Kubernetes Run-Befehl

Einführung

Der Befehl kubectl run ist eine einfache Methode, um einen Pod in Kubernetes zu erstellen. Da moderne Kubernetes-Versionen kubectl run nicht mehr zum Erstellen von Deployments oder Jobs verwenden, kombiniert dieses Lab kubectl run mit den jeweils dedizierten Befehlen für diese Ressourcen. Dieses Lab soll Anfängern helfen zu verstehen, welcher Befehl für welchen Workload-Typ zu verwenden ist.

Am Ende dieses Labs werden Sie gelernt haben, wie man:

Einen Minikube-Cluster startet und überprüft.
Einen Pod mit kubectl run erstellt.
Ein Deployment mit mehreren Replikaten erstellt.
Einen Job für die Stapelverarbeitung (Batch Processing) erstellt und untersucht.
Ressourcen bereinigt, um den Cluster sauber zu halten.

Starten des Minikube-Clusters

Bevor Sie Ressourcen erstellen können, benötigen Sie einen laufenden Kubernetes-Cluster. Minikube ist eine leichtgewichtige Kubernetes-Umgebung, die auf Ihrem lokalen Rechner ausgeführt wird.

Navigieren Sie zu Ihrem Arbeitsverzeichnis:

Öffnen Sie das Terminal und wechseln Sie in den Standard-Projektordner:
```
cd /home/labex/project
```
Starten Sie Minikube:

Starten Sie Minikube, um einen Kubernetes-Cluster zu initialisieren:
```
minikube start
```
- Dieser Befehl richtet einen Single-Node-Kubernetes-Cluster auf Ihrem lokalen Rechner ein.
- Je nach Systemleistung kann der Start von Minikube einige Minuten dauern.
Überprüfen Sie, ob Minikube läuft:

Prüfen Sie den Status des Minikube-Clusters:
```
minikube status
```
- Achten Sie darauf, dass Komponenten wie kubelet und apiserver als Running aufgeführt sind.
- Falls der Cluster nicht läuft, führen Sie minikube start erneut aus.

Sollten beim Starten von Minikube Probleme auftreten, verwenden Sie minikube delete, um die Umgebung bei Bedarf zurückzusetzen.

Erkunden des Befehls kubectl run

Der Befehl kubectl run wird verwendet, um ein bestimmtes Image in einem Pod zu erstellen und auszuführen. Er bietet zahlreiche Optionen, um das Verhalten, die Umgebung und die Spezifikationen des Pods anzupassen.

Führen Sie den folgenden Befehl aus, um die verfügbaren Optionen für kubectl run anzuzeigen:

kubectl run -h

Sie erhalten die folgende Ausgabe:

Create and run a particular image in a pod.

Examples:
## Start a nginx pod
kubectl run nginx --image=nginx

## Start a hazelcast pod and let the container expose port 5701
kubectl run hazelcast --image=hazelcast/hazelcast --port=5701

## Start a hazelcast pod and set environment variables "DNS_DOMAIN=cluster" and "POD_NAMESPACE=default" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --env="DNS_DOMAIN=cluster" --env="POD_NAMESPACE=default"

## Start a hazelcast pod and set labels "app=hazelcast" and "env=prod" in the container
kubectl run hazelcast --image=hazelcast/hazelcast --labels="app=hazelcast,env=prod"

## Dry run; print the corresponding API objects without creating them
kubectl run nginx --image=nginx --dry-run=client

## Start a nginx pod, but overload the spec with a partial set of values parsed from JSON
kubectl run nginx --image=nginx --overrides='{ "apiVersion": "v1", "spec": { ... } }'

## Start a busybox pod and keep it in the foreground, don't restart it if it exits
kubectl run -i -t busybox --image=busybox --restart=Never

## Start the nginx pod using the default command, but use custom arguments (arg1 .. argN) for that command
kubectl run nginx --image=nginx -- <arg1> <arg2> ... <argN>

## Start the nginx pod using a different command and custom arguments
kubectl run nginx --image=nginx --command -- <cmd> <arg1> ... <argN>

Erstellen eines Pods

Ein Pod ist die kleinste bereitstellbare Einheit in Kubernetes und repräsentiert einen oder mehrere Container, die gemeinsam ausgeführt werden. In diesem Schritt erstellen wir einen Pod, der einen Nginx-Webserver ausführt.

Erstellen Sie den Pod:

Führen Sie den folgenden Befehl aus, um einen Pod namens nginx-pod zu erstellen:
```
kubectl run nginx-pod --image=nginx
```
- Die Option --image gibt das zu verwendende Container-Image an. Hier verwenden wir das offizielle Nginx-Image.
Überprüfen Sie den Pod:

Prüfen Sie, ob der Pod läuft:
```
kubectl get pods
```
- Suchen Sie in der Ausgabe nach nginx-pod.
- Die Spalte STATUS sollte Running anzeigen, sobald der Pod bereit ist.

Falls der Pod-Status Pending anzeigt, lädt Kubernetes möglicherweise noch das Container-Image herunter. Warten Sie einen Moment und führen Sie kubectl get pods erneut aus.

Erstellen eines Deployments und Skalieren von Replikaten

Ein Deployment verwaltet eine Gruppe von Pods und stellt sicher, dass sie wie gewünscht ausgeführt werden. Es ist nützlich für die Skalierung und Aktualisierung von Anwendungen.

Erstellen Sie das Deployment:

Führen Sie den folgenden Befehl aus, um ein Deployment namens nginx-deployment zu erstellen:
```
kubectl create deployment nginx-deployment --image=nginx
```
- Die Option --image gibt das zu verwendende Container-Image an.
Skalieren Sie das Deployment auf 3 Replikate:

Da das Flag --replicas veraltet ist, skalieren wir das Deployment stattdessen mit kubectl scale.

Verwenden Sie den Befehl kubectl scale, um die Anzahl der Replikate anzupassen:
```
kubectl scale deployment nginx-deployment --replicas=3
```
- Dies stellt sicher, dass drei Pods als Teil des Deployments ausgeführt werden.
Überprüfen Sie das Deployment und seine Replikate:

Prüfen Sie den Status des Deployments und der Pods:
```
kubectl get deployments
kubectl get pods
```
- Stellen Sie sicher, dass das Deployment in der Spalte READY 3 Replikate anzeigt.
- Überprüfen Sie, ob in der Ausgabe von kubectl get pods drei Pods aufgelistet sind.

Wenn sich ein Pod nicht im Status Running befindet, liegt dies möglicherweise an unzureichenden Cluster-Ressourcen. Überprüfen Sie die Pod-Ereignisse mit:

kubectl describe pod <pod-name>

Erstellen eines Jobs

In diesem Schritt erstellen Sie einen Kubernetes-Job, um eine kurze Stapelaufgabe auszuführen. Ein Job verfolgt den erfolgreichen Abschluss, daher ist er die richtige Ressource, wenn ein Befehl ausgeführt werden und sich danach beenden soll, anstatt wie ein langlebiger Pod dauerhaft zu laufen.

Erstellen Sie den Job

Führen Sie den folgenden Befehl aus, um einen Job namens busybox-job zu erstellen:

kubectl create job busybox-job --image=busybox -- echo "Hello from Kubernetes"

kubectl create job erstellt eine Job-Ressource anstelle eines eigenständigen Pods.
Der Befehl echo definiert die Aufgabe, die der Job ausführen soll.

Überprüfen Sie den Job-Status

Führen Sie den folgenden Befehl aus, um den Job zu überprüfen:

kubectl get jobs

Erwartete Ausgabe:

NAME          COMPLETIONS   DURATION   AGE
busybox-job   1/1           5s         10s

COMPLETIONS: Zeigt an, dass der Job einmal erfolgreich abgeschlossen wurde (1/1).
Falls noch kein Job aufgelistet ist, warten Sie einige Sekunden und führen Sie kubectl get jobs erneut aus.

Überprüfen Sie den Pod des Jobs

Da ein Job innerhalb eines Pods ausgeführt wird, verwenden Sie den folgenden Befehl, um den Pod zu überprüfen:

kubectl get pods

Erwartete Ausgabe:

NAME                      READY   STATUS      RESTARTS   AGE
busybox-job-abcde         0/1     Completed   0          30s

Der Pod-Name enthält ein generiertes Suffix, da er vom Job verwaltet wird.
Das Feld STATUS sollte Completed anzeigen, was bedeutet, dass der Pod des Jobs erfolgreich beendet wurde.

Überprüfen Sie die Job-Ausgabe

Untersuchen Sie die Logs des Jobs, um die Ausgabe zu verifizieren:

kubectl logs job/busybox-job

Erwartete Ausgabe:

Hello from Kubernetes

Dies bestätigt, dass der Job erfolgreich ausgeführt wurde.

Bereinigung

Um Ihren Cluster sauber zu halten, löschen Sie die Ressourcen, die Sie während des Labs erstellt haben.

Löschen Sie die Ressourcen:

Führen Sie die folgenden Befehle aus:

kubectl delete pod nginx-pod
kubectl delete deployment nginx-deployment
kubectl delete job busybox-job

Überprüfen Sie die Bereinigung:

Stellen Sie sicher, dass keine Ressourcen mehr vorhanden sind:
```
kubectl get pods
kubectl get deployments
```
- Stellen Sie sicher, dass die von Ihnen erstellten Ressourcen nicht mehr in der Ausgabe aufgeführt sind.

Zusammenfassung

In diesem Lab haben Sie gelernt, wie man:

Einen Minikube-Cluster startet und überprüft.
kubectl run verwendet, um einen Pod zu erstellen, und dedizierte Befehle nutzt, um Deployments und Jobs zu erstellen.
Ressourcen bereinigt, um den Cluster organisiert zu halten.

Sie haben zudem gesehen, wie Kubernetes unterschiedliche Befehle für verschiedene Workload-Typen verwendet. Durch das Üben dieser Schritte legen Sie ein solides Fundament für fortgeschrittenere Kubernetes-Workflows.