Zum Inhalt springen
DevOps

Kubernetes - Eine vollstaendige Einfuehrung fuer Entwickler

Veröffentlicht am:
·6 Min. Lesezeit·Autor: MDS Software Solutions Group
kubernetesdockerdevopscloud

Kubernetes Eine vollstaendige

devops

Kubernetes - Eine vollstaendige Einfuehrung fuer Entwickler

Kubernetes (kurz K8s) ist eine Container-Orchestrierungsplattform, die die Art und Weise revolutioniert hat, wie Anwendungen in Produktionsumgebungen bereitgestellt, skaliert und verwaltet werden. Wenn Sie mit Docker-Containern arbeiten und sich fragen, wie Sie diese im grossen Massstab effizient verwalten koennen, ist Kubernetes die Antwort.

In diesem Leitfaden fuehren wir Sie durch alle wichtigen Kubernetes-Konzepte - von grundlegenden Objekten ueber YAML-Manifeste bis hin zum praktischen Deployment einer Next.js-Anwendung in einem K8s-Cluster.

Warum Kubernetes?#

Wenn Ihre Anwendung in einem einzelnen Docker-Container auf einem einzelnen Server laeuft, ist alles unkompliziert. Probleme entstehen, wenn Sie Folgendes benoetigen:

  • Skalierung der Anwendung auf mehrere Instanzen je nach Traffic
  • Hohe Verfuegbarkeit - automatischer Neustart nach Ausfaellen
  • Konfigurationsmanagement mehrerer Microservices gleichzeitig
  • Deployments ohne Ausfallzeit - Zero-Downtime-Deployments
  • Traffic-Verteilung zwischen mehreren Anwendungsinstanzen
  • Sichere Verwaltung von Secrets und Konfigurationen

Docker Compose funktioniert gut in Entwicklungsumgebungen, aber in der Produktion brauchen Sie etwas Robusteres. Kubernetes automatisiert all diese Aufgaben und bietet ein deklaratives Modell fuer das Infrastrukturmanagement.

Kubernetes-Architektur#

Bevor wir in die Praxis einsteigen, lohnt es sich, die grundlegende Architektur eines Kubernetes-Clusters zu verstehen:

  • Control Plane (Master) - das Gehirn des Clusters, verwaltet den Zustand und trifft Scheduling-Entscheidungen
    • API Server - die zentrale API fuer die Kommunikation mit dem Cluster
    • etcd - ein verteilter Key-Value-Store, der den Cluster-Zustand speichert
    • Scheduler - entscheidet, auf welchem Node ein Pod laufen soll
    • Controller Manager - ueberwacht den Cluster-Zustand und nimmt Korrekturen vor
  • Worker Nodes - Maschinen, auf denen die Container tatsaechlich laufen
    • kubelet - ein Agent, der Pods auf einem bestimmten Node verwaltet
    • kube-proxy - verwaltet Netzwerkregeln

Grundlegende Kubernetes-Objekte#

Pod - Die kleinste Einheit#

Ein Pod ist die kleinste deploybare Einheit in Kubernetes. Er kann einen oder mehrere Container enthalten, die sich Netzwerk und Storage teilen:

apiVersion: v1
kind: Pod
metadata:
  name: my-nextjs-app
  labels:
    app: nextjs
    environment: production
spec:
  containers:
    - name: nextjs
      image: my-registry/nextjs-app:1.0.0
      ports:
        - containerPort: 3000
      resources:
        requests:
          memory: "128Mi"
          cpu: "250m"
        limits:
          memory: "256Mi"
          cpu: "500m"
      livenessProbe:
        httpGet:
          path: /api/health
          port: 3000
        initialDelaySeconds: 10
        periodSeconds: 30
      readinessProbe:
        httpGet:
          path: /api/health
          port: 3000
        initialDelaySeconds: 5
        periodSeconds: 10

In der Praxis erstellt man selten Pods direkt. Stattdessen verwendet man uebergeordnete Controller wie Deployments.

Deployment - Verwaltung von Replikas#

Ein Deployment ist das am haeufigsten verwendete Objekt in Kubernetes. Es verwaltet eine Menge identischer Pods (ReplicaSet) und ermoeglicht deklarative Updates:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: nextjs-app
  labels:
    app: nextjs
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nextjs
  strategy:
    type: RollingUpdate
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 0
  template:
    metadata:
      labels:
        app: nextjs
        version: "1.0.0"
    spec:
      containers:
        - name: nextjs
          image: my-registry/nextjs-app:1.0.0
          ports:
            - containerPort: 3000
          env:
            - name: NODE_ENV
              value: "production"
            - name: DATABASE_URL
              valueFrom:
                secretKeyRef:
                  name: app-secrets
                  key: database-url
          resources:
            requests:
              memory: "128Mi"
              cpu: "250m"
            limits:
              memory: "256Mi"
              cpu: "500m"

Die RollingUpdate-Strategie mit maxUnavailable: 0 stellt sicher, dass waehrend des Deployments immer die erforderliche Anzahl von Pods verfuegbar ist, was Zero-Downtime-Deployments garantiert.

Service - Interne Kommunikation#

Ein Service bietet einen stabilen Zugriffspunkt auf eine Gruppe von Pods. Selbst wenn Pods erstellt und zerstoert werden, behaelt ein Service eine konsistente IP-Adresse und einen DNS-Eintrag:

apiVersion: v1
kind: Service
metadata:
  name: nextjs-service
spec:
  type: ClusterIP
  selector:
    app: nextjs
  ports:
    - protocol: TCP
      port: 80
      targetPort: 3000

Kubernetes bietet mehrere Service-Typen:

  • ClusterIP (Standard) - nur innerhalb des Clusters erreichbar
  • NodePort - stellt einen Port auf jedem Node im Cluster bereit
  • LoadBalancer - erstellt einen externen Load Balancer (in Cloud-Umgebungen)
  • ExternalName - bildet einen Service auf einen externen DNS-Namen ab

Ingress - Externes Traffic-Routing#

Ingress ist ein Objekt, das den HTTP/HTTPS-Zugriff von ausserhalb des Clusters verwaltet. Es ermoeglicht Routing basierend auf Hostnamen und Pfaden:

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nextjs-ingress
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
    cert-manager.io/cluster-issuer: "letsencrypt-prod"
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - myapp.example.com
      secretName: myapp-tls
  rules:
    - host: myapp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: nextjs-service
                port:
                  number: 80
          - path: /api
            pathType: Prefix
            backend:
              service:
                name: api-service
                port:
                  number: 8080

kubectl-Grundlagen#

kubectl ist das primaere CLI-Werkzeug fuer die Interaktion mit einem Kubernetes-Cluster. Hier sind die wichtigsten Befehle, die Sie kennen sollten:

# Cluster-Informationen
kubectl cluster-info
kubectl get nodes

# Pod-Verwaltung
kubectl get pods
kubectl get pods -o wide
kubectl describe pod <pod-name>
kubectl logs <pod-name>
kubectl logs -f <pod-name>  # follow
kubectl exec -it <pod-name> -- /bin/sh

# Deployment-Verwaltung
kubectl get deployments
kubectl rollout status deployment/nextjs-app
kubectl rollout history deployment/nextjs-app
kubectl rollout undo deployment/nextjs-app

# Manifeste anwenden
kubectl apply -f deployment.yaml
kubectl apply -f ./k8s/  # alle Dateien im Verzeichnis
kubectl delete -f deployment.yaml

# Skalierung
kubectl scale deployment nextjs-app --replicas=5

# Debugging
kubectl get events --sort-by='.lastTimestamp'
kubectl top pods
kubectl top nodes

ConfigMaps und Secrets#

ConfigMap - Anwendungskonfiguration#

Eine ConfigMap speichert Konfigurationsdaten als Schluessel-Wert-Paare. Sie ermoeglicht die Trennung von Konfiguration und Container-Image:

apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  NEXT_PUBLIC_API_URL: "https://api.example.com"
  NEXT_PUBLIC_SITE_NAME: "My Application"
  LOG_LEVEL: "info"
  CACHE_TTL: "3600"
  nginx.conf: |
    server {
      listen 80;
      server_name localhost;
      location / {
        proxy_pass http://localhost:3000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
      }
    }

Secret - Sensible Daten#

Secrets dienen zur Speicherung sensibler Daten wie Passwoerter, API-Tokens oder Zertifikate. Die Werte werden in base64 kodiert:

apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  database-url: cG9zdGdyZXNxbDovL3VzZXI6cGFzc0BkYjoxNTQzMi9teWRi
  jwt-secret: c3VwZXItc2VjcmV0LWtleS0xMjM0NTY=
  redis-password: cmVkaXMtcGFzc3dvcmQtMTIz

Verwendung von ConfigMap und Secret in einem Deployment:

spec:
  containers:
    - name: nextjs
      image: my-registry/nextjs-app:1.0.0
      envFrom:
        - configMapRef:
            name: app-config
        - secretRef:
            name: app-secrets
      volumeMounts:
        - name: config-volume
          mountPath: /etc/nginx/conf.d
  volumes:
    - name: config-volume
      configMap:
        name: app-config
        items:
          - key: nginx.conf
            path: default.conf

Beachten Sie, dass Secrets in Kubernetes standardmaessig nicht verschluesselt sind - sie sind lediglich base64-kodiert. Fuer Produktionsumgebungen sollten Sie Tools wie Sealed Secrets, HashiCorp Vault oder AWS Secrets Manager in Betracht ziehen.

Namespaces - Ressourcenisolation#

Namespaces bieten eine logische Isolation von Ressourcen innerhalb eines Clusters. Sie sind besonders nuetzlich in Multi-Team-Umgebungen:

apiVersion: v1
kind: Namespace
metadata:
  name: production
  labels:
    environment: production
---
apiVersion: v1
kind: Namespace
metadata:
  name: staging
  labels:
    environment: staging

Sie koennen die in einem Namespace verfuegbaren Ressourcen mit ResourceQuota begrenzen:

apiVersion: v1
kind: ResourceQuota
metadata:
  name: production-quota
  namespace: production
spec:
  hard:
    requests.cpu: "4"
    requests.memory: "8Gi"
    limits.cpu: "8"
    limits.memory: "16Gi"
    pods: "20"

Persistent Volumes - Dauerhafter Speicher#

Container sind von Natur aus kurzlebig. Persistent Volumes (PV) und Persistent Volume Claims (PVC) ermoeglichen dauerhafte Datenspeicherung:

apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: postgres-data
spec:
  accessModes:
    - ReadWriteOnce
  storageClassName: standard
  resources:
    requests:
      storage: 20Gi
---
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:16-alpine
          ports:
            - containerPort: 5432
          env:
            - name: POSTGRES_PASSWORD
              valueFrom:
                secretKeyRef:
                  name: db-secrets
                  key: postgres-password
          volumeMounts:
            - name: postgres-storage
              mountPath: /var/lib/postgresql/data
      volumes:
        - name: postgres-storage
          persistentVolumeClaim:
            claimName: postgres-data

Horizontal Pod Autoscaler (HPA)#

Der HPA skaliert automatisch die Anzahl der Pods basierend auf der beobachteten Auslastung. Er erfordert die Installation des Metrics Servers:

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: nextjs-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: nextjs-app
  minReplicas: 2
  maxReplicas: 10
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70
    - type: Resource
      resource:
        name: memory
        target:
          type: Utilization
          averageUtilization: 80
  behavior:
    scaleUp:
      stabilizationWindowSeconds: 60
      policies:
        - type: Pods
          value: 2
          periodSeconds: 60
    scaleDown:
      stabilizationWindowSeconds: 300
      policies:
        - type: Pods
          value: 1
          periodSeconds: 120

Der Abschnitt behavior ermoeglicht eine feingranulare Steuerung der Skalierungsgeschwindigkeit in beide Richtungen und verhindert uebermaessig aggressive Aenderungen.

Helm Charts - Der Kubernetes-Paketmanager#

Helm ist ein Paketmanager fuer Kubernetes, der das Deployment komplexer Anwendungen vereinfacht. Ein Chart ist eine Sammlung von Dateien, die zusammengehoerige Kubernetes-Ressourcen beschreiben:

# Chart.yaml
apiVersion: v2
name: nextjs-app
description: A Helm chart for Next.js application
type: application
version: 1.0.0
appVersion: "1.0.0"
dependencies:
  - name: postgresql
    version: "13.x.x"
    repository: "https://charts.bitnami.com/bitnami"
    condition: postgresql.enabled

# values.yaml
replicaCount: 3

image:
  repository: my-registry/nextjs-app
  tag: "1.0.0"
  pullPolicy: IfNotPresent

service:
  type: ClusterIP
  port: 80

ingress:
  enabled: true
  className: nginx
  hosts:
    - host: myapp.example.com
      paths:
        - path: /
          pathType: Prefix
  tls:
    - secretName: myapp-tls
      hosts:
        - myapp.example.com

resources:
  limits:
    cpu: 500m
    memory: 256Mi
  requests:
    cpu: 250m
    memory: 128Mi

autoscaling:
  enabled: true
  minReplicas: 2
  maxReplicas: 10
  targetCPUUtilizationPercentage: 70

postgresql:
  enabled: true
  auth:
    database: myapp
    username: myapp

Wichtige Helm-Befehle:

# Chart installieren
helm install my-release ./nextjs-chart -f values.yaml

# Aktualisieren
helm upgrade my-release ./nextjs-chart -f values.yaml

# Rollback
helm rollback my-release 1

# Releases auflisten
helm list

# Deinstallieren
helm uninstall my-release

Lokale Kubernetes-Umgebungen#

Zum Lernen und fuer die Entwicklung benoetigen Sie keinen Cloud-Cluster. Mehrere Tools ermoeglichen es, Kubernetes lokal auszufuehren:

Minikube#

Das beliebteste Tool fuer lokales Kubernetes:

# Installieren und starten
minikube start --driver=docker --cpus=4 --memory=8192

# Dashboard
minikube dashboard

# Service bereitstellen
minikube service nextjs-service

# Stoppen
minikube stop

Kind (Kubernetes in Docker)#

Eine leichtgewichtige Alternative, ideal fuer CI/CD-Pipelines:

# Cluster erstellen
kind create cluster --name my-cluster

# Mit Multi-Node-Konfiguration
kind create cluster --config kind-config.yaml

# kind-config.yaml
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
nodes:
  - role: control-plane
  - role: worker
  - role: worker

Docker Desktop#

Docker Desktop bietet integrierte Kubernetes-Unterstuetzung - aktivieren Sie diese einfach in den Einstellungen. Dies ist die einfachste Option fuer Entwickler, die Docker Desktop bereits taeglich nutzen.

Praktisches Deployment einer Next.js-Anwendung#

Lassen Sie uns alle Konzepte zusammenfuehren und eine Next.js-Anwendung in einem Kubernetes-Cluster deployen. Verzeichnisstruktur:

k8s/
  namespace.yaml
  configmap.yaml
  secret.yaml
  deployment.yaml
  service.yaml
  ingress.yaml
  hpa.yaml

Vollstaendiges Deployment-Manifest:

# k8s/namespace.yaml
apiVersion: v1
kind: Namespace
metadata:
  name: nextjs-production
---
# k8s/configmap.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: nextjs-config
  namespace: nextjs-production
data:
  NEXT_PUBLIC_API_URL: "https://api.example.com"
  NODE_ENV: "production"
---
# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: nextjs-app
  namespace: nextjs-production
spec:
  replicas: 3
  selector:
    matchLabels:
      app: nextjs
  template:
    metadata:
      labels:
        app: nextjs
    spec:
      containers:
        - name: nextjs
          image: my-registry/nextjs-app:1.0.0
          ports:
            - containerPort: 3000
          envFrom:
            - configMapRef:
                name: nextjs-config
          resources:
            requests:
              cpu: "250m"
              memory: "128Mi"
            limits:
              cpu: "500m"
              memory: "256Mi"
          livenessProbe:
            httpGet:
              path: /api/health
              port: 3000
            initialDelaySeconds: 15
            periodSeconds: 30
          readinessProbe:
            httpGet:
              path: /api/health
              port: 3000
            initialDelaySeconds: 5
            periodSeconds: 10
---
# k8s/service.yaml
apiVersion: v1
kind: Service
metadata:
  name: nextjs-service
  namespace: nextjs-production
spec:
  type: ClusterIP
  selector:
    app: nextjs
  ports:
    - port: 80
      targetPort: 3000
---
# k8s/ingress.yaml
apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: nextjs-ingress
  namespace: nextjs-production
  annotations:
    nginx.ingress.kubernetes.io/ssl-redirect: "true"
spec:
  ingressClassName: nginx
  tls:
    - hosts:
        - myapp.example.com
      secretName: myapp-tls
  rules:
    - host: myapp.example.com
      http:
        paths:
          - path: /
            pathType: Prefix
            backend:
              service:
                name: nextjs-service
                port:
                  number: 80

Alles mit einem einzigen Befehl deployen:

kubectl apply -f k8s/

Monitoring mit Prometheus und Grafana#

Monitoring ist in Produktionsumgebungen unverzichtbar. Prometheus und Grafana sind der Standard im Kubernetes-Oekosystem:

# prometheus-config.yaml
apiVersion: v1
kind: ConfigMap
metadata:
  name: prometheus-config
data:
  prometheus.yml: |
    global:
      scrape_interval: 15s
      evaluation_interval: 15s
    scrape_configs:
      - job_name: "kubernetes-pods"
        kubernetes_sd_configs:
          - role: pod
        relabel_configs:
          - source_labels:
              - __meta_kubernetes_pod_annotation_prometheus_io_scrape
            action: keep
            regex: true
          - source_labels:
              - __meta_kubernetes_pod_annotation_prometheus_io_port
            action: replace
            target_label: __address__
            regex: (.+)

Installation des kube-prometheus-stack mit Helm:

helm repo add prometheus-community https://prometheus-community.github.io/helm-charts
helm repo update

helm install monitoring prometheus-community/kube-prometheus-stack \
  --namespace monitoring \
  --create-namespace \
  --set grafana.adminPassword=your-password

Dies installiert Prometheus, Grafana, Alertmanager und eine Reihe vorgefertigter Dashboards fuer das Cluster-Monitoring.

Managed Kubernetes in der Cloud#

Fuer Produktionsumgebungen sind verwaltete Kubernetes-Dienste von Cloud-Anbietern der empfohlene Ansatz:

Amazon EKS (Elastic Kubernetes Service)#

  • Tiefe Integration mit dem AWS-Oekosystem (ALB, RDS, S3, IAM)
  • Fargate-Unterstuetzung (Serverless Containers)
  • Groesster Marktanteil

Azure AKS (Azure Kubernetes Service)#

  • Integration mit Azure DevOps und GitHub Actions
  • Unterstuetzung fuer Windows-Container
  • Kostenlose Control Plane

Google GKE (Google Kubernetes Engine)#

  • Von den Erfindern von Kubernetes entwickelt - die fortschrittlichste Implementierung
  • GKE Autopilot - ein vollstaendig verwalteter Modus
  • Beste Leistung und schnellste Updates

Die Wahl der Plattform haengt von Ihrem bestehenden Cloud-Oekosystem, den Geschaeftsanforderungen und den Praeferenzen des Teams ab.

Wann Kubernetes ueberdimensioniert ist#

Kubernetes ist ein maaechtiges Werkzeug, aber nicht jedes Projekt braucht es. K8s ist wahrscheinlich ueberdimensioniert, wenn:

  • Sie eine einfache Anwendung haben mit ein oder zwei Services
  • Geringer Traffic - einige hundert Benutzer pro Tag
  • Kleines Team (1-3 Personen) ohne K8s-Erfahrung
  • Das Budget begrenzt ist - ein K8s-Cluster verursacht zusaetzliche Kosten
  • Kein Autoscaling erforderlich ist - der Traffic ist vorhersehbar und konstant

In solchen Faellen sind bessere Alternativen:

  • Docker Compose + VPS - fuer einfache Anwendungen
  • PaaS-Plattformen - Vercel, Railway, Fly.io
  • Serverless - AWS Lambda, Azure Functions, Google Cloud Run
  • Verwaltete Container - AWS ECS, Azure Container Apps

Kubernetes ergibt Sinn, wenn Sie mehrere Microservices verwalten, erweitertes Autoscaling benoetigen, ein DevOps-Team haben und Anforderungen an hohe Verfuegbarkeit bestehen.

Zusammenfassung#

Kubernetes ist ein unverzichtbares Werkzeug im Toolkit des modernen Entwicklers. Die wichtigsten Erkenntnisse aus diesem Leitfaden:

  • Pods sind die Grundeinheit, aber Sie verwalten sie ueber Deployments
  • Services und Ingress handhaben die interne und externe Kommunikation
  • ConfigMaps und Secrets trennen Konfiguration vom Code
  • HPA automatisiert die Skalierung basierend auf Metriken
  • Helm vereinfacht die Verwaltung komplexer Deployments
  • Beginnen Sie mit einem lokalen Cluster (minikube oder kind), bevor Sie in die Cloud migrieren

Die Investition in das Erlernen von Kubernetes zahlt sich vielfach aus - die Automatisierung, Zuverlaessigkeit und Skalierbarkeit, die es bietet, sind mit anderen Mitteln schwer zu erreichen.

Brauchen Sie Hilfe mit Kubernetes?#

Bei MDS Software Solutions Group helfen wir Unternehmen bei der Implementierung und Verwaltung von Kubernetes-Infrastruktur. Wir bieten:

  • Entwurf der K8s-Cluster-Architektur
  • Migration von Anwendungen zu Kubernetes
  • Einrichtung von CI/CD-Pipelines mit automatisierten Deployments
  • Monitoring und Alerting (Prometheus, Grafana)
  • Optimierung der Cloud-Infrastrukturkosten
  • Kubernetes-Schulungen fuer Entwicklungsteams

Kontaktieren Sie uns, um Ihr Projekt und Ihre Infrastrukturanforderungen zu besprechen!

Autor
MDS Software Solutions Group

Team von Programmierexperten, die sich auf moderne Webtechnologien spezialisiert haben.

← Zurück zum Wissen
Kubernetes - Eine vollstaendige Einfuehrung fuer Entwickler | MDS Software Solutions Group | MDS Software Solutions Group