Hur man distribuerar applikationer i Kubernetes

Kubernetes framstår som en av de mest populära plattformarna för automatisering av utrullning, skalning och drift av applikationscontainrar på ett kluster av värdar, eller noder. Dess förmåga att hantera containeriserade applikationer har gjort det till ett oumbärligt verktyg i modern mjukvaruutveckling.

Denna artikel utforskar ett av de mest centrala koncepten inom Kubernetes: deployment. Vi kommer att gå igenom hur en deployment fungerar, samt hur du skapar, uppdaterar och tar bort den, vilket ger en grundläggande förståelse för dess användning.

Vad är en Deployment?

En Deployment är en typ av objekt i Kubernetes som används för att starta Pods. Kubernetes rekommenderar starkt att använda deployments för tillståndslösa applikationer. Att hantera Pods manuellt skulle vara omständligt och ohanterligt, särskilt vid hantering av många Pods. Genom att använda en deployment förenklas hanteringen av poddar avsevärt.

Genom att deklarera en deployment i YAML skapas inte bara Pods, utan det säkerställs också att de hålls uppdaterade och i drift. Det underlättar även automatisk skalning av applikationer. En deployment används således för att skala, distribuera och återställa olika versioner av dina applikationer i Pods. Den ger ett effektivt sätt att organisera och underhålla dina applikationer.

En deployment anger för Kubernetes hur många kopior av en Pod som ska köras, och Kubernetes tar hand om resten. När en deployment skapas, genererar den automatiskt ett ReplicaSet baserat på deployment-konfigurationen. Styrenheten som hanterar ReplicaSet skapar sedan de faktiska Podsen.

Fördelarna med att använda en deployment framför att direkt skapa ett ReplicaSet inkluderar:

• Historikhantering: Varje ändring av objektet (genom en ”apply” eller ”edit”) lagras som en version, vilket skapar en säkerhetskopia av tidigare versioner.
• Utrullnings- och återställningshantering: Möjligheten att återgå till en tidigare konfiguration, som är kopplat till historiken.

Skapa en Deployment

Det finns huvudsakligen två metoder för att skapa en deployment i Kubernetes:

Imperativ Metod

Kubernetes API:er erbjuder ett direkt och imperativt sätt att skapa resurser, utan att kräva konfigurationsfiler i YAML-format. Med den imperativa metoden specificerar vi vad vi vill åstadkomma och Kubernetes ser till att det genomförs. Fokus ligger på resultatet och inte på den specifika processen.

För att skapa en deployment imperativt kan du använda kommandot:

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

Deklarativ Metod

I den deklarativa metoden beskriver vi önskat tillstånd i en YAML-fil. Kubernetes läser sedan filen och skapar resurserna exakt som de har definierats. Detta ger en tydligare översikt över den konfiguration som används.

För att använda den deklarativa metoden, skapar du en YAML-fil, till exempel:

YAML-fil för deployment med namnet new_deployment.yaml:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  #Antalet Pod-kopior
  replicas: 3
  #Väljer Pods som ska hanteras
  selector:
    #Matchar de definierade etiketterna
    matchLabels:
      deploy: example
  template:
    metadata:
      #Definierar etiketter på Podsen
      labels:
        deploy: example
    spec:
      containers:
        - name: nginx
          image: nginx:1.20.2

I denna YAML-fil definieras först Kubernetes API-version, typen av objekt (Deployment), och namnet på deployment. Under specifikationsavsnittet definieras replicas, som anger antalet Pod-instanser deployment ska underhålla.

En selector-etikett identifierar poddarna som tillhör denna deployment. Detta säkerställer att alla Pods som matchar etiketten hanteras av deployment.

Mall-objektet (template) definierar hur Pods ska skapas. Det fungerar som en ritning för de Pods som skapas av deployment. Specifikationen för en vanlig Pod finns inuti mallen.

Denna deployment kommer att distribuera Nginx-bilder till Pods med de angivna etiketterna. Det är viktigt att fundera på den arkitektur du vill använda om du vill placera flera containrar i samma pod. En Pod är den minsta enheten för skalbarhet i Kubernetes.

För att skapa deployment med hjälp av filen new_deployment.yaml, använd kommandot:

kubectl apply -f new_deployment.yaml

Efter en kort stund kan du verifiera statusen med:

kubectl get all

Hämta och Uppdatera Deployment

Observera att både Pods, deployment och en ReplicaSet har skapats. En deployment skapar och hanterar alltid en ReplicaSet. För att få detaljerad information om din deployment kan du använda kommandot:

kubectl describe deployment nginx-deployment

Nu ser du en utförlig beskrivning av deployment, inklusive den använda strategin för att skapa/ersätta Pods vid uppdatering. Standardstrategin är RollingUpdate.

Strategin RollingUpdate möjliggör en stegvis migrering från en applikationsversion till en annan. Det är den vanligaste strategin i Kubernetes.

Andra strategier inkluderar:

• Återskapa: Avslutar alla nuvarande Pod-instanser och skapar om dem med den nya versionen.
• Blå/grön: Skapar två identiska miljöer. Applikationen körs i den blå, medan den nya versionen körs i den gröna.

• Canary: Stegvis utrullning av en ny version till en liten delmängd av användare.

När du använder RollingUpdate kan du konfigurera beteendet för uppdateringen med parametrarna maxSurge och maxUnavailable.

• maxSurge låter dig definiera hur många fler Pods som kan skapas utöver det nuvarande antalet repliker.
• maxUnavailable anger hur många Pods som kan vara otillgängliga under uppdateringen, beroende på det konfigurerade antalet repliker.

Dessa konfigurationer tillåter dig att optimera både QoS (Quality of Service) och hastigheten på dina utrullningar, beroende på dina applikationskrav och autoskalningsinställningar.

Nu kan vi skala Pods till 10 och ändra Nginx-bildtaggen till den senaste versionen.

kubectl scale deployment nginx-deployment --replicas=10

Notera att fem behållare skapas initialt och att fem av totalt tio Pods är tillgängliga.

Efter en stund, använd följande kommando:

kubectl get all

Nu ser du att alla Pods har skapats och att behållarna körs korrekt.

Ta bort din Deployment

För att ta bort en Kubernetes deployment kan du använda något av följande kommandon:

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

Helm: Förenkla Deployment

När du distribuerar komplexa applikationer som använder tiotals eller hundratals Kubernetes-resurser kan kubectl bli otympligt. Därför utvecklades Helm, ett pakethanteringsverktyg för Kubernetes. Helm bygger på kubectl och förenklar applikationsdeployment. Det förenklar hanteringen av Kubernetes-applikationer genom att paketera konfigurationsfiler i så kallade ”charts”.

I Helm kallas en applikation för ”release”. En release är associerad med en ”chart”, en samling konfigurationsfiler i YAML-format som innehåller globala variabler och mallar som definierar Kubernetes-resurser.

Slutsats

Deployment är ett viktigt koncept inom Kubernetes. Det ger ett kraftfullt verktyg för hantering av applikationer, men det är viktigt att vara noggrann vid konfigureringen för att undvika oväntat beteende. För att utforska mer avancerade konfigurationer hänvisas till Kubernetes dokumentation. Det är viktigt att lära sig grunderna för att sedan gå vidare till mer avancerade koncept inom Kubernetes.

Om du vill lära dig mer om Kubernetes kan du även undersöka några av de bästa Kubernetes-handledningarna.