Sådan implementeres applikationer i Kubernetes

Kubernetes er en af de mest populære automatiseringsplatforme til implementering, skalering og drift af applikationscontainere på en klynge af værter eller noder.

Denne artikel vil diskutere et af de centrale objekter i Kubernetes: implementering. Målet er at forstå dens adfærd og hvordan man opretter, opdaterer og sletter den.

Indholdsfortegnelse

Hvad er en implementering?

En Deployment er et af de objekter, der bruges til at starte Pods. Kubernetes bedste praksis opfordrer til brug af implementeringer til statsløse applikationer. Uden en implementering skal du manuelt oprette, opdatere og slette flere Pods, hvilket ville være kedeligt og umuligt for mange Pods.

En implementering erklærer et enkelt objekt i YAML, som ikke kun opretter Pods, men også sikrer, at de er opdaterede og kører. Du kan også nemt automatisk skalere dine applikationer ved hjælp af en implementering på Kubernetes. En implementering bruges således til at skalere, implementere og rulle tilbage versioner af dine applikationer i Pods.

En implementering fortæller også Kubernetes, hvor mange kopier af en Pod vi vil køre, og Kubernetes tager sig af resten. Den tilknyttede controller vil oprette et ReplicaSet fra din konfiguration, når du opretter en implementering. Den controller, der er knyttet til ReplicaSet’et, vil oprette en række Pods fra ReplicaSet-konfigurationen.

Fordelene ved at bruge en implementering i stedet for direkte at oprette et ReplicaSet er:

Historik af objektet: hver ændring i objektet (via en “anvend” eller en “rediger”) vil oprette en sikkerhedskopi af den tidligere version.
Udrulning og rollback-styring: Du kan gå tilbage på en konfiguration i forbindelse med forrige punkt.

10 gode ressourcer til at lære Big Data og Hadoop

Oprettelse af en implementering

Der er to metoder, vi kan bruge til at oprette en Kubernetes-implementering:

Imperativ metode

Kubernetes API’erne tillader en mere direkte og tvingende tilgang uden at kræve konfigurationsfiler eller YAML-formaterede manifester. I denne tilgang er alt, hvad vi skal gøre, at sige, hvad vi vil have gjort, og Kubernetes vil tage ansvaret for at definere, hvad der skal gøres for at opnå det forventede resultat.

For at bruge den imperative metode skal du blot bruge kommandoen nedenfor:

kubectl create deployment nginx-deployment --image nginx --port=80

Deklarativ metode

I denne metode skal du deklarere alt, og når du bruger denne kode, læser Kubernetes bare dine definitioner og opretter nøjagtigt som præsenteret eller deklareret.

For at bruge deklarativ implementering skal du oprette en YAML-fil.

YAML-fil til implementering med navnet new_deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  #Specifies the number of Pod Copies
  replicas: 3
 #Selects the Pod to be managed by the deployment
  selector:
    #Matches the defined labels
    matchLabels:
      deploy: example
  template:
    metadata:
      #Specifies the labels on the Pod.
       labels:
         deploy: example
    spec:
      containers:
        - name: nginx
          image: nginx:1.20.2

I denne YAML-fil, efter at have defineret Kubernetes API-versionen, den type objekt, du opretter, og navnet på installationen, er der spec-afsnittet. I dette afsnit definerer du først replika-nøglen, som angiver antallet af Pod-forekomster, som implementeringen skal holde aktiv.

Brug en vælgeretiket til at identificere Pods i implementeringen. Til dette kan du bruge implementeringsetiketten, som fortæller, at alle pods, der matcher disse etiketter, er grupperet i implementering.

Derefter har du skabelonobjektet, hvor du har en Pod-model inde i din implementeringsspecifikation. Når implementeringen opretter Pods, opretter den dem ved hjælp af denne skabelon. Specifikationen for en almindelig pod kan findes under skabelonnøglen.

10 Top Warehouse Management Systems (WMS) til at organisere dit lager

Med denne implementering vil Nginx-billeder med etiketter blive implementeret til Pods. Desuden skal du også være forsigtig på dette punkt, og Pod’en er skalerbarheden i Kubernetes, så du skal tænke på det mønster, du vil bruge, hvis du lægger flere beholdere i den samme Pod.

Anvend derefter filen new_deployment.yaml Yaml, brug følgende kommando:

kubectl apply -f new_deployment.yaml

Efter et par sekunder kan du få implementeringsstatussen ved at bruge følgende:

kubectl get all

Hent og opdater implementering

Bemærk, at du har oprettet pods, implementeringen og også et replikasæt. Så en implementering opretter og administrerer altid et replikasæt. Nu kan du bruge følgende kommando til at beskrive implementeringen:

kubectl describe deployment nginx-deployment

Nu har du en fuldstændig beskrivelse af implementeringen. Det fremhæver den strategi, der bruges til at oprette/genopbygge pods, når en opdatering er blevet defineret som RollingUpdate.

RollingUpdate-strategien giver mulighed for en velordnet migrering af én version af en applikation til en nyere version. Det er standardstrategien, der bruges i Kubernetes.

Udover dette har vi også følgende strategier:

Genopret: Afslutter de aktuelt kørende Pod-forekomster og ‘genskaber’ dem med den nye version;
Blå/grøn: Denne strategi skaber to separate, men identiske miljøer. I det blå miljø kører applikationen, som den er, mens applikationen i det grønne miljø kører, som den vil være i fremtiden;

Canary: En implementeringsstrategi, hvor en delmængde af brugere er involveret i den trinvise udgivelse af en applikation eller tjeneste.

Hvis du vælger “rullende opdatering”, kan du konfigurere dens adfærd omkring det ønskede antal replikaer.

maxSurge giver dig mulighed for at angive (i procent eller absolutte tal) hvor mange Pods den kan oprette ud over antallet af replikaer, der aktuelt er konfigureret.
maxUnavailable giver dig mulighed for at angive (i procent eller absolutte tal) hvor mange Pods der kan være “utilgængelige” under opdateringen, afhængigt af antallet af konfigurerede replikaer.

Lav et stamtræ med disse 8 bedste værktøjer

Afhængigt af din applikation og din autoscaler vil disse konfigurationer give dig mulighed for at sikre QoS eller fremskynde dine implementeringer.

Dernæst skal du skalere Pods til 10 og ændre Nginx-billedmærket til det seneste.

kubectl scale deployment nginx-deployment --replicas=10

Bemærk, at vi har 5 containere under oprettelse, og ud af 10 Pods har vi 5 tilgængelige.

Efter et par sekunder skal du bruge følgende kommando:

kubectl get all

Her kan du se, at alle Pods er oprettet, og containerne kører.

Sletning af din implementering

For at slette en Kubernetes-implementering kan du bruge følgende kommandoer:

kubectl delete deploy nginx-deployment 
kubectl delete deploy new_deployment.yaml

Styr: Forenkle implementeringer

Når du ønsker at implementere en kompleks applikation, der bruger titusvis eller endda hundredvis af Kubernetes-ressourcer, bliver kubectl-værktøjet uegnet, hvorfor Helm-værktøjet blev udviklet. Helm er en pakkehåndtering for Kubernetes, der bygger på kubectl og forenkler applikationsimplementeringer.

I Helm-vokabularet kaldes en applikation en udgivelse. Det er forbundet med et diagram, dvs. en samling af konfigurationsfiler i YAML-format, der indeholder globale variabler og skabeloner, der beskriver Kubernetes-ressourcer.

Konklusion

Implementeringen er et væsentligt Kubernetes-objekt. Da en stor magt indebærer et stort ansvar, skal du være forsigtig, når du konfigurerer den eller risikere at få uventet adfærd. For at gå videre med implementeringskonfigurationerne kan du henvise til Kubernetes-dokumentationen.

Du kan også udforske nogle af de bedste Kubernetes-tutorials for at lære fra bunden og blive en ekspert.