Kubernetes Einstiegshandbuch: Effiziente Verwaltung containerisierter Anwendungen

Kubernetes ist zurzeit die beliebteste Plattform für die Orchestrierung von Containern. Sie bietet eine Lösung zur automatisierten Bereitstellung, Skalierung und Verwaltung containerisierter Anwendungen. Dieser Artikel bietet Anfängern und fortgeschrittenen Entwicklern einen praktischen Einstieg, um die Kernkonzepte und praktischen Anwendungen von Kubernetes schnell zu erlernen.

Was ist Kubernetes?

Kubernetes (häufig abgekürzt als K8s) ist eine Open-Source-Plattform zur Automatisierung der Bereitstellung, Skalierung und Verwaltung containerisierter Anwendungen. Es wurde von Google entwickelt und der Cloud Native Computing Foundation (CNCF) gespendet. Das Hauptziel von Kubernetes ist es, das Lebenszyklusmanagement von Anwendungen zu vereinfachen und die hohe Verfügbarkeit und automatisierte Verwaltung des Systems sicherzustellen.

Die Kernkomponenten von Kubernetes

1. Pod

Ein Pod ist die kleinste Bereitstellungseinheit in Kubernetes und kann einen oder mehrere Container enthalten. Jeder Pod teilt sich Netzwerk und Speicher und eignet sich für den Betrieb eng verbundener Dienste.

apiVersion: v1
kind: Pod
metadata:
  name: my-app-pod
spec:
  containers:
  - name: my-app-container
    image: nginx

2. Deployment

Das Deployment verwaltet den Lebenszyklus von Pods, stellt sicher, dass eine bestimmte Anzahl von Pods im Betrieb ist, und ermöglicht Versionskontrolle und Updates.

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

3. Service

Der Service bietet einen stabilen Zugangspunkt, der es anderen Pods oder externen Benutzern ermöglicht, auf die laufenden Pods zuzugreifen.

apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
    - port: 80
      targetPort: 80

Vorteile von Kubernetes

• Automatisierte Verwaltung: Kubernetes kann containerisierte Anwendungen automatisch bereitstellen, skalieren und verwalten, wodurch manuelle Eingriffe reduziert und die Fehlerwahrscheinlichkeit verringert wird.
• Hohe Verfügbarkeit: Durch ReplicaSets stellt Kubernetes sicher, dass genügend Pod-Instanzen im Betrieb sind. Wenn eine Instanz ausfällt, wird sie automatisch neu gestartet oder ersetzt.
• Lastverteilung: Kubernetes bietet integrierte Lastverteilungsfunktionen, die den Diensten Traffic zuweisen und eine effiziente Ressourcennutzung sicherstellen.

So starten Sie schnell mit Kubernetes

1. Vorbereitung der Umgebung

Zuerst müssen Sie eine Kubernetes-Umgebung einrichten. Dies kann auf verschiedene Arten erfolgen, z. B. durch die Verwendung von Minikube für lokale Tests oder durch das Einrichten eines Clusters bei einem Cloud-Anbieter (z. B. Google Kubernetes Engine, AWS EKS, Azure AKS).

Installation von Kubernetes mit Minikube

• Installieren Sie Minikube und kubectl

# Installieren Sie Minikube (genaue Installationsanweisungen finden Sie in der offiziellen Minikube-Dokumentation)
brew install minikube

# Installieren Sie kubectl
brew install kubectl

• Starten Sie Minikube

minikube start

2. Bereitstellung der ersten Anwendung

Nehmen wir Nginx als Beispiel. Wir können Nginx bereitstellen, indem wir ein Deployment und einen Service definieren.

# Erstellen Sie die Datei deployment.yaml
cat  deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nginx-deployment
spec:
  replicas: 2
  selector:
    matchLabels:
      app: nginx
  template:
    metadata:
      labels:
        app: nginx
    spec:
      containers:
      - name: nginx
        image: nginx
        ports:
        - containerPort: 80
EOF

# Wenden Sie das Deployment an
kubectl apply -f deployment.yaml

# Erstellen Sie die Datei service.yaml
cat  service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
    - protocol: TCP
      port: 80
      targetPort: 80
  type: NodePort
EOF

# Wenden Sie den Service an
kubectl apply -f service.yaml

3. Zugriff auf die Anwendung

Jedes Mal, wenn Sie einen Service vom Typ NodePort erstellen, weist Kubernetes ihm einen Port zu. Sie können die Zugriffsadresse mit folgendem Befehl abrufen:

minikube service nginx-service --url

Greifen Sie mit einem Browser auf die angezeigte URL zu, um die Willkommensseite von Nginx zu sehen.

Häufige Fehler und Debugging

Während der Verwendung von Kubernetes können Sie auf einige häufige Probleme stoßen, wie z. B. den Status CrashLoopBackOff eines Pods. Dies ist kein Fehler, sondern eine Sicherheitsmaßnahme. Kubernetes startet einen Pod nach einem Absturz nicht endlos neu, sondern erhöht die Verzögerung zwischen den Neustarts, um ein Durcheinander im System zu vermeiden.

Sie können die Protokolle des Pods mit folgendem Befehl einsehen, um beim Debugging zu helfen:

kubectl logs 

Fazit

Kubernetes ist ein leistungsstarkes Tool zur Verwaltung von Containern. Durch das Verständnis seiner Kernkonzepte und gängigen Befehle können Sie cloud-native Anwendungen effizienter verwalten und bereitstellen. Mit der Verbreitung von Cloud-Computing und Container-Technologien wird das Lernen von Kubernetes neue Möglichkeiten für Ihre berufliche Entwicklung eröffnen. Wir hoffen, dass dieses Handbuch Ihnen auf Ihrer Lernreise mit Kubernetes hilfreich ist.