Java >> Java tutorial >  >> Java

En trinvis vejledning til Kubernetes

Java

I dette indlæg vil vi diskutere, hvordan du bruger Kubernetes, og hvordan du implementerer din mikrotjeneste i en Kubernetes-klynge. Jeg vil dække det grundlæggende, så hvis du er nybegynder, vil dette være en god trin-for-trin guide til at lære Kubernetes. Da vi skal bygge en dockeriseret containerapplikation, kan du komme i gang med den komplette guide til brug af docker-compose.

Hvad er Kubernetes?

I henhold til den originale kilde – Kubernetes er et open source-system til automatisering af udrulning, skalering og styring af containeriserede applikationer. Kubernetes er en containerorkestreringsplatform.

Dybest set, når du har en containeriseret applikation, kan du implementere den på Kubernetes-klyngen. Specifikt indeholder klyngen flere maskiner eller servere.

I en traditionel Java-applikation ville man bygge en jar-fil og installere den på en servermaskine. Nogle gange kan du endda implementere den samme applikation på flere maskiner for at skalere vandret. Frem for alt, med Kubernetes behøver du ikke at bekymre dig om servermaskiner. Det er klart, at Kubernetes tillader oprettelse af en klynge af maskiner og implementering af din container-applikation på den.

Derudover kan man med Kubernetes

  • Orkestrer containere på tværs af flere værtsmaskiner
  • Styr og automatiser implementering af applikationer
  • Administrer serverressourcer bedre
  • Sundhedstjek og selvhelbred dine apps med automatisk placering, automatisk genstart, automatisk replikering og automatisk skalering

Desuden indeholder Kubernetes-klyngen to dele

  1. Et kontrolplan
  2. En computermaskine

Især knudepunkterne (fysiske maskiner eller virtuelle maskiner) interagerer med kontrolplanet ved hjælp af Kubernetes API.

  • Kontrolplan – Samlingen af ​​processer, der styrer Kubernetes-knuderne.
  • Noder – Maskinerne, der udfører de opgaver, der er tildelt gennem processer.
  • Pod – En gruppe af en eller flere containere installeret på en enkelt node. Alle containere på pod'en deler ressourcerne og IP-adresserne.
  • Service – En abstrakt måde at eksponere en applikation, der kører på et sæt Pods, som en netværkstjeneste.
  • Kubelet – Kubelet er en primær nodeagent, der kører på hver node. Den læser containermanifesterne og holder styr på containere, der starter og kører.
  • kubectl – Kommandolinjekonfigurationsværktøjet til Kubernetes

Hvordan opretter man en klynge?

Derefter, afhængigt af dit miljø, download Minikube. Jeg bruger et Windows-miljø.

minikube start vil oprette en ny Kubernetes-klynge.

Til sidst, hvis du vil se på et mere detaljeret dashboard, kan du bruge kommandoen minikube dashboard . Denne kommando vil starte et Kubernetes-dashboard i browseren. (http://127.0.0.1:60960/api/v1/namespaces/kubernetes-dashboard/services/http:kubernetes-dashboard:/proxy/ )

Demo til at implementere en mikrotjeneste til Kubernetes

Opret en containeriseret mikroservice

Lad os desuden skabe en simpel mikrotjeneste, som vi til sidst vil implementere i klyngen. Jeg vil bruge Spring Boot til at oprette en mikrotjeneste, der returnerer en liste over produkter til et REST API-kald.

Denne mikroservice returnerer en liste over produkter under opkaldet.


package com.betterjavacode.kubernetesdemo.controllers;

import com.betterjavacode.kubernetesdemo.dtos.ProductDTO;
import com.betterjavacode.kubernetesdemo.services.ProductService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.List;

@RestController
@RequestMapping("/v1/products")
public class ProductController
{
    @Autowired
    public ProductService productService;

    @GetMapping
    public List getAllProducts()
    {
        return productService.getAllProducts();
    }
}

Desuden ProductService vil have en enkelt metode til at returnere alle produkter.


package com.betterjavacode.kubernetesdemo.services;

import com.betterjavacode.kubernetesdemo.dtos.ProductDTO;
import org.springframework.stereotype.Component;

import java.util.ArrayList;
import java.util.List;

@Component
public class ProductService
{

    public List getAllProducts ()
    {
        List productDTOS = new ArrayList<>();

        ProductDTO toothbrushProductDTO = new ProductDTO("Toothbrush", "Colgate", "A toothbrush " +
                "for " +
                "all");
        ProductDTO batteryProductDTO = new ProductDTO("Battery", "Duracell", "Duracell batteries " +
                "last long");

        productDTOS.add(toothbrushProductDTO);
        productDTOS.add(batteryProductDTO);
        return productDTOS;

    }
}

Jeg bruger bevidst ikke nogen database og bruger en statisk liste over produkter til at returnere til demoformål.

Før du opbygger et docker-image, skal du køre

minikube docker-env

minikube docker-env | Invoke-Expression

Byg docker-billede

Lad os bygge et docker-image til vores mikrotjeneste, som vi lige har oprettet. Først skal du oprette en dockerfil i dit projekts rodbibliotek.

FROM openjdk:8-jdk-alpine
VOLUME /tmp
COPY ./build/libs/*.jar app.jar
ENTRYPOINT ["java", "-jar", "/app.jar"]

Lad os nu bygge et docker-billede ved hjælp af denne dockerfil.

docker build -t kubernetesdemo .

Dette vil oprette en kubernetesdemo docker-billede med det seneste tag.

Hvis du vil prøve dette billede på dit lokale miljø, kan du køre det med kommandoen:

docker run --name kubernetesdemo -p 8080:8080 kubernetesdemo

Dette vil køre vores mikroservice Docker-image på port 8080. Uanset hvad, før vi implementerer til kubernetes, skal vi skubbe dette docker-image til docker-hub-beholderregistret, så Kubernetes kan trække fra hub'en.

docker login – Log ind på docker hub med dit brugernavn og adgangskode fra din terminal.

Når login er lykkedes, skal vi oprette et tag til vores docker-billede.

docker tag kubernetesdemo username/kubernetesdemo:1.0.0 .

Brug dit brugernavn til docker hub.

Nu vil vi skubbe dette billede til docker-hub med kommandoen:

docker push username/kubernetesdemo:1.0.0 .

Nu er vores docker-image i containerregistret.

Kubernetes-implementering

Kubernetes er en containerorkestrator designet til at køre komplekse applikationer med skalerbarhed i tankerne.

Containerorkestratoren styrer containerne omkring serverne. Det er den simple definition. Som tidligere nævnt, vil vi oprette en lokal klynge på Windows-maskine med kommandoen

minikube start .

Når klyngen starter, kan vi se på klyngeinfoen med kommandoen

kubectl get cluster-info .

For nu at implementere vores mikroservice i Kubernetes, vil vi bruge den deklarative grænseflade.

Erklærer implementeringsfil

Opret en kube mappe under dit projekts rodmappe. Tilføj en yaml fil kaldet deployment.yaml .

Denne fil vil se ud som nedenfor:

apiVersion: v1
kind: Service
metadata:
  name: kubernetesdemo
spec:
  selector:
    app: kubernetesdemo
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: kubernetesdemo
spec:
  selector:
    matchLabels:
      app: kubernetesdemo
  replicas: 3
  template:
    metadata:
      labels:
        app: kubernetesdemo
    spec:
      containers:
      - name: kubernetesdemo
        image: username/kubernetesdemo:1.0.0
        imagePullPolicy: IfNotPresent
        ports:
        - containerPort: 8080

Om kort tid vil vi gennemgå hver sektion af denne installationsfil.

Når vi kører denne installationsfil, vil den oprette en container og en service. Lad os først se på Deployment .

apiVersion: apps/v1 
kind: Deployment 
metadata: 
  name: kubernetesdemo

Disse linjer erklærer, at vi opretter en ressource af typen Deployment bruger version v1 og navnet kubernetesdemo .

replicas: 3 angive, at vi kører 3 replikaer af containeren. Men beholderen her er ikke andet end en pod. En pod er en indpakning omkring en beholder. En enkelt pod kan køre flere containere, mens containerne deler podens ressourcer. Bare husk, at poden er den mindste installationsenhed i Kubernetes.

template.metadata.labels definerer etiketten for den pod, der kører containeren til applikationen kubernetesdemo .

Sektionen af ​​containers er selvforklarende. Hvis det ikke er klart, er det her, vi erklærer om containeren, at vi planlægger at køre i en pod. Navnet på containeren kubernetesdemo og billedet af denne container er username/kubernetesdemo:1.0.0 . Vi vil afsløre port 8080 på denne container, hvor vores mikroservice vil køre.

Servicedefinition

Lad os uden forsinkelse se på den tidligere del af denne installationsfil.

apiVersion: v1
kind: Service
metadata:
  name: kubernetesdemo
spec:
  selector:
    app: kubernetesdemo
  ports:
    - port: 80
      targetPort: 8080
  type: LoadBalancer

Her opretter vi en ressource af typen Service .

En tjeneste tillader pods at kommunikere med andre pods. Men det giver også eksterne brugere adgang til pods. Uden en service kan man ikke få adgang til pods. Den slags service, vi definerer her, vil give os mulighed for at videresende trafikken til en bestemt pod.

I denne erklæring, spec.selector.app giver os mulighed for at vælge poden med navnet kubernetesdemo . Service vil afsløre denne pod. En anmodning, der kommer til port 80, vil blive videresendt til målporten på 8080 for den valgte Pod.

Og endelig er tjenesten af ​​typen LoadBalancer . Grundlæggende vil en tjeneste i vores Kubernetes-klynge fungere som en belastningsbalancer, der videresender trafikken til forskellige pods. En Service sikrer kontinuerlig tilgængelighed af applikationer. Hvis en pod går ned, starter en anden pod, og tjenesten sørger for at dirigere trafikken i overensstemmelse hermed.

Service holder styr på alle de replikaer, du kører i klyngen.

Kørsel af implementeringen

Indtil videre har vi bygget en implementeringskonfiguration til at skabe ressourcer i vores klynge. Men vi har ikke implementeret noget endnu.

Brug

for at køre implementeringen

kubectl apply -f deployment.yaml

Du kan også bare køre

kubectl apply -f kube og den henter implementeringsfiler fra kube bibliotek.

Svaret for denne kommando vil være

service/kubernetesdemo configured
deployment.apps/kubernetesdemo created

kubectl get pods vil vise status for pods

For nu at se den faktiske situation med klynge og tjenester, der kører, kan vi bruge

minikube dashboard .

Vi kan se, at der kører 3 pods for vores mikrotjeneste kubernetesdemo .

Hvis du kører kubectl get services , vil vi se alle tjenesterne køre. For nu at få adgang til vores applikation skal vi finde tjenestens url. I dette tilfælde er navnet på tjenesten (ikke mikrotjeneste) kubernetesdemo .

minikube service kubernetesdemo --url vil vise en URL i terminalvinduet.

Brug nu denne URL http://127.0.0.1:49715/v1/products , kan vi se outputtet i browseren

Hvordan skalerer man?

Med Kubernetes er det nemt at skalere applikationen. Vi bruger allerede 3 replikaer, men vi kan reducere eller øge antallet med en kommando:

kubectl scale --replicas=4 deployment/kubernetesdemo .

Hvis du har dashboardet, vil du se den 4. replika starte. Det er alt.

Konklusion

Wow, vi har dækket meget i denne demo. Jeg håber, jeg var i stand til at forklare de grundlæggende begreber i Kubernetes trin for trin. Hvis du vil vide mere, så kommenter på dette opslag. Hvis du ønsker at lære Spring Security-koncepter, kan du købe min bog Simplifying Spring Security.


Java tag