Starte lokal mit minikube oder kind, verwalte Ressourcen deklarativ mit kubectl apply -f und aktiviere den metrics-server, um HPA für automatische Skalierung zu nutzen.
Kurzantwort
Kubernetes (K8s) ist ein Open-Source-Orchestrator für Container, der Bereitstellung, Skalierung und Betrieb von Anwendungen automatisiert. Ein Cluster wird über die Control Plane und Worker-Nodes mit kubectl, deklarativen Manifesten (YAML), RBAC, Monitoring, Autoscaling und Tools wie Helm, GitOps (Argo CD/Flux) oder Managed-Services (EKS/GKE/AKS) verwaltet.
Kubernetes: Container-Orchestrierung und Cluster-Management
Kubernetes (K8s) ist der De-facto-Standard zur Orchestrierung von Containern. Es automatisiert Deployment, Skalierung, Self-Healing und Rollouts/Rollbacks von Anwendungen. Ein Kubernetes-Cluster besteht aus einer Control Plane und Worker-Nodes und wird typischerweise deklarativ über Manifeste verwaltet.
Was ist Kubernetes?
Kubernetes ist eine Open-Source-Plattform, die Container-Workloads in Pods verwaltet und für Hochverfügbarkeit, Portabilität und Automatisierung sorgt. Anstatt manuell Container zu starten, beschreibt man den Zielzustand (Desired State) in YAML – Kubernetes sorgt dafür, dass der Ist-Zustand übereinstimmt.
Kernkonzepte
- Pod: Kleinste ausrollbare Einheit; enthält einen oder mehrere Container.
- Deployment: Deklaratives Management stateless Workloads inkl. Rollouts/Rollbacks.
- StatefulSet: Für zustandsbehaftete Workloads mit stabilen Identitäten und Storage.
- DaemonSet: Ein Pod pro Node, z. B. für Logging/Monitoring-Agents.
- Job/CronJob: Batch- und zeitgesteuerte Workloads.
- Service: Stabile virtuelle IP/Discovery für Pods; Typen: ClusterIP, NodePort, LoadBalancer.
- Ingress/Gateway API: HTTP/HTTPS-Routing von außen ins Cluster.
- Namespace: Logische Isolation/Mehrmandantenfähigkeit.
- Labels/Selectors: Schlüssel/Wert-Metadaten für Auswahl/Organisation.
- ConfigMap/Secret: Konfiguration und vertrauliche Daten.
- Volumes/PersistentVolume (PV)/PersistentVolumeClaim (PVC)/StorageClass: Persistenter Speicher.
Architektur des Clusters
- Control Plane:
- kube-apiserver (zentrale Schnittstelle),
- etcd (hochverfügbarer Key-Value-Store),
- kube-scheduler (Pod-Platzierung),
- kube-controller-manager (Controller-Schleifen),
- optional cloud-controller-manager.
- Worker-Nodes:
- kubelet (Agent),
- kube-proxy (Service-Netzwerk),
- Container Runtime (containerd, CRI-O).
- Netzwerk: CNI-Plugins (z. B. Calico, Cilium), flaches Pod-Netz.
- Storage: CSI-Treiber binden externe Speicher (z. B. EBS, PD, Azure Disk).
Cluster bereitstellen
- Managed Kubernetes: Amazon EKS, Google GKE, Azure AKS (vereinfachte Provisionierung, Upgrades, SLAs).
- Self-Managed: kubeadm, Rancher, OpenShift; für volle Kontrolle.
- Lokal/Dev: minikube, kind, k3s für Tests und CI.
Zugriff und Tools
- kubeconfig: Cluster-Credentials und Kontexte verwalten.
- kubectl: CLI zur Interaktion mit dem API-Server.
- Helm: Paketmanager (Charts) für wiederholbare Deployments.
- Kustomize: Overlay-basiertes Patching von YAML.
- GitOps: Argo CD oder Flux für deklarative, pull-basierte Deployments.
Cluster verwalten (Ops)
Deklaratives Management
- YAML-Manifeste in Git versionieren.
- CI/CD oder GitOps zur automatischen Anwendung von Änderungen.
- Strikte Trennung von Desired State und Laufzeitdaten.
Day-2-Operations
- Rollouts: kubectl rollout status/undo, Canary/Blue-Green via Ingress/Service Mesh.
- Skalierung: Horizontal (HPA), Vertikal (VPA), Cluster Autoscaler für Nodes.
- Upgrades: Kontrolliert, Nodes drainen (cordon/drain), Version-Skew beachten, etcd-Backups.
- Kapazität: Node-Pools, Taints/Tolerations, PodDisruptionBudget (PDB).
Sicherheit
- RBAC: Rollen/Bindings, ServiceAccounts und Least Privilege.
- NetworkPolicies: Ost-West-Verkehr einschränken.
- Pod Security Standards (früher PodSecurityPolicy), OPA/Gatekeeper oder Kyverno für Policies.
- Secrets verschlüsseln (at rest) und ggf. externe Secret-Manager (AWS/GCP/Azure/KMS).
- Image Security: Signierung/Scanning (Cosign, Trivy), nur vertrauenswürdige Registries.
Observability
- Monitoring: Prometheus + Grafana, metrics-server für HPA.
- Logging: EFK/ELK (Elasticsearch/OpenSearch + Fluentd/Fluent Bit + Kibana) oder Loki.
- Tracing: OpenTelemetry, Jaeger/Tempo.
- Alerting: Alertmanager, SLO/SLA-gestützte Alarme.
Netzwerk & Traffic
- Ingress-Controller: NGINX, HAProxy, Traefik, Contour; oder Gateway API.
- Service Mesh: Istio, Linkerd für mTLS, Traffic Shaping, Observability.
- Load Balancer: Cloud-Integrationen oder MetallLB on-prem.
Storage & Backups
- CSI-Provisioner, StorageClasses (Standard/IO-optimiert).
- Backups/Restore: Velero (Objekte + PV-Snapshots), regelmäßige etcd-Snapshots.
Kostenkontrolle
- Ressourcen Requests/Limits sauber setzen (Right-Sizing).
- Spot/Preemptible Nodes für nicht-kritische Workloads.
- Pod-Scheduling optimieren (Affinity/Anti-Affinity, Topology Spread).
- Unbenutzte Ressourcen bereinigen, Quotas/LimitRanges nutzen.
kubectl-Basics (Cheatsheet)
- Anzeigen:
kubectl get nodes/pods/svc -A, Details:kubectl describe pod <name> - Logs/Debug:
kubectl logs <pod> [-c container],kubectl exec -it <pod> -- sh - Deployments:
kubectl apply -f <manifest.yaml>,kubectl rollout status deployment/<name> - Skalieren:
kubectl scale deploy/<name> --replicas=3 - Nodes warten:
kubectl cordon/drain <node>,kubectl uncordon <node>
Best Practices
- Alles deklarativ, versioniert in Git; Automatisierung via GitOps/CI.
- Konsistente Namenskonventionen, Labels und Annotations.
- Sicherheitsbaseline: RBAC, NetworkPolicies, Image-Scanning, mTLS.
- Ressourcen-Requests/Limits definieren, HPA/VPA aktivieren.
- Observability „by default“: Metrics, Logs, Traces, Runbooks.
- Regelmäßige Upgrades, Chaos-/DR-Übungen, Backup-Tests.
Häufige Stolpersteine
- Pods ohne Ressourcenlimits führen zu Node-Overcommit.
- Fehlende NetworkPolicies erlauben unbeschränkten Ost-West-Verkehr.
- Direktes Editieren von Live-Objekten statt Git/Manifeste erzeugt Drift.
- StatefulSets ohne passende StorageClass/Policies -> Datenverlust/Downzeiten.
Zukunftstrends
- Gateway API ersetzt/ergänzt Ingress.
- eBPF-basierte Netzwerke/Observability (z. B. Cilium).
- WASM-Workloads und Sidecar-Optimierungen.
- Verbesserte Multi-Cluster-/Edge-Patterns und Energieeffizienz.
Fazit
Kubernetes bietet eine mächtige, skalierbare Plattform für moderne Anwendungen. Mit deklativem Management, soliden Sicherheits- und Observability-Praktiken sowie Automatisierung (Helm, GitOps, Autoscaling) lässt sich ein Cluster effizient betreiben – ob self-managed oder als Managed Service in der Cloud.
