Kubernetes Deployment

Die Erstellung eines erfolgreichen Kubernetes Deployments ist entscheidend für die effiziente Verwaltung von Container-Anwendungen. In diesem Tutorial erhalten Sie Einblicke in die grundlegenden Schritte und Best Practices, um ein robustes Deployment in einer Kubernetes-Umgebung zu gestalten.

Was ist ein Kubernetes Deployment?

Ein Kubernetes Deployment ist ein essenzielles Konzept innerhalb der Kubernetes-Plattform, das die Bereitstellung und Verwaltung von Anwendungen in Containern vereinfacht. Dieser Kontrollmechanismus agiert als Vermittler zwischen der Konfiguration und ihrer tatsächlichen Ausführung im Kubernetes-Cluster. Sie definieren den gewünschten Zustand Ihrer Anwendungen, einschließlich Replikationsdetails, Container-Images und Konfigurationseinstellungen.

Das Kubernetes Deployment übernimmt daraufhin die automatisierte Bereitstellung, organisiert Container in Kubernetes Pods und verteilt sie auf verfügbare Ressourcen im Cluster. Zusätzlich erlaubt es Rolling Updates, um Aktualisierungen schrittweise durchzuführen und Ausfallzeiten zu minimieren. Auto-Scaling-Funktionen gewährleisten eine dynamische Anpassung der Anzahl laufender Instanzen basierend auf der aktuellen Last.

Tipp

Mit Managed Kubernetes von IONOS genießen Sie die Vorteile der Container-Orchestrierung, ohne sich um aufwendige administrative Aufgaben wie Monitoring, Updates und Pflegeroutinen kümmern zu müssen. Dank des kostenfreien Management-Services von IONOS Cloud steigern Sie Ihre Produktivität und sparen wertvolle Ressourcen.

Die Erstellung eines Kubernetes Deployments kann auf zwei grundlegenden Methoden basieren:

  • Imperative Methode
  • Deklarative Methode

Kubernetes Deployment erstellen: Imperative Methode

Bei der imperativen Methode geben Sie spezifische Befehle an, um direkt die gewünschten Aktionen durchzuführen. Dies kann das Erstellen von Ressourcen, wie Pods und Services, oder das Aktualisieren von Konfigurationen umfassen. Der imperative Weg eignet sich gut für situative oder experimentelle Anforderungen.

Der folgende Befehl erstellt ein Kubernetes Deployment mit dem Namen nginx-deployment und konfiguriert es so, dass es einen Nginx-Webserver in einem Container aus dem offiziellen Nginx-Image auf Port 80 bereitstellt.

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

Auch wenn der imperative Ansatz schnell umzusetzen ist, hat er einige Nachteile. Die Schritte in der imperativen Methode sind direkt an die aktuelle Situation gebunden, was die Wiederholbarkeit von Aktionen erschweren kann. Das bedeutet, dass das erneute Ausführen desselben Befehls möglicherweise nicht immer denselben Zustand erzeugt, insbesondere wenn sich die Ausgangssituation geändert hat.

Schritt-für-Schritt-Anleitung: Deklarative Methode

Im Vergleich zum imperativen Weg folgt die deklarative Methode einem abstrakteren Ansatz. Sie legen den gewünschten Zustand der Anwendung in einer Konfigurationsdatei fest, und Kubernetes sorgt dafür, dass das Cluster diesem entspricht. Hierbei beschreiben Sie, was erreicht werden soll, und Kubernetes übernimmt die Umsetzung und Aufrechterhaltung dieses Zustands.

Schritt 1: YAML-Konfigurationsdatei erstellen

Als Erstes öffnen wir einen Texteditor und erstellen die YAML-Datei nginx-deployment.yaml, um die Konfiguration für das Kubernetes Deployment zu definieren:

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
yaml

Im Abschnitt spec legen wir die gewünschte Konfiguration fest. Mit replicas: 3 geben wir an, dass das Deployment drei Replikationen (Pods) der Anwendung erstellen soll. Der Abschnitt selector definiert, wie die Pods ausgewählt werden, wobei hier app=nginx als Auswahlkriterium dient. Das template ist die Vorlage für die zu erstellenden Pods, inklusive Labels. Innerhalb von containers wird der Container nginx-container konfiguriert, der das Nginx-Image nutzt und auf Port 80 lauscht.

Schritt 2: Anwenden der Konfiguration

Führen Sie den folgenden Befehl in der Kommandozeile aus, um die Konfiguration auf das Cluster anzuwenden:

kubectl apply -f nginx-deployment.yaml
shell

Die Option -f gibt den Pfad zur YAML- oder JSON-Datei an, die die Konfiguration für die Kubernetes-Ressourcen enthält.

Schritt 3: Status des Deployments überprüfen

Dieser Schritt gibt Aufschluss darüber, ob das Kubernetes Deployment erfolgreich erstellt wurde und wie viele Pods davon aktuell bereitstehen.

kubectl get deployments nginx-deployment
shell

Die Ausgabe zeigt uns:

NAME                   READY   UP-TO-DATE   AVAILABLE   AGE
nginx-deployment         3/3            3           3    2m
shell
  • READY: Gibt die Anzahl der aktuell laufenden Pods im Verhältnis zur gewünschten Anzahl wieder.
  • UP-TO-DATE: Zeigt die Anzahl der Pods, die mit der neuesten Konfiguration aktualisiert wurden.
  • AVAILABLE: Listet die Anzahl der Pods auf, die verfügbar sind und Anfragen entgegennehmen können.
  • AGE: Gibt an, wie lange das Deployment bereits läuft.

Schritt 4: Zusätzliche Informationen anzeigen

Mit folgendem Befehl erhalten Sie detaillierte Informationen zu Ihrem Kubernetes Deployment, der verwendeten Strategien, der aktuellen und gewünschten Replikationen und der Selector-Labels.

kubectl describe deployment nginx-deployment
shell

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
shell

Die Aktualisierungsstrategie ist als Rolling Update konfiguriert, mit maximal 25 % Nichtverfügbarkeit und einem Anstieg von bis zu 25 % zusätzlichen Pods während eines Updates.

Schritt 5: Skalierung des Deployments

Um die Anzahl der Pods in einem Kubernetes Deployment anzupassen, verwenden Sie den Befehl kubectl scale.

kubectl scale deployment nginx-deployment --replicas=2
shell

Nach Ausführung dieses Befehls wird Kubernetes das Deployment aktualisieren und sicherstellen, dass die gewünschte Anzahl von Replikationen vorhanden ist. In unserem Beispiel reduzieren wir die Anzahl der laufenden Pods auf 2.

Kubernetes-Deployment-Strategien

Die Deployment-Strategien in Kubernetes definieren, wie Änderungen in einer Anwendung in einem Cluster implementiert werden.

  • Rolling Deployment (Standard): Die Rolling-Strategie ist die Standardmethode für Deployments in Kubernetes. Dabei werden neue Pods schrittweise bereitgestellt, während alte Pods nach und nach entfernt werden. Dies ermöglicht eine kontinuierliche Verfügbarkeit während des Aktualisierungsprozesses.
  • Recreate Deployment: Bei dieser Strategie werden alle bestehenden Pods zuerst entfernt, und anschließend werden die aktualisierten Pods gestartet. Diese Methode kann zu einem vorübergehenden Ausfall der Dienste führen, da während des Recreate-Prozesses keine Pods verfügbar sind.
  • Blue/Green Deployment: Hier werden zwei Sets von Pods (Blue und Green) erstellt, wobei eines die aktuelle Version der Anwendung repräsentiert und das andere die neue Version. Durch die Zuweisung spezifischer Labels zu diesen Pods kann der Verkehr nahtlos zwischen den beiden Versionen umgeleitet werden. So können Sie schnell zwischen den beiden Versionen wechseln und Rollbacks einfach durchführen.

Kubernetes Deployment Rollback

Wenn ein Fehler in der neuesten Version Ihrer Anwendung auftritt, ist es entscheidend, so schnell wie möglich ein Rollback durchzuführen. In Kubernetes können Sie den Rollback-Prozess einleiten, indem Sie die Revisionshistorie Ihres Deployments überprüfen und bei Bedarf zu einer vorherigen Version zurückkehren.

Revisionshistorie kontrollieren

Um die Revisionshistorie Ihres Deployments anzuzeigen, nutzen Sie das Kommando:

kubectl rollout history deployment/nginx-deployment
shell

Rollback zum vorherigen Stand

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

kubectl rollout undo deployment/nginx-deployment
shell

Rollback zu einer bestimmten Version

Wenn Sie zu einer spezifischen Revision zurückkehren möchten, geben Sie folgendes Kommando und die gewünschte Revisionsnummer an:

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

Falls Sie neu in Kubernetes einsteigen, empfehlen wir Ihnen das Kubernetes Tutorial aus unserem Digital Guide.

Managed Kubernetes von IONOS

Der einfache Weg zur Verwaltung von Container-Workloads. Vollautomatisiertes Setup von Kubernetes Clustern und maximale Transparenz und Kontrolle der K8s Cluster.

Persistent Storage
K8s 24/7 voll supportet
Automatisiertes Cluster Setup