Kubernetes-Anwendungen erkunden und debuggen

Einführung

In diesem Lab werden Sie Kubernetes-Anwendungen erkunden und debuggen. Sie werden mithilfe von Minikube einen lokalen Kubernetes-Cluster starten, eine Beispielanwendung bereitstellen und verschiedene Debugging-Techniken lernen, wie das Prüfen der Anwendungs-Konfiguration, das Anzeigen von Logs, das Ausführen von Befehlen innerhalb von Pods und das Untersuchen von Cluster-Events. Diese Fähigkeiten sind für die Entwicklung und Fehlerbehebung von auf Kubernetes basierenden Anwendungen unerlässlich.

Kubernetes Cluster starten

In diesem Schritt lernst du, wie du einen lokalen Kubernetes Cluster mit Minikube startest und verifizierst. Dies ist ein wesentlicher erster Schritt für die Entwicklung und das Testen von Kubernetes-Anwendungen auf deinem lokalen Rechner.

Starte zuerst den Minikube Cluster:

minikube start

Beispielausgabe:

😄  minikube v1.29.0 on Ubuntu 22.04
✨  Automatically selected the docker driver
📌  Using Docker driver with root permissions
🔥  Creating kubernetes in kubernetes cluster
🔄  Restarting existing kubernetes cluster
🐳  Preparing Kubernetes v1.26.1 on Docker 20.10.23 ...
🚀  Launching Kubernetes ...
🌟  Enabling addons: storage-provisioner, default-storageclass
🏄  Done! kubectl is now configured to use "minikube" cluster and "default" namespace

Überprüfe nun den Clusterstatus mit mehreren Befehlen:

minikube status
kubectl get nodes

Beispielausgabe:

minikube
type: Control Plane
host: Running
kubelet: Running
apiserver: Running
kubeconfig: Configured

NAME       STATUS   ROLES           AGE   VERSION
minikube   Ready    control-plane   1m    v1.26.1

Diese Befehle bestätigen, dass:

Minikube erfolgreich läuft
Ein lokaler Kubernetes Cluster erstellt wurde
Der Cluster einsatzbereit ist
Du einen Single-Node-Cluster mit Control-Plane-Funktionen hast

Lass uns den Kontext (context) des Clusters überprüfen, um sicherzustellen, dass du mit dem richtigen Cluster verbunden bist:

kubectl config current-context

Beispielausgabe:

minikube

Dies verifiziert, dass kubectl so konfiguriert ist, dass es den Minikube Cluster verwendet.

Illustration for Kubernetes cluster setup

Eine Beispielanwendung bereitstellen (Deploy)

In diesem Schritt lernen Sie, wie Sie eine einfache Kubernetes-Anwendung mithilfe von YAML-Manifesten erstellen und bereitstellen (deploy). Wir erstellen sowohl einen Pod als auch ein Deployment, um verschiedene Möglichkeiten der Anwendungsbereitstellung zu demonstrieren.

Erstellen Sie zunächst ein Verzeichnis für Ihre Kubernetes-Manifeste:

mkdir -p ~/project/k8s-manifests
cd ~/project/k8s-manifests

Erstellen Sie ein einfaches NGINX Pod-Manifest:

nano nginx-pod.yaml

Fügen Sie den folgenden Inhalt hinzu:

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  labels:
    app: nginx
spec:
  containers:
    - name: nginx
      image: nginx:latest
      ports:
        - containerPort: 80

Drücken Sie Ctrl+X, dann Y und Enter, um zu speichern und zu beenden.

Erstellen Sie nun ein Deployment-Manifest:

nano nginx-deployment.yaml

Fügen Sie den folgenden Inhalt hinzu:

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

Wenden Sie die Manifeste an, um die Ressourcen zu erstellen:

kubectl apply -f nginx-pod.yaml
kubectl apply -f nginx-deployment.yaml

Beispielausgabe:

pod/nginx-pod created
deployment.apps/nginx-deployment created

Überprüfen Sie die erstellten Ressourcen:

kubectl get pods
kubectl get deployments

Beispielausgabe:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          1m
nginx-deployment-xxx-yyy            1/1     Running   0          1m
nginx-deployment-xxx-zzz            1/1     Running   0          1m
nginx-deployment-xxx-www            1/1     Running   0          1m

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

Warten Sie, bis das Deployment die Replikate erstellt hat. Die Spalte READY sollte 3/3 anzeigen, wenn alle Replikate bereit sind.

Hauptunterschiede zwischen Pod und Deployment:

Pod: Einzelne Instanz einer Anwendung
Deployment: Verwaltet mehrere Replikate und bietet Self-Healing (Selbstheilung)

Überprüfen Sie die Anwendungs-Konfiguration

In diesem Schritt lernen Sie, wie Sie die Konfigurationsdetails von Kubernetes-Deployments und Pods mithilfe verschiedener kubectl-Befehle untersuchen und abrufen. Das Verständnis, wie man Ressourcen-Konfigurationen prüft, ist für die Fehlerbehebung und das Verständnis der Einrichtung Ihrer Anwendung von entscheidender Bedeutung.

Zunächst rufen wir die YAML-Konfiguration des Pods ab, den wir im vorherigen Schritt erstellt haben:

kubectl get pod nginx-pod -o yaml

Beispielausgabe (teilweise):

apiVersion: v1
kind: Pod
metadata:
  name: nginx-pod
  namespace: default
  labels:
    app: nginx
spec:
  containers:
    - image: nginx:latest
      imagePullPolicy: Always
      name: nginx
      ports:
        - containerPort: 80
      resources: {}
  dnsPolicy: ClusterFirst
  restartPolicy: Always

Jetzt untersuchen wir die Deployment-Konfiguration:

kubectl get deployment nginx-deployment -o yaml

Beispielausgabe (teilweise):

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

Verwenden Sie kubectl describe, um detailliertere Informationen über Ressourcen zu erhalten:

kubectl describe pod nginx-pod
kubectl describe deployment nginx-deployment

Beispielausgabe für describe pod (teilweise):

Name:         nginx-pod
Namespace:    default
Priority:     0
Node:         minikube/172.17.0.2
Start Time:   [timestamp]
Labels:       app=nginx
Annotations:  <none>
Status:       Running
IP:           172.17.0.5
Containers:
  nginx:
    Container ID:   docker://[container-id]
    Image:          nginx:latest
    Image ID:       docker-pullable://nginx@[image-digest]
    Port:           80/TCP
    Host Port:      0/TCP
    State:          Running
    Ready:          True
    Restart Count:  0
Conditions:
  Type              Status
  Initialized       True
  Ready             True
  ContainersReady   True
  PodScheduled      True

Sie können auch die JSON-Ausgabe für maschinenlesbarere Formate verwenden:

kubectl get pod nginx-pod -o json

Wichtige Aspekte, die Sie bei der Prüfung von Konfigurationen beachten sollten:

Ressourcen-Metadaten (Name, Labels, Namespace)
Container-Image und Ports
Anzahl der Replikate (für Deployments)
Ressourcen-Status und -Bedingungen

Anzeigen der Logs einer Anwendung

In diesem Schritt lernen Sie, wie Sie die Logs von Kubernetes-Pods mithilfe von kubectl logs anzeigen und untersuchen. Das Anzeigen von Logs ist von entscheidender Bedeutung, um das Verhalten einer Anwendung zu verstehen, Probleme zu debuggen und die Leistung der Anwendung zu überwachen.

Zunächst listen Sie die verfügbaren Pods auf, um sicherzustellen, dass Sie mit den richtigen Ressourcen arbeiten:

kubectl get pods

Beispielausgabe:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          20m
nginx-deployment-xxx-yyy            1/1     Running   0          20m
nginx-deployment-xxx-zzz            1/1     Running   0          20m
nginx-deployment-xxx-www            1/1     Running   0          20m

Zeigen Sie die Logs eines bestimmten Pods an:

## Anzeigen der Logs für den nginx-pod
kubectl logs nginx-pod

Beispielausgabe:

/docker-entrypoint.sh: /docker-entrypoint.d/ is not empty, will attempt to perform configuration
/docker-entrypoint.sh: Looking for shell scripts in /docker-entrypoint.d/
/docker-entrypoint.sh: Launching /docker-entrypoint.d/10-listen-on-ipv6-by-default.sh
...
2023/xx/xx [notice] xxxx#x: signal process started

Zeigen Sie die Logs der Pods eines Deployments an:

## Anzeigen der Logs für einen bestimmten Pod im Deployment
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')
kubectl logs $POD_NAME

Entdecken Sie zusätzliche Optionen zum Anzeigen von Logs:

## Anzeigen der letzten 50 Logzeilen
kubectl logs nginx-pod --tail=50

## Echtzeitverfolgung der Logs
kubectl logs -f nginx-pod

Beispiel für die Echtzeitverfolgung von Logs:

[real-time log output will be displayed]

Beenden Sie die Echtzeitansicht der Logs, indem Sie Ctrl + C drücken.

Für Pods mit mehreren Containern geben Sie den Containernamen an:

## Wenn ein Pod mehrere Container hat
kubectl logs nginx-pod -c nginx

Wichtige Techniken zum Anzeigen von Logs:

Anzeigen des gesamten Log-Verlaufs
Begrenzen der Logzeilen
Echtzeitverfolgung von Logs
Angeben des Containers in Pods mit mehreren Containern

Debuggen mit kubectl exec

In diesem Schritt lernen Sie, wie Sie kubectl exec verwenden, um Befehle innerhalb eines Kubernetes-Pods auszuführen. Dies ist für das Debuggen und die Untersuchung von Container-Umgebungen von entscheidender Bedeutung.

Zunächst überprüfen Sie die verfügbaren Pods:

kubectl get pods

Beispielausgabe:

NAME                                READY   STATUS    RESTARTS   AGE
nginx-pod                           1/1     Running   0          30m
nginx-deployment-xxx-yyy            1/1     Running   0          30m
nginx-deployment-xxx-zzz            1/1     Running   0          30m
nginx-deployment-xxx-www            1/1     Running   0          30m

Führen Sie eine interaktive Shell im nginx-pod aus:

kubectl exec -it nginx-pod -- /bin/bash

Beispielinteraktionen innerhalb des Pods:

## Überprüfen der Nginx-Konfiguration
cat /etc/nginx/nginx.conf

## Überprüfen der installierten Pakete
apt update && apt list --installed

## Verlassen der Pod-Shell
exit

Stellen Sie sicher, dass Sie die interaktive Shell mit exit verlassen, um zum Shell-Prompt zurückzukehren.

Führen Sie bestimmte Befehle aus, ohne eine interaktive Shell zu öffnen:

## Überprüfen der Nginx-Version
kubectl exec nginx-pod -- nginx -v

## Auflisten der Dateien im Web-Root
kubectl exec nginx-pod -- ls /usr/share/nginx/html

Für Deployment-Pods wählen Sie einen bestimmten Pod aus:

## Abrufen des Namens eines Pods aus dem Deployment
POD_NAME=$(kubectl get pods -l app=nginx | grep nginx-deployment | head -n 1 | awk '{print $1}')

## Ausführen von Befehlen im Pod des Deployments
kubectl exec -it $POD_NAME -- /bin/bash

Wichtige Techniken mit kubectl exec:

Ausführen von interaktiven Shells
Ausführen bestimmter Befehle
Untersuchung der internen Struktur von Pods
Debuggen von Container-Konfigurationen

Verwenden Sie kubectl describe zur Fehlerbehebung

In diesem Schritt lernen Sie, wie Sie kubectl describe verwenden, um Kubernetes-Ressourcen zu diagnostizieren und zu debuggen. Dies bietet detaillierte Einblicke in den Status von Pods, Deployments und Cluster-Komponenten.

Zunächst erstellen wir ein problematisches Deployment, um die Fehlersuche zu demonstrieren:

cd ~/project/k8s-manifests
nano problematic-deployment.yaml

Fügen Sie den folgenden Inhalt hinzu:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: debug-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: debug
  template:
    metadata:
      labels:
        app: debug
    spec:
      containers:
        - name: debug-container
          image: non-existent-image:latest
          ports:
            - containerPort: 80

Wenden Sie das Deployment an:

kubectl apply -f problematic-deployment.yaml

Jetzt verwenden Sie kubectl describe, um das Deployment zu untersuchen:

kubectl describe deployment debug-deployment

Beispielausgabe:

Name:                   debug-deployment
Namespace:              default
CreationTimestamp:      [timestamp]
Labels:                 <none>
Annotations:            deployment.kubernetes.io/revision: 1
Selector:               app=debug
Replicas:               2 desired | 0 available | 2 total | 2 unavailable
StrategyType:           RollingUpdate
MinReadySeconds:        0
RollingUpdateStrategy:  25% max unavailable, 25% max surge
Conditions:
  Type           Status   Reason
  ----           ------   ------
  Available      False    MinimumReplicasUnavailable
  Progressing    False    ProgressDeadlineExceeded
OldReplicaSets:  <none>
NewReplicaSet:   debug-deployment-xxx (2/2 replicas created)
Events:
  Type     Reason                    Age   From                   Message
  ----     ------                    ----  ----                   -------
  Warning  FailedCreate              1m    deployment-controller  Failed to create pod
  Normal   ScalingReplicaSet         1m    deployment-controller  Scaled up replica set

Beschreiben Sie die Pods, um weitere Details zu erhalten:

kubectl describe pods -l app=debug

Beispielausgabe:

Name:           debug-deployment-xxx-yyy
Namespace:      default
Priority:       0
Node:           minikube/172.17.0.2
Start Time:     [timestamp]
Labels:         app=debug
Annotations:    <none>
Status:         Pending
Conditions:
  Type           Status
  Initialized    True
  Ready          False
  PodScheduled   True
Events:
  Type     Reason                  Age   From               Message
  ----     ------                  ----  ----               -------
  Warning  FailedCreatePodSandBox  1m    kubelet            Failed to create pod sandbox
  Warning  Failed                  1m    kubelet            Failed to pull image

Beschreiben Sie die Knoten-Ressourcen:

kubectl describe nodes minikube

Wichtige Techniken zur Fehlerbehebung:

Identifizieren des Status von Deployments und Pods
Anzeigen detaillierter Fehlermeldungen
Verstehen, warum Ressourcen nicht laufen
Überprüfen der Bedingungen von Knoten und Cluster

Untersuchen Sie Cluster-Ereignisse (kubectl get events) für Hinweise und Zeitachsen

In diesem Schritt lernen Sie, wie Sie kubectl get events verwenden, um clusterweite Ereignisse zu untersuchen, Systemaktivitäten zu verstehen und Probleme in Ihrer Kubernetes-Umgebung zu diagnostizieren.

Zunächst zeigen Sie alle Cluster-Ereignisse an:

kubectl get events

Beispielausgabe:

LAST SEEN   TYPE      REASON                 OBJECT                           MESSAGE
10m         Warning   FailedCreate           deployment/debug-deployment     Failed to create pod
5m          Normal    Scheduled              pod/nginx-pod                   Successfully assigned default/nginx-pod to minikube
3m          Normal    Pulled                 pod/nginx-deployment-xxx-yyy    Container image "nginx:latest" already present on machine

Filtern Sie Ereignisse nach Namespace:

kubectl get events -n default

Verwenden Sie detailliertere Optionen zum Anzeigen von Ereignissen:

## Beobachten Sie Ereignisse in Echtzeit
kubectl get events -w

## Holen Sie Ereignisse sortiert nach Zeitstempel
kubectl get events --sort-by='.metadata.creationTimestamp'

Erstellen Sie ein benutzerdefiniertes Szenario zur Ereigniserzeugung:

cd ~/project/k8s-manifests
nano event-test-deployment.yaml

Fügen Sie den folgenden Inhalt hinzu:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: event-test
spec:
  replicas: 3
  selector:
    matchLabels:
      app: event-test
  template:
    metadata:
      labels:
        app: event-test
    spec:
      containers:
        - name: nginx
          image: nginx:latest
          resources:
            limits:
              cpu: "100m"
              memory: "50Mi"

Wenden Sie das Deployment an und untersuchen Sie die Ereignisse:

kubectl apply -f event-test-deployment.yaml
kubectl get events

Erweiterte Ereignisfilterung:

## Filtern Sie nach Ereignistyp
kubectl get events --field-selector type=Warning

## Filtern Sie nach einer bestimmten Ressource
kubectl get events --field-selector involvedObject.kind=Deployment

Wichtige Techniken zur Ereignisuntersuchung:

Anzeigen von clusterweiten Ereignissen
Filtern von Ereignissen nach Namespace
Echtzeitbeobachtung von Ereignissen
Identifizieren von Warn- und Fehlereignissen

Zusammenfassung

In diesem Lab haben Sie gelernt, wie Sie einen lokalen Kubernetes-Cluster mit Minikube starten und überprüfen können. Dies ist ein wesentlicher erster Schritt für die Entwicklung und das Testen von Kubernetes-Anwendungen auf Ihrem lokalen Rechner. Sie haben auch gelernt, wie Sie eine einfache Kubernetes-Anwendung mithilfe von YAML-Manifesten erstellen und bereitstellen können, einschließlich eines Pods und eines Deployments. Darüber hinaus haben Sie verschiedene Befehle zur Inspektion der Konfiguration, zum Anzeigen von Logs, zum Debuggen und zur Fehlerbehebung der Anwendung untersucht und so ein besseres Verständnis dafür gewonnen, wie Sie Kubernetes-Anwendungen verwalten und überwachen können.