Ku­ber­netes De­ploy­ment

Die Er­stel­lung eines er­folg­rei­chen Ku­ber­netes De­ploy­ments ist ent­schei­dend für die ef­fi­zi­en­te Ver­wal­tung von Container-An­wen­dun­gen. In diesem Tutorial erhalten Sie Einblicke in die grund­le­gen­den Schritte und Best Practices, um ein robustes De­ploy­ment in einer Ku­ber­netes-Umgebung zu gestalten.

Was ist ein Ku­ber­netes De­ploy­ment?

Ein Ku­ber­netes De­ploy­ment ist ein es­sen­zi­el­les Konzept innerhalb der Ku­ber­netes-Plattform, das die Be­reit­stel­lung und Ver­wal­tung von An­wen­dun­gen in Con­tai­nern ver­ein­facht. Dieser Kon­troll­me­cha­nis­mus agiert als Ver­mitt­ler zwischen der Kon­fi­gu­ra­ti­on und ihrer tat­säch­li­chen Aus­füh­rung im Ku­ber­netes-Cluster. Sie de­fi­nie­ren den ge­wünsch­ten Zustand Ihrer An­wen­dun­gen, ein­schließ­lich Re­pli­ka­ti­ons­de­tails, Container-Images und Kon­fi­gu­ra­ti­ons­ein­stel­lun­gen.

Das Ku­ber­netes De­ploy­ment übernimmt daraufhin die au­to­ma­ti­sier­te Be­reit­stel­lung, or­ga­ni­siert Container in Ku­ber­netes Pods und verteilt sie auf ver­füg­ba­re Res­sour­cen im Cluster. Zu­sätz­lich erlaubt es Rolling Updates, um Ak­tua­li­sie­run­gen schritt­wei­se durch­zu­füh­ren und Aus­fall­zei­ten zu mi­ni­mie­ren. Auto-Scaling-Funk­tio­nen ge­währ­leis­ten eine dy­na­mi­sche Anpassung der Anzahl laufender Instanzen basierend auf der aktuellen Last.

Die Er­stel­lung eines Ku­ber­netes De­ploy­ments kann auf zwei grund­le­gen­den Methoden basieren:

• Im­pe­ra­ti­ve Methode
• De­kla­ra­ti­ve Methode

Ku­ber­netes De­ploy­ment erstellen: Im­pe­ra­ti­ve Methode

Bei der im­pe­ra­ti­ven Methode geben Sie spe­zi­fi­sche Befehle an, um direkt die ge­wünsch­ten Aktionen durch­zu­füh­ren. Dies kann das Erstellen von Res­sour­cen, wie Pods und Services, oder das Ak­tua­li­sie­ren von Kon­fi­gu­ra­tio­nen umfassen. Der im­pe­ra­ti­ve Weg eignet sich gut für situative oder ex­pe­ri­men­tel­le An­for­de­run­gen.

Der folgende Befehl erstellt ein Ku­ber­netes De­ploy­ment mit dem Namen nginx-deployment und kon­fi­gu­riert es so, dass es einen Nginx-Webserver in einem Container aus dem of­fi­zi­el­len Nginx-Image auf Port 80 be­reit­stellt.

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

Auch wenn der im­pe­ra­ti­ve Ansatz schnell um­zu­set­zen ist, hat er einige Nachteile. Die Schritte in der im­pe­ra­ti­ven Methode sind direkt an die aktuelle Situation gebunden, was die Wie­der­hol­bar­keit von Aktionen er­schwe­ren kann. Das bedeutet, dass das erneute Ausführen desselben Befehls mög­li­cher­wei­se nicht immer denselben Zustand erzeugt, ins­be­son­de­re wenn sich die Aus­gangs­si­tua­ti­on geändert hat.

Schritt-für-Schritt-Anleitung: De­kla­ra­ti­ve Methode

Im Vergleich zum im­pe­ra­ti­ven Weg folgt die de­kla­ra­ti­ve Methode einem abs­trak­te­ren Ansatz. Sie legen den ge­wünsch­ten Zustand der Anwendung in einer Kon­fi­gu­ra­ti­ons­da­tei fest, und Ku­ber­netes sorgt dafür, dass das Cluster diesem ent­spricht. Hierbei be­schrei­ben Sie, was erreicht werden soll, und Ku­ber­netes übernimmt die Umsetzung und Auf­recht­erhal­tung dieses Zustands.

Schritt 1: YAML-Kon­fi­gu­ra­ti­ons­da­tei erstellen

Als Erstes öffnen wir einen Text­edi­tor und erstellen die YAML-Datei nginx-deployment.yaml, um die Kon­fi­gu­ra­ti­on für das Ku­ber­netes De­ploy­ment zu de­fi­nie­ren:

apiVersion: apps/v1
kind: Deployment
metadata:
    name: nginx-deployment
spec:
    replicas: 3
    selector:
        matchLabels:
            app: nginx
    template:
        metadata:
            labels:
                app: nginx
        spec:
            containers:
            - name: nginx-container
                image: nginx
                ports:
                - containerPort: 80

Im Abschnitt spec legen wir die ge­wünsch­te Kon­fi­gu­ra­ti­on fest. Mit replicas: 3 geben wir an, dass das De­ploy­ment drei Re­pli­ka­tio­nen (Pods) der Anwendung erstellen soll. Der Abschnitt selector definiert, wie die Pods aus­ge­wählt werden, wobei hier app=nginx als Aus­wahl­kri­te­ri­um dient. Das template ist die Vorlage für die zu er­stel­len­den Pods, inklusive Labels. Innerhalb von containers wird der Container nginx-container kon­fi­gu­riert, der das Nginx-Image nutzt und auf Port 80 lauscht.

Schritt 2: Anwenden der Kon­fi­gu­ra­ti­on

Führen Sie den folgenden Befehl in der Kom­man­do­zei­le aus, um die Kon­fi­gu­ra­ti­on auf das Cluster an­zu­wen­den:

kubectl apply -f nginx-deployment.yaml

Die Option -f gibt den Pfad zur YAML- oder JSON-Datei an, die die Kon­fi­gu­ra­ti­on für die Ku­ber­netes-Res­sour­cen enthält.

Schritt 3: Status des De­ploy­ments über­prü­fen

Dieser Schritt gibt Auf­schluss darüber, ob das Ku­ber­netes De­ploy­ment er­folg­reich erstellt wurde und wie viele Pods davon aktuell be­reit­ste­hen.

kubectl get deployments nginx-deployment

Die Ausgabe zeigt uns:

NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment         3/3            3           3    2m

• READY: Gibt die Anzahl der aktuell laufenden Pods im Ver­hält­nis zur ge­wünsch­ten Anzahl wieder.
• UP-TO-DATE: Zeigt die Anzahl der Pods, die mit der neuesten Kon­fi­gu­ra­ti­on ak­tua­li­siert wurden.
• AVAILABLE: Listet die Anzahl der Pods auf, die verfügbar sind und Anfragen ent­ge­gen­neh­men können.
• AGE: Gibt an, wie lange das De­ploy­ment bereits läuft.

Schritt 4: Zu­sätz­li­che In­for­ma­tio­nen anzeigen

Mit folgendem Befehl erhalten Sie de­tail­lier­te In­for­ma­tio­nen zu Ihrem Ku­ber­netes De­ploy­ment, der ver­wen­de­ten Stra­te­gien, der aktuellen und ge­wünsch­ten Re­pli­ka­tio­nen und der Selector-Labels.

kubectl describe deployment nginx-deployment

Die Ausgabe lautet:

Name:                               nginx-deployment
Namespace:                    default
CreationTimestamp:      Thu, 22 Feb 2024 12:34:56 +0000
Labels:                              <none>
Annotations:                   deployment.kubernetes.io/revision: 1
Selector:                           app=nginx
Replicas:                           3 desired | 3 updated | 3 total | 3 available | 0 unavailable
StrategyType:                  RollingUpdate
MinReadySeconds:         0
RollingUpdateStrategy:  25% max unavailable, 25% max surge

Die Ak­tua­li­sie­rungs­stra­te­gie ist als Rolling Update kon­fi­gu­riert, mit maximal 25 % Nicht­ver­füg­bar­keit und einem Anstieg von bis zu 25 % zu­sätz­li­chen Pods während eines Updates.

Schritt 5: Ska­lie­rung des De­ploy­ments

Um die Anzahl der Pods in einem Ku­ber­netes De­ploy­ment an­zu­pas­sen, verwenden Sie den Befehl kubectl scale.

kubectl scale deployment nginx-deployment --replicas=2

Nach Aus­füh­rung dieses Befehls wird Ku­ber­netes das De­ploy­ment ak­tua­li­sie­ren und si­cher­stel­len, dass die ge­wünsch­te Anzahl von Re­pli­ka­tio­nen vorhanden ist. In unserem Beispiel re­du­zie­ren wir die Anzahl der laufenden Pods auf 2.

Ku­ber­netes-De­ploy­ment-Stra­te­gien

Die De­ploy­ment-Stra­te­gien in Ku­ber­netes de­fi­nie­ren, wie Än­de­run­gen in einer Anwendung in einem Cluster im­ple­men­tiert werden.

• Rolling De­ploy­ment (Standard): Die Rolling-Strategie ist die Stan­dard­me­tho­de für De­ploy­ments in Ku­ber­netes. Dabei werden neue Pods schritt­wei­se be­reit­ge­stellt, während alte Pods nach und nach entfernt werden. Dies er­mög­licht eine kon­ti­nu­ier­li­che Ver­füg­bar­keit während des Ak­tua­li­sie­rungs­pro­zes­ses.
• Recreate De­ploy­ment: Bei dieser Strategie werden alle be­stehen­den Pods zuerst entfernt, und an­schlie­ßend werden die ak­tua­li­sier­ten Pods gestartet. Diese Methode kann zu einem vor­über­ge­hen­den Ausfall der Dienste führen, da während des Recreate-Prozesses keine Pods verfügbar sind.
• Blue/Green De­ploy­ment: Hier werden zwei Sets von Pods (Blue und Green) erstellt, wobei eines die aktuelle Version der Anwendung re­prä­sen­tiert und das andere die neue Version. Durch die Zuweisung spe­zi­fi­scher Labels zu diesen Pods kann der Verkehr nahtlos zwischen den beiden Versionen um­ge­lei­tet werden. So können Sie schnell zwischen den beiden Versionen wechseln und Rollbacks einfach durch­füh­ren.

Ku­ber­netes De­ploy­ment Rollback

Wenn ein Fehler in der neuesten Version Ihrer Anwendung auftritt, ist es ent­schei­dend, so schnell wie möglich ein Rollback durch­zu­füh­ren. In Ku­ber­netes können Sie den Rollback-Prozess einleiten, indem Sie die Re­vi­si­ons­his­to­rie Ihres De­ploy­ments über­prü­fen und bei Bedarf zu einer vor­he­ri­gen Version zu­rück­keh­ren.

Re­vi­si­ons­his­to­rie kon­trol­lie­ren

Um die Re­vi­si­ons­his­to­rie Ihres De­ploy­ments an­zu­zei­gen, nutzen Sie das Kommando:

kubectl rollout history deployment/nginx-deployment

Rollback zum vor­he­ri­gen Stand

Dieser Befehl führt ein Rollback auf die vorherige Revision durch, die als stabil angesehen wird:

kubectl rollout undo deployment/nginx-deployment

Rollback zu einer be­stimm­ten Version

Wenn Sie zu einer spe­zi­fi­schen Revision zu­rück­keh­ren möchten, geben Sie folgendes Kommando und die ge­wünsch­te Re­vi­si­ons­num­mer an:

kubectl rollout undo deployment/nginx-deployment --to-revision=1