Kubernetes / Container: Markt

Stelle

eine offene Stelle, die das Qualitäts-Gate passiert hat und mindestens zwei Technologien nennt

Beobachteter Kandidat

ein Kandidat, dessen Stack diese Technologie enthält; ein Aggregat — kein einziger Datensatz verlässt den Perimeter

Matchbarer Kandidat

noch nicht gezählt

Fenster

Stellen, die zum Zeitpunkt der Erstellung des Snapshots offen waren

Junior — typischer Einstieg: DevOps Middle mit K8s-Erfahrung → Junior K8s Engineer (Fokus tief auf K8s, engerer Umfang). Der Sprung Junior → Middle — nach dem ersten K8s-Deployment im Produktionsmaßstab + einem selbst geschriebenen Operator. Middle → Senior — Multi-Cluster-Verantwortung + produktives Service-Mesh-Setup + Betriebserfahrung im Produktionsmaßstab (Nodes). Senior → Kubernetes Architect — organisationsweite K8s-Strategie + Multi-Cluster-Föderation + Architekturentscheidungen für Cloud-native. Karriereweg: DevOps Middle (2-3 Jahre) → Junior K8s (1-2 Jahre) → Middle (2-3 Jahre) → Senior → entweder Kubernetes Architect, K8s Operator Developer (Programmiertiefe in Go) oder Wechsel zu nativem Cloud-K8s — Teams von AWS EKS / GCP GKE / Azure AKS.

Top 5: kubernetes, devops, cloud, ci/cd, aws. Tiefe, souveräne Beherrschung von Kubernetes: Architektur von API-Server / Scheduler / Controller-Manager / kubelet / etcd, souveränes RBAC (Roles / ClusterRoles / RoleBindings + ServiceAccount-Token), Network Policies (NetworkPolicy + Cilium CiliumNetworkPolicy), Pod Security Standards (ersetzen PSP seit 1.25), Resource Quotas + LimitRanges, HPA / VPA / Karpenter (moderner Autoscaler — ersetzt den Cluster Autoscaler im AWS-Kontext), Muster für Deployment / StatefulSet / DaemonSet / Job / CronJob. Eigene CRDs + Operatoren: Operator SDK / Kubebuilder (Go) oder KOPF (Python). CRDs entwerfen + Controller schreiben + Reconciliation Loops handhaben. Souveränes Helm: Erstellen von Charts (Templates / Hierarchien von values.yaml / Hooks / Sub-Charts / Abhängigkeiten), Verteilung über OCI-Registries, Library Charts. Kustomize: Overlay-basiertes Konfigurationsmanagement, Alternative / Ergänzung zu Helm. GitOps: ArgoCD (dominiert 2026 — ApplicationSets für Multi-Cluster, Sync Waves, Sync Hooks, Projekthierarchien) oder FluxCD (leichtgewichtig + Helm-nativ). Service Mesh: Istio (die meisten Features — souveräne Beherrschung von VirtualService / DestinationRule / EnvoyFilter), Linkerd (am einfachsten + leichtgewichtig — Control Plane in Rust), Cilium (auf dem Vormarsch 2026 — eBPF-basiert, ersetzt kube-proxy + bietet Service Mesh + Network Policies im Kernel + Hubble-Observability). Netzwerke: CNI-Plugins in der Tiefe (Calico / Cilium / Weave / Flannel — eines in der Tiefe wählen), Gateway API (moderner Ersatz für Ingress — GA 2024 — HTTPRoute / Gateway / GatewayClass), Ingress-Controller (NGINX Ingress / Traefik / Contour / Istio Gateway). Speicher: souveräne Beherrschung von CSI-Treibern, OpenEBS / Longhorn / Rook/Ceph (selbst gehostet) + Cloud-CSI (EBS / Persistent Disk / Azure Disk). Observability: souveräner Prometheus Operator (kube-prometheus-stack), Grafana Loki, OpenTelemetry Collector, Jaeger / Tempo für Distributed Tracing. Sicherheit: OPA Gatekeeper oder Kyverno (Durchsetzung von Policies — Kyverno einfacher, auf dem Vormarsch 2026), Falco (Laufzeitsicherheit), Trivy + Snyk Container + Grype (Image-Scanning), Sigstore + cosign (Supply Chain — Signierung + Verifizierung von Images), External Secrets Operator / Sealed Secrets / Vault-Integration. Workflow / Orchestrierung: souveräne Argo Workflows (DAG / Step / suspended / ereignisgetrieben), Argo Events, Tekton Pipelines, Knative (Serverless auf K8s). GPU-Workloads (auf dem Vormarsch 2026 für KI / ML): NVIDIA GPU Operator, MIG (Multi-Instance GPU) für GPU-Sharing, Kueue für Job-Queuing, Volcano (Batch-Scheduler). Multi-Cluster: Karmada (Multi-Cluster-Orchestrierung), OpenChoreo, Cluster API (Bereitstellung von K8s-Clustern über K8s), Multi-Cluster-Service-Mesh (Istio Ambient Mesh — 2024+ Multi-Cluster). Sprachen: Go primär (Ökosystem von K8s). Python sekundär (KOPF-Operatoren + eigene Skripte).

Entscheidungsbaum für die Container-Orchestrierung 2026: 1) Kubernetes — Industriestandard seit 2018, dominiert die Container-Orchestrierung in Produktion (>80% im Enterprise). Einsatzfall: alles jenseits der einfachsten containerisierten Apps + Multi-Cloud-Portabilität + riesiges Ökosystem. Abwägungen: hohe Komplexität (steile Lernkurve + Betriebslast), aber der Markt hat keine Alternative. 2) AWS ECS (Elastic Container Service) — AWS-nativ, einfacher als K8s. Einsatzfall: nur AWS + kleines Team + Wunsch nach verwalteter Einfachheit. Zwei Varianten: ECS auf EC2 (Sie verwalten die Nodes) oder ECS Fargate (vollständig managed, keine Nodes). Fargate — am besten für kleine Workloads, teuer bei großem Maßstab. Abwägungen: Vendor-Lock-in bei AWS, kein Multi-Cloud, kleineres Ökosystem. 3) Docker Swarm — Dockers K8s-Alternative. Status 2026: tot. Docker Inc konzentriert sich auf Docker Desktop + Compose. Nur für die Legacy-Wartung verwenden. Einsatzfall: HashiCorp-Umgebung (nutzt bereits Vault / Consul / Terraform) + Wunsch nach etwas Einfacherem als K8s + Multi-Plattform (Container + VMs + Java-Apps + eigenständige Binaries). Abwägungen: kleineres Ökosystem (integriert sich aber mit dem Consul-Mesh), weniger Community + Stellen. Eine Nischenwahl. 5) Serverless (Lambda / Cloud Functions / Azure Functions) — führt Funktionen aus, ohne Container zu verwalten. Einsatzfall: ereignisgesteuerte Workloads, sporadischer Traffic, einfache API-Endpunkte. Abwägungen: Vendor-Lock-in, Cold-Start-Latenz, Ausführungslimits von 15 Minuten, schwierigeres Debugging. 6) Cloud Run / Knative — Serverless-Container (das Beste aus beiden Welten). Einsatzfall: containerisierte Apps + Wunsch nach Serverless-Skalierung (Scale-to-Zero) ohne K8s-Betriebslast. GCP Cloud Run — die beste Umsetzung. 7) Modernes PaaS: Render, Railway, Fly.io, Heroku — vollständig verwaltetes Deployment ohne Infrastruktur. Einsatzfall: Startups + kleine Teams + kleine Workloads. Standardempfehlungen 2026: Großunternehmen + Multi-Cloud + Zukunftssicherheit → Kubernetes. Nur AWS + kleines Team → ECS Fargate (oder K8s über EKS bei Wachstum). Ereignisgesteuert, sporadisch → Serverless-Funktionen. Containerisiert + Serverless gewünscht → Cloud Run / Knative. HashiCorp-Umgebung → Nomad. Ein Senior K8s Engineer muss wissen, wann K8s die falsche Wahl ist.

Referenz-Stack für K8s in Produktion 2026: 1) Bereitstellung des Clusters — verwaltet (EKS / GKE / AKS) oder Cluster API + Cluster-API-Provider (vsphere / AWS / GCP / Azure) für selbstverwaltete Cluster. 2) CNI (Container Network Interface) — Cilium (im Aufwind — eBPF-basiert, ersetzt kube-proxy) oder Calico (ausgereift) oder Flannel (einfach). Empfehlung 2026: Cilium — Bonus: Hubble-Observability + Durchsetzung von Network Policies im Kernel. 3) Ingress / Gateway — Gateway API (modern, GA 2024 — HTTPRoute / Gateway) mit den Implementierungen Cilium Gateway / Istio Gateway / Envoy Gateway / Kong Gateway. Legacy: NGINX Ingress Controller / Traefik / Contour. 4) Service Mesh (optional, aber für Produktion empfohlen): Istio (die meisten Funktionen — Ambient Mesh 2024+ vermeidet Sidecar-Overhead) oder Linkerd (einfacher) oder Cilium Service Mesh (eBPF-basiert — ganz ohne Sidecars). 5) GitOps — ArgoCD (dominiert — ApplicationSets für Mandantenfähigkeit, Sync Waves, Hooks) oder FluxCD. 6) Helm + Kustomize — Verwaltung von Manifesten. Helm für verteilte Pakete, Kustomize für overlaybasierte Konfiguration pro Umgebung. 7) Secrets-Management — External Secrets Operator (im Aufwind — bezieht aus Vault / AWS Secrets Manager / GCP Secret Manager / Azure Key Vault) oder Sealed Secrets (für GitOps-freundlich verschlüsselte Secrets). 8) Durchsetzung von Richtlinien — Kyverno (einfacher als OPA Gatekeeper, im Aufwind 2026) oder OPA Gatekeeper. Durchsetzen: Pflicht-Labels / Image-Registries / Ressourcenlimits / Security Contexts. 9) Observability — Metriken: Prometheus Operator (kube-prometheus-stack) + Grafana + VictoriaMetrics / Mimir für Langzeitspeicherung. 10) Observability — Logs: Loki + Fluent Bit / Vector (Vector im Aufwind — in Rust, schneller). 11) Observability — Traces: OpenTelemetry Collector + Jaeger oder Tempo (Grafana-Stack). 12) Laufzeitsicherheit: Falco (CNCF — eBPF-basierte Bedrohungserkennung zur Laufzeit) + Cilium Tetragon (eBPF-Security-Observability — neuere Alternative). 13) Image-Sicherheit: Trivy (Scans) + Sigstore cosign (Signierung) + Admission Controller, der Signaturen prüft. 14) Speicher: CSI-Treiber — Cloud-native (EBS / Persistent Disk / Azure Disk) oder OpenEBS / Longhorn / Rook/Ceph für selbst gehostete Umgebungen. 15) Backup / DR: Velero (CNCF — sichert K8s-Ressourcen + Persistent Volumes, stellt in einem anderen Cluster wieder her). Optionale Erweiterungen 2026: KEDA (ereignisgesteuertes Autoscaling), Argo Workflows (Batch / Pipelines), Knative (Serverless auf K8s), NVIDIA GPU Operator (für AI- / ML-Workloads). Ein Senior K8s Engineer wählt und pflegt diesen gesamten Stack — 15+ Komponenten.

Ja, 28% der Stellen als Kubernetes Engineer sind vollständig remote oder hybrid. K8s-Arbeit ist standardmäßig cloudbasiert. Outsourcer — fast immer remote bei US-Projekten. Russische Unternehmen — hybrid oder remote nach der Probezeit. Internationale Tech-Unternehmen — vollständig remote als Standard. Cloud-native-Unternehmen (Aiven / Isovalent (Cilium) / Tigera / SUSE Rancher / Rafay) — vollständig remote, Premium. K8s-Teams in Big Tech — Hybrid als Standard. Relokations-Hubs: Polen / Deutschland / Kanada / Serbien / Georgien / VAE. Englisch für internationale K8s-Remote-Arbeit — Pflicht (die CNCF-Community ist englischsprachig, KubeCon-Konferenzen auf Englisch).

Senior Kubernetes Engineer — setzt K8s-Cluster + eigene Operatoren um und pflegt sie. Alltag: Helm-Charts schreiben, Cluster-Probleme debuggen, Rufbereitschaft, Performance-Tuning, Entwicklung von Operatoren. Programmierlastig (Meisterschaft in Go für Operatoren). Kubernetes Architect — entwirft die K8s-Strategie + Multi-Cluster-Föderation + Service-Mesh-Architektur + Entscheidungen zur Cloud-native-Architektur. Alltag: ADRs für K8s-Entscheidungen schreiben, Design Reviews, Strategie der Multi-Cluster-Föderation (Karmada / OpenChoreo), Wahl des Service Mesh + Topologie, Entwurf des Frameworks für Sicherheitsrichtlinien, Kapazitätsplanung. Weniger Programmierung. Karriereweg: Senior K8s Engineer (4-6 Jahre) → K8s Architect → Principal K8s Architect / Cloud Native Architect. K8s Operator Developer (alternativer Weg — programmiertiefe Spezialisierung) — schreibt eigene K8s-Operatoren in Go. Alltag: Go-Programmierung + CRD-Design + controller-runtime + Tests. Arbeitet oft in Produktunternehmen, in denen K8s die primäre Plattform ist (z. B. Kubernetes-native Datenbanken — K8s-Operatoren von Cockroach / Yugabyte / SingleStore, K8s-natives Monitoring — K8s-Integrationen von Datadog / Dynatrace). Karrierewahl: Engineer — praktischer Alltag, Architect — Strategie + mehrere Teams, Operator Developer — tiefe Programmierung + Produktentwicklung.

Roadmap: 1) Solide DevOps-Basis — Linux + Docker beherrschen + Git + Grundlagen einer Cloud. 2) Kubernetes-Grundlagen — die offizielle Kubernetes-Dokumentation (kubernetes.io/docs — den gesamten Abschnitt Concepts lesen, Pflicht), „Kubernetes in Action“ von Lukša (das kanonische erste Buch), „Kubernetes Patterns“ von Ibryam / Roß. 3) K8s in der Praxis — einen eigenen Cluster aufsetzen: kind (Kubernetes in Docker — für die lokale Entwicklung), k3s (leichtgewichtig, für Edge / IoT / Raspberry Pi), minikube (Single-Node) oder Cloud-verwaltet (EKS / GKE / AKS — für das Free Tier geeignet). Echte Apps deployen. 4) CKA-Zertifizierung (Certified Kubernetes Administrator) — Pflicht für Rollen als K8s Engineer. Praktische Prüfung (2 Stunden praktisch). Ressourcen: Killer.sh (die beste Übungsprüfung — im CKA-Kauf enthalten), CKA-Kurs von KodeKloud. 5) CKAD-Zertifizierung (Certified Kubernetes Application Developer) — für die Entwicklerseite. 6) CKS-Zertifizierung (Certified Kubernetes Security Specialist) — Premium-Spezialisierung. 7) Helm beherrschen — Charts erstellen (Templates / Values / Hooks / Abhängigkeiten / Library Charts). Ein Chart-Repository einrichten. 8) GitOps mit ArgoCD — Application + ApplicationSets + Projects + Sync Hooks. ArgoCD auf dem eigenen Cluster einrichten + eine echte App im GitOps-Stil deployen. 9) Grundlagen des Service Mesh — Istio oder Linkerd auf dem eigenen Cluster installieren, Traffic-Routing + Observability konfigurieren. 10) Eigene CRDs + Operatoren — Programmieren in Go auf Backend-Middle-Niveau + Operator SDK / Kubebuilder. Einen einfachen Operator schreiben (z. B. einen Backup-Controller für StatefulSets). 11) Observability-Stack — kube-prometheus-stack + Grafana + Loki + Tempo installieren, eigene Metriken + Dashboards + Alerting konfigurieren. 12) Security-Stack — Falco + OPA Gatekeeper oder Kyverno installieren, Sicherheitsrichtlinien schreiben. 13) Fortgeschrittenes Pet-Projekt: produktionsreifer K8s-Aufbau mit allen 15 Komponenten des Stacks auf dem eigenen Cluster — als GitHub-Portfolio dokumentieren. 14) Zu Open Source beitragen — ein good-first-issue in den Repos von Kubernetes / Helm / ArgoCD / Cilium finden. Die CNCF-Community ist offen für neue Mitwirkende. Kurse (RU): Slurm DevOps + K8s, Otus „Kubernetes Educator“, Karpov.Courses K8s Track, KubeOps School. International (EN): KubeCon-Vorträge auf YouTube (kostenlos — die Top 50 Vorträge sind Pflicht), Learnk8s (Intensivkurse), KodeKloud Cloud-Native Learning Path, CNCF Curriculum (kostenlos). Pflichtlektüre: „Kubernetes Up & Running“ von Burns / Beda / Hightower (3. Auflage — die Autoren haben K8s erfunden), „Programming Kubernetes“ von Hausenblas / Stefan Schimanski (für die Entwicklung von Operatoren). DevOps Middle → K8s Junior — 4-8 Monate.

335 active open Kubernetes Engineer positions — premium specialisation inside DevOps. Geography: the US, Poland, India. Time to close a Senior K8s Engineer role — 4-10 weeks (faster than SRE, but requires deep specialisation).

Ein Senior Kubernetes Engineer verantwortet den gesamten Zyklus des K8s-Ökosystems + Betrieb im Produktionsmaßstab + technische Führung. Beherrschung von Kubernetes in der Tiefe: Produktionsmaßstab (Nodes), alle Controller + API-Objekte + Admission Controller + Scheduler-Plugins. Beherrschung von eigenen CRDs + Operatoren: Go-Programmierung auf Backend-Senior-Niveau + Operator SDK / Kubebuilder + controller-runtime + Umgang mit Reconciliation Loops + Leader Election + Versionierung eigener Ressourcen + Conversion Webhooks. Beherrschung von Helm: Erstellen von Charts (Templates / Werte-Hierarchien / Hooks / Sub-Charts / Library Charts), Verteilung über OCI-Registries, Testen von Charts (helm-unittest + chart-testing). Beherrschung von GitOps: ArgoCD ApplicationSets für mehrere Cluster + Sync Waves + Hooks + Projects + RBAC + Integration des Secrets-Managements. Service Mesh in der Tiefe: Istio oder Cilium Service Mesh — produktives Setup, Mesh über mehrere Cluster, mTLS, Traffic Management, Observability. Netzwerke in der Tiefe: Interna von CNI-Plugins (eBPF-Modell von Cilium oder BGP-Modell von Calico), Beherrschung der Gateway API (HTTPRoute / Gateway / GatewayClass), Entwurf der Durchsetzung von Network Policies. Beherrschung der Sicherheit: Pod Security Standards + Beherrschung von RBAC (Least-Privilege-Entwurf), Richtlinien-Framework OPA Gatekeeper / Kyverno, Laufzeitsicherheit (Falco / Cilium Tetragon), Supply-Chain-Sicherheit (Sigstore + cosign + Admission Webhooks zur Prüfung von Signaturen). Speicher: Interna von CSI-Treibern + bei Bedarf Entwicklung eigener CSI-Treiber. Beherrschung der Observability: Prometheus Operator fortgeschritten (CRDs ServiceMonitor / PodMonitor / Probe + Recording Rules + Föderation), Grafana fortgeschritten, OpenTelemetry Collector fortgeschritten, Distributed Tracing über das Mesh. Beherrschung mehrerer Cluster: Cluster API für die Bereitstellung, Karmada / OpenChoreo für die Föderation, Service Mesh über mehrere Cluster (Istio Ambient Mesh), DR-Strategien über mehrere Cluster. GPU-Workloads (im Aufwind 2026 für KI / ML): NVIDIA GPU Operator fortgeschritten, MIG-Konfiguration, Kueue für Job-Queuing, Volcano-Batch-Scheduler. Systementwurf für K8s-Plattformen: eine K8s-Plattform über mehrere Cluster für 10.000+ Nodes + Mandantenfähigkeit + Multi-Region am Whiteboard entwerfen. Performance-Optimierung: Benchmarking von Clustern (kube-bench für CIS / kube-burner für Performance), Tuning der Control Plane, etcd-Tuning. Programmierung: Beherrschung von Go als Hauptsprache (für Operatoren + eigenes Tooling). Python als Zweitsprache. Soft Skills: Verfassen von ADRs für K8s-Entscheidungen, technisches Schreiben (Chart-Dokumentation + Design-Dokumente für Operatoren), Code Review für Helm-Charts + Operator-Code, Mentoring von Middle-K8s-Engineers, Vorträge auf der KubeCon als Bonus. Englisch ab Senior+ PFLICHT — CNCF-Community / Dokumentation / Konferenzen sind auf Englisch. Optionaler Bonus: Open-Source-Beiträge zu Kubernetes Core / Helm / ArgoCD / Cilium / Istio — steigern den Marktwert bei Einstellungen in K8s-Teams von Big Tech deutlich.