Kubernetes Erste Schritte

Note

Dieser Artikel wurde zunächst anhand der Versionshinweise zu Ubuntu 26.04 LTS vom April 2026 überprüft. Kubernetes-Komponentenversionen und Produktionsbereitstellungsdetails müssen weiterhin anhand von MicroK8s und Upstream-Updates validiert werden.

Kubernetes (abgekürzt als K8s) ist heute die beliebteste Container-Orchestrierungsplattform, Open-Source von Google und gespendet an die CNCF (Cloud Native Computing Foundation). Es automatisiert die Bereitstellung, Skalierung und Verwaltung von Containeranwendungen und ist der Grundstein einer modernen Cloud-nativen Architektur.

Ubuntu ist eine der Mainstream-Linux-Distributionen für die Ausführung von Kubernetes. Canonical bietet außerdem MicroK8s an – eine leichte, einfach zu installierende Kubernetes-Distribution, die sich ideal für Entwicklungs-, Test- und Edge-Computing-Szenarien eignet.

Was ist K8s und warum Sie es brauchen?

Schmerzpunkte vor K8s

Im Zeitalter der Containerisierung löste Docker das Problem des „Verpackens und Ausführens von Anwendungen“. Wenn Sie jedoch Dutzende oder sogar Hunderte von Containern verwalten müssen, ergeben sich neue Herausforderungen:

Wenn ein Container abstürzt, wer startet ihn dann automatisch neu?
Wie erfolgt die automatische Skalierung, wenn der Datenverkehr zunimmt?
Wie entdecken und kommunizieren Container einander?
Wie führen Sie fortlaufende Updates ohne Dienstunterbrechung durch?
Wie planen Sie Container auf mehreren Servern?

Was K8s löst

Kubernetes wurde entwickelt, um genau diese Probleme zu lösen:

Funktion	Beschreibung
Selbstheilung	Startet abgestürzte Container automatisch neu. migriert Arbeitslasten, wenn Knoten ausfallen
Horizontale Skalierung	Erhöht oder verringert automatisch Containerinstanzen basierend auf der Auslastung
Diensterkennung	Container registrieren sich automatisch und greifen über DNS-Namen aufeinander zu
Laufende Updates	Ersetzt nach und nach alte Versionen für Bereitstellungen ohne Ausfallzeiten
Lastausgleich	Verteilt den Datenverkehr automatisch auf mehrere Containerinstanzen
Konfigurationsverwaltung	Zentralisierte Verwaltung von Anwendungskonfigurationen und Geheimnissen

MicroK8s-Installation

MicroK8s ist der leichte Kubernetes von Canonical, der über Snap mit einem einzigen Befehl installiert wird.

MicroK8s installieren


# Install MicroK8s
# Choose the latest stable channel; check snap info microk8s for available versions
sudo snap install microk8s --classic --channel=1.33/stable
 
# Add current user to the microk8s group (avoid sudo every time)
sudo usermod -a -G microk8s $USER
sudo chown -f -R $USER ~/.kube
 
# Re-login for group permissions to take effect
newgrp microk8s
 
# Check installation status
microk8s status --wait-ready

Gemeinsame Add-ons aktivieren

MicroK8s wird mit vielen integrierten Add-ons geliefert:


# Enable DNS (internal cluster name resolution -- almost always required)
microk8s enable dns
 
# Enable local storage
microk8s enable hostpath-storage
 
# Enable Dashboard (web management interface)
microk8s enable dashboard
 
# Enable Ingress (HTTP reverse proxy)
microk8s enable ingress
 
# Enable container image registry
microk8s enable registry
 
# Enable multiple add-ons at once
microk8s enable dns hostpath-storage dashboard ingress
 
# View all available add-ons
microk8s status

Konfigurieren des kubectl-Alias

MicroK8s enthält microk8s kubectl, aber es ist mühsam, es jedes Mal einzugeben. Sie können einen Alias einrichten:


# Option 1: Use an alias
alias kubectl='microk8s kubectl'
echo "alias kubectl='microk8s kubectl'" >> ~/.bashrc
 
# Option 2: Export config for a standalone kubectl installation
microk8s config > ~/.kube/config

Kubectl-Grundoperationen

kubectl ist das Befehlszeilentool für die Interaktion mit Kubernetes-Clustern.

Clusterinformationen


# View cluster information
kubectl cluster-info
 
# View all nodes
kubectl get nodes
 
# View node details
kubectl describe node <node-name>
 
# View cluster component status
kubectl get componentstatuses

Ressourcen anzeigen


# View all Pods
kubectl get pods
 
# View Pods across all namespaces
kubectl get pods --all-namespaces
# Or shorthand
kubectl get pods -A
 
# View Pod details (wide output)
kubectl get pods -o wide
 
# View all Deployments
kubectl get deployments
 
# View all Services
kubectl get services
# Or shorthand
kubectl get svc
 
# View all resources
kubectl get all

Ressourcendetails und Protokolle


# View Pod details
kubectl describe pod <pod-name>
 
# View Pod logs
kubectl logs <pod-name>
 
# Follow logs in real-time
kubectl logs -f <pod-name>
 
# View logs for a specific container in a multi-container Pod
kubectl logs <pod-name> -c <container-name>
 
# Execute commands inside a Pod
kubectl exec -it <pod-name> -- /bin/bash

Kernkonzepte

Pod

Ein Pod ist die kleinste einsetzbare Einheit in Kubernetes. Ein Pod enthält einen oder mehrere Container, die Netzwerk und Speicher gemeinsam nutzen.


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


# Create a Pod
kubectl apply -f pod-example.yaml
 
# Check Pod status
kubectl get pod nginx-pod
 
# Delete a Pod
kubectl delete pod nginx-pod

Einsatz

Eine Bereitstellung verwaltet die Anzahl der Pod-Replikate, fortlaufende Updates und Rollbacks. In der Praxis werden Sie Pods fast nie direkt erstellen – stattdessen verwalten Sie sie über Bereitstellungen.


# deployment-example.yaml
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
        image: nginx:1.27
        ports:
        - containerPort: 80
        resources:
          requests:
            memory: "64Mi"
            cpu: "250m"
          limits:
            memory: "128Mi"
            cpu: "500m"


# Deploy the application
kubectl apply -f deployment-example.yaml
 
# View deployment status
kubectl get deployment nginx-deployment
 
# Scale up/down
kubectl scale deployment nginx-deployment --replicas=5
 
# View rolling update status
kubectl rollout status deployment nginx-deployment
 
# Update image version
kubectl set image deployment/nginx-deployment nginx=nginx:1.28
 
# Rollback to previous version
kubectl rollout undo deployment nginx-deployment
 
# View update history
kubectl rollout history deployment nginx-deployment

Service

Ein Dienst stellt einen stabilen Netzwerkendpunkt für eine Reihe von Pods bereit. Pod-IPs ändern sich dynamisch, während ein Dienst einen festen Zugangspunkt bereitstellt.


# service-example.yaml
apiVersion: v1
kind: Service
metadata:
  name: nginx-service
spec:
  selector:
    app: nginx
  ports:
  - protocol: TCP
    port: 80
    targetPort: 80
  type: ClusterIP

Beschreibungen der Servicetypen:

Typ	Beschreibung
ClusterIP	Standard; nur innerhalb des Clusters zugänglich
NodePort	Öffnet einen Port auf jedem Knoten; von außen zugänglich
LoadBalancer	Verwendet den Load Balancer des Cloud-Anbieters


# Create a Service
kubectl apply -f service-example.yaml
 
# View the Service
kubectl get svc nginx-service
 
# Expose a service with NodePort
kubectl expose deployment nginx-deployment --type=NodePort --port=80

Bereitstellen Ihrer ersten Anwendung

Lassen Sie uns eine vollständige Webanwendung von Anfang bis Ende bereitstellen.

Schritt 1: Erstellen Sie eine Bereitstellung


# Quickly create using the command line
kubectl create deployment hello-app --image=gcr.io/google-samples/hello-app:1.0
 
# Verify the Pod is running
kubectl get pods -l app=hello-app

Schritt 2: Stellen Sie den Dienst bereit


# Create a NodePort Service
kubectl expose deployment hello-app --type=NodePort --port=8080
 
# View the assigned port
kubectl get svc hello-app

Schritt 3: Greifen Sie auf die Anwendung zu


# Get the access URL
# MicroK8s runs locally by default, so use localhost
NODE_PORT=$(kubectl get svc hello-app -o jsonpath='{.spec.ports[0].nodePort}')
echo "Access URL: http://localhost:$NODE_PORT"
 
# Test access
curl http://localhost:$NODE_PORT

Schritt 4: Hochskalieren


# Scale to 3 replicas
kubectl scale deployment hello-app --replicas=3
 
# View all Pods
kubectl get pods -l app=hello-app

Schritt 5: Aufräumen


# Delete the Service and Deployment
kubectl delete svc hello-app
kubectl delete deployment hello-app

Helm-Paketverwaltung

Helm ist der Paketmanager für Kubernetes, ähnlich dem apt von Ubuntu. Es verwendet Charts (Pakete), um komplexe Kubernetes-Anwendungen zu definieren, zu installieren und zu aktualisieren.

Helm installieren


# Option 1: Install via Snap
sudo snap install helm --classic
 
# Option 2: Install via official script
curl https://raw.githubusercontent.com/helm/helm/main/scripts/get-helm-3 | bash
 
# Verify installation
helm version

Helm verwenden


# Add the official stable repository
helm repo add bitnami https://charts.bitnami.com/bitnami
 
# Update repository index
helm repo update
 
# Search for Charts
helm search repo nginx
helm search repo mysql
 
# Install an application (Redis example)
helm install my-redis bitnami/redis
 
# View installed Releases
helm list
 
# View Release status
helm status my-redis
 
# Install with custom configuration
helm install my-nginx bitnami/nginx \
  --set replicaCount=3 \
  --set service.type=NodePort
 
# Install with a values file for custom configuration
helm install my-app bitnami/nginx -f custom-values.yaml
 
# Upgrade a Release
helm upgrade my-redis bitnami/redis --set auth.enabled=false
 
# Rollback
helm rollback my-redis 1
 
# Uninstall a Release
helm uninstall my-redis

Erstellen Sie Ihr eigenes Diagramm


# Create a new Chart template
helm create my-chart
 
# Directory structure
# my-chart/
#   Chart.yaml      # Chart metadata
#   values.yaml     # Default configuration values
#   templates/       # K8s resource templates
#     deployment.yaml
#     service.yaml
#     ingress.yaml
 
# Validate the Chart
helm lint my-chart/
 
# Dry-run install (no actual deployment)
helm install my-release my-chart/ --dry-run --debug
 
# Package the Chart
helm package my-chart/

Schnellreferenz-Befehlstabelle

Betrieb	Befehl
Clusterstatus anzeigen	`kubectl cluster-info`
Alle Pods anzeigen	`kubectl get pods -A`
Pod-Protokolle anzeigen	`kubectl logs POD_NAME`
Betreten Sie einen Pod	`kubectl exec -it POD_NAME -- bash`
Erstellen Sie eine Ressource	`kubectl apply -f file.yaml`
Löschen Sie eine Ressource	`kubectl delete -f file.yaml`
Vergrößern	`kubectl scale deployment NAME --replicas=N`
Bild aktualisieren	`kubectl set image deployment/NAME container=image`
Rollback	`kubectl rollout undo deployment/NAME`
Port vorwärts	`kubectl port-forward pod/NAME 8080:80`
Ressourcennutzung anzeigen	`kubectl top pods`
MicroK8s-Status	`microk8s status`
MicroK8s starten	`microk8s start`
MicroK8s stoppen	`microk8s stop`

Produktionsüberlegungen

Warning

MicroK8s eignet sich hervorragend zum Lernen und Entwickeln. Beachten Sie jedoch die folgenden Punkte, wenn Sie Kubernetes in der Produktion verwenden:

Hochverfügbarkeitscluster: Die Produktion erfordert mindestens 3 Steuerungsebenenknoten, um Single Points of Failure zu vermeiden
Ressourcenlimits: Legen Sie immer resources.requests und resources.limits für jeden Container fest, um zu verhindern, dass eine Anwendung alle Knotenressourcen verbraucht
Netzwerkrichtlinien: Konfigurieren Sie NetworkPolicy, um die Pod-zu-Pod-Kommunikation nach dem Prinzip der geringsten Rechte einzuschränken
RBAC-Berechtigungen: Führen Sie keine Anwendungen mit Cluster-Administratorrechten aus; Erstellen Sie für jeden Dienst dedizierte ServiceAccounts
Bildsicherheit: Verwenden Sie nur vertrauenswürdige Bildregister, scannen Sie Bilder regelmäßig auf Schwachstellen und vermeiden Sie die Verwendung des Tags latest
etcd sichern: etcd speichert alle Cluster-Statusdaten – regelmäßige Sicherungen sind von entscheidender Bedeutung
Überwachung und Warnung: Stellen Sie Prometheus + Grafana bereit, um den Clusterzustand zu überwachen
Protokollsammlung: Verwenden Sie EFK (Elasticsearch + Fluentd + Kibana) oder Loki für die Protokollaggregation

Für Support der Enterprise-Klasse sollten Sie Charmed Kubernetes von Canonical oder verwaltete K8s-Dienste von Cloud-Anbietern (z. B. AWS EKS, Google GKE, Azure AKS) in Betracht ziehen.

Allgemeine Fehlerbehebung


# Pod stuck in Pending state
kubectl describe pod <pod-name>
# Usually caused by insufficient resources or node selector mismatch
 
# Pod in CrashLoopBackOff
kubectl logs <pod-name> --previous
# View logs from the previous crash
 
# Cannot pull image (ImagePullBackOff)
kubectl describe pod <pod-name>
# Check if the image name is correct and whether image pull credentials are needed
 
# Service inaccessible
kubectl get endpoints <service-name>
# Verify that the Service selector matches the Pod labels
 
# DNS resolution failure
kubectl run test --image=busybox --rm -it -- nslookup kubernetes.default
# Check if CoreDNS is running properly

Nachdem Sie die oben genannten Inhalte gemeistert haben, sind Sie in der Lage, grundlegende Kubernetes-Workloads unter Ubuntu auszuführen und zu verwalten. Mit zunehmender Erfahrung können Sie ConfigMap, Secret, PersistentVolume, Ingress, CronJob und andere Ressourcentypen weiter erkunden.