Fragen zum Kubernetes-Interview 2026: Pods, Services, RBAC und HPA

⏱️3 min read · 656 words

Fragen zu Kubernetes-Interviews testen Ihr Verständnis von Container-Orchestrierung, Pod-Lebenszyklus, Diensten, Netzwerken, Skalierung und Produktionsabläufen. Dieser Leitfaden behandelt die am häufigsten gestellten K8s-Fragen für DevOps-Ingenieure und Plattform-Ingenieure im Jahr 2026.

Kernfragen zu Kubernetes

1. Was ist ein Pod und wie unterscheidet er sich von einem Container?

A Podist die kleinste bereitstellbare Einheit in Kubernetes. Es umhüllt einen oder mehrere Container, die Folgendes gemeinsam nutzen:

Netzwerk-Namespace (gleiche IP, gemeinsamer Localhost)
Speichervolumina
Lebenszyklus

Normalerweise ein Behälter pro Pod. Verwenden Sie mehrere Container für Sidecar-Muster (Logging-Agent, Proxy).

2. Erklären Sie den Unterschied zwischen einem Deployment, einem StatefulSet und einem DaemonSet

Ressource	Anwendungsfall	Hauptmerkmal
Einsatz	Zustandslose Apps (Webserver, APIs)	Rolling Updates, Replikatverwaltung
StatefulSet	Zustandsbehaftete Apps (Datenbanken, Kafka)	Stabile Pod-Namen, geordnete Bereitstellung, persistente Volumes
DaemonSet	Agenten auf Knotenebene (Protokollierung, Überwachung)	Automatisch ein Pod pro Knoten

3. Was sind ConfigMaps und Secrets? Wie unterscheiden sie sich?

# ConfigMap — non-sensitive configuration
apiVersion: v1
kind: ConfigMap
metadata:
  name: app-config
data:
  APP_ENV: production
  DB_HOST: postgres-service
  LOG_LEVEL: info

# Secret — sensitive data (base64 encoded, not encrypted by default!)
apiVersion: v1
kind: Secret
metadata:
  name: app-secrets
type: Opaque
data:
  DB_PASSWORD: c2VjcmV0cGFzcw==  # base64 encoded

# Use in Pod
env:
  - name: APP_ENV
    valueFrom:
      configMapKeyRef:
        name: app-config
        key: APP_ENV
  - name: DB_PASSWORD
    valueFrom:
      secretKeyRef:
        name: app-secrets
        key: DB_PASSWORD

4. Erklären Sie Kubernetes-Dienste und ihre Typen

# ClusterIP (default) — only accessible within cluster
apiVersion: v1
kind: Service
spec:
  type: ClusterIP
  selector:
    app: backend
  ports:
    - port: 8000
      targetPort: 8000

# NodePort — exposes on each node's IP at static port
spec:
  type: NodePort
  ports:
    - port: 80
      nodePort: 30080  # 30000-32767 range

# LoadBalancer — cloud provider creates LB
spec:
  type: LoadBalancer
  # Creates AWS ALB, GCP Load Balancer, Azure LB automatically

# Headless — no virtual IP, returns pod IPs directly (for StatefulSet)
spec:
  clusterIP: None
  selector:
    app: kafka

5. Was ist der Unterschied zwischen Liveness- und Readiness-Probes?

containers:
  - name: app
    livenessProbe:       # Is the container alive? If fails: RESTART container
      httpGet:
        path: /health
        port: 8000
      initialDelaySeconds: 30
      periodSeconds: 10
      failureThreshold: 3

    readinessProbe:      # Is the container ready for traffic? If fails: remove from load balancer
      httpGet:
        path: /ready
        port: 8000
      initialDelaySeconds: 5
      periodSeconds: 5

    startupProbe:        # For slow-starting apps — delays liveness check
      httpGet:
        path: /startup
        port: 8000
      failureThreshold: 30   # gives 5*30=150s for startup
      periodSeconds: 5

6. Wie funktioniert der Horizontal Pod Autoscaler (HPA)?

apiVersion: autoscaling/v2
kind: HorizontalPodAutoscaler
metadata:
  name: myapp-hpa
spec:
  scaleTargetRef:
    apiVersion: apps/v1
    kind: Deployment
    name: myapp
  minReplicas: 2
  maxReplicas: 20
  metrics:
    - type: Resource
      resource:
        name: cpu
        target:
          type: Utilization
          averageUtilization: 70  # scale when avg CPU > 70%
    - type: Resource
      resource:
        name: memory
        target:
          type: AverageValue
          averageValue: 500Mi
    # Custom metrics (requires metrics-server + Prometheus adapter)
    - type: Pods
      pods:
        metric:
          name: requests_per_second
        target:
          type: AverageValue
          averageValue: 100

7. Erklären Sie Kubernetes RBAC

# ServiceAccount — identity for pods
apiVersion: v1
kind: ServiceAccount
metadata:
  name: myapp-sa

# Role — permissions within a namespace
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: pod-reader
rules:
  - apiGroups: [""]
    resources: ["pods", "pods/logs"]
    verbs: ["get", "list", "watch"]

# ClusterRole — cluster-wide permissions
kind: ClusterRole
rules:
  - apiGroups: ["apps"]
    resources: ["deployments"]
    verbs: ["get", "list", "create", "update", "delete"]

# RoleBinding — attach role to service account
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata:
  name: myapp-pod-reader
subjects:
  - kind: ServiceAccount
    name: myapp-sa
    namespace: production
roleRef:
  kind: Role
  name: pod-reader
  apiGroup: rbac.authorization.k8s.io

8. Was passiert, wenn Sie „kubectl apply -f distribution.yaml“ ausführen?

kubectl sendet das Manifest an den API-Server (über HTTPS)
Der API-Server validiert und authentifiziert die Anfrage
Der API-Server bleibt im etcd (Cluster-Statusspeicher) bestehen.
Deployment Controller erkennt die Änderung über Watch
Der Controller erstellt bei Bedarf ReplicaSet
ReplicaSet Controller erstellt Pod-Spezifikationen
Der Scheduler weist Pods den Knoten zu (basierend auf Ressourcen, Taints, Affinität).
Kubelet auf dem Knoten ruft das Bild ab und startet den Container
Der Pod-Status wurde wieder auf etcd aktualisiert

Erfolg bei Kubernetes-Interviews: Verstehen Sie die Steuerungsebene (API-Server, etcd, Scheduler, Controller), kennen Sie den Unterschied zwischen Deployment/StatefulSet/DaemonSet, erklären Sie Probes klar und kennen Sie Netzwerke (Dienste, Ingress, Netzwerkrichtlinien). Fragen zu Produktions-K8s beziehen sich häufig auf RBAC, HPA, Ressourcengrenzen und Pod-Unterbrechungsbudgets.

🔗 Share this article

X / Twitter Facebook WhatsApp LinkedIn Telegram