1. Kurzfazit

Die offiziellen, herstellerneutralen Kubernetes-Zertifizierungen kommen aus dem Umfeld CNCF / Linux Foundation. Der Kern besteht aus:

Die wichtigste Reihenfolge für die meisten Lernenden ist:

KCNA oder direkt Kubernetes Fundamentals
  -> CKA für Betrieb und Plattform
  -> CKAD für Anwendungsentwicklung
  -> KCSA für Security-Grundlagen
  -> CKS für Kubernetes-Security auf Professional-/Advanced-Level

Für Kubestronaut müssen alle fünf CNCF-Kubernetes-Zertifizierungen aktuell gehalten werden:

KCNA + KCSA + CKA + CKAD + CKS

Für Cloud-, OpenShift-, Rancher-, DevOps-, Platform-Engineering-, Security- und Observability-Zertifizierungen ist Kubernetes-Wissen häufig kein alleiniger Prüfungsinhalt, aber ein relevanter Hebel. Besonders wichtig ist es bei:

• Red Hat OpenShift-Zertifizierungen,
• SUSE Rancher / RKE2-Zertifizierungen,
• Google-Cloud-Zertifizierungen mit GKE-Bezug,
• AWS-Zertifizierungen mit Amazon-EKS- oder Container-Plattformbezug,
• Microsoft-Azure-Credentials mit AKS-Bezug,
• CNCF-Zertifizierungen rund um Argo, GitOps, Prometheus, OpenTelemetry, Cilium, Istio, Kyverno und Platform Engineering.

2. Was in dieser Datei erweitert wurde

Die ursprüngliche Datei enthielt bereits die korrekte Grundannahme: Offizielle CNCF/Linux-Foundation-Zertifizierungen sind CKA, CKAD, CKS, KCNA und KCSA. Sie enthielt außerdem eine kurze Einordnung, Themenliste, Lernstrategie und Praxisnachweise.

Diese erweiterte Version ergänzt:

1. eine klare Abgrenzung zwischen offiziellen Kubernetes-Zertifizierungen und verwandten Cloud-Native-Zertifizierungen,
2. eine Übersicht, wo diese Zertifizierungen existieren,
3. eine detaillierte Beschreibung der fünf CNCF-Kubernetes-Zertifizierungen,
4. eine Einordnung von Kubestronaut und erweiterten CNCF-Pfaden,
5. eine Übersicht zu Red Hat OpenShift, SUSE Rancher/RKE2, Google Cloud, AWS und Microsoft Azure,
6. Lernpfade nach Rollen,
7. eine Zuordnung zu den vorhandenen Workshop- und Prüfungsleveln 01 bis 04,
8. eine Themenmatrix für Kubernetes-Kompetenzen,
9. eine Checkliste vor der Anmeldung,
10. offizielle Quellen zur weiteren Prüfung.

3. Begriffsklärung: offiziell, verwandt, nützlich

3.1 Offizielle Kubernetes-Zertifizierung

In dieser Datei bedeutet offizielle Kubernetes-Zertifizierung:

• personenbezogene Zertifizierung,
• direkt auf Kubernetes ausgerichtet,
• von CNCF und/oder Linux Foundation angeboten oder verantwortet,
• herstellerneutral,
• international anerkannt,
• mit offizieller Exam- oder Certification-Seite.

Dazu gehören derzeit:

• KCNA,
• KCSA,
• CKA,
• CKAD,
• CKS.

3.2 Verwandte Cloud-Native-Zertifizierung

Eine verwandte Cloud-Native-Zertifizierung prüft nicht primär Kubernetes selbst, ist aber fachlich eng mit Kubernetes-Plattformen verbunden. Beispiele:

• Prometheus für Monitoring,
• OpenTelemetry für Telemetrie,
• Cilium für Kubernetes-Netzwerk, Security und Observability,
• Istio für Service Mesh,
• Argo und GitOps für Kubernetes-Delivery,
• Kyverno für Kubernetes Policy-as-Code,
• Platform Engineering für interne Entwicklerplattformen auf Kubernetes-Basis.

3.3 Anbieter-Zertifizierung mit Kubernetes-Bezug

Eine Anbieter-Zertifizierung ist nicht herstellerneutral, prüft aber häufig Kubernetes in einer konkreten Plattform:

• Red Hat OpenShift,
• SUSE Rancher Prime,
• Rancher Kubernetes Engine 2,
• Google Kubernetes Engine,
• Amazon Elastic Kubernetes Service,
• Azure Kubernetes Service.

3.4 Kubernetes-Wissen ist wichtig oder nützlich

Kubernetes-Wissen ist wichtig, wenn die Zertifizierung explizit Kubernetes-Cluster, Kubernetes-Objekte, Pods, Deployments, Services, RBAC, Storage, Netzwerk oder Security prüft.

Kubernetes-Wissen ist nützlich, wenn die Zertifizierung breitere Cloud-, DevOps-, Security- oder Architekturkompetenzen prüft und Kubernetes als eine mögliche Plattform vorkommt. In solchen Prüfungen reicht Kubernetes allein nicht, aber es hilft beim Verständnis von Containern, Deployments, Skalierung, IAM/RBAC, Observability, Netzwerken und Betrieb.

4. Offizielle Kubernetes-Zertifizierungen von CNCF und Linux Foundation

4.1 Übersicht

4.2 KCNA – Kubernetes and Cloud Native Associate

Ziel: Nachweisen, dass du Kubernetes und das Cloud-Native-Ökosystem grundlegend verstehst.

Geeignet für:

• Einsteiger,
• Studierende,
• Junior DevOps Engineers,
• Cloud Engineers am Anfang,
• Personen, die vor CKA/CKAD eine strukturierte Orientierung wollen,
• technische Product Owner oder Projektverantwortliche mit Cloud-Native-Fokus.

Typische Themen:

• Kubernetes-Grundarchitektur,
• Pods, Deployments, Services und Namespaces,
• kubectl-Grundverständnis,
• Container und Images,
• Cloud-Native-Prinzipien,
• Observability-Grundlagen,
• Security-Grundlagen,
• CNCF-Ökosystem.

Warum Kubernetes-Wissen wichtig ist:

KCNA ist direkt auf Kubernetes und Cloud Native ausgerichtet. Du musst nicht wie bei CKA produktionsnahe Cluster administrieren, aber du musst Begriffe und Zusammenhänge sicher einordnen.

Passende Vorbereitung aus diesem Material:

• 01-fundamentals-*,
• Grundlagenfragen aus questions-kubernetes-DE.md,
• einfache Hands-on-Labs mit Namespace, Deployment, Service, ConfigMap, Secret, Rollout und Troubleshooting.

Nicht ideal, wenn:

• du bereits produktive Kubernetes-Cluster betreibst und eine praktische Prüfung suchst,
• du eine Entwickler- oder Adminrolle direkt nachweisen willst.

Dann ist CKA oder CKAD sinnvoller.

4.3 KCSA – Kubernetes and Cloud Native Security Associate

Ziel: Grundlagenwissen zu Kubernetes- und Cloud-Native-Security nachweisen.

Geeignet für:

• Einsteiger in Kubernetes Security,
• Security Engineers ohne Kubernetes-Praxis,
• DevOps Engineers mit Interesse an DevSecOps,
• Personen, die später CKS anstreben,
• Auditoren oder Compliance-Verantwortliche mit Cloud-Native-Kontext.

Typische Themen:

• Kubernetes-Security-Grundlagen,
• Cluster- und Plattformrisiken,
• RBAC-Grundlagen,
• Pod Security Standards,
• Secrets-Grundlagen,
• Netzwerksegmentierung,
• Supply-Chain-Grundlagen,
• Compliance- und Hardening-Grundideen.

Warum Kubernetes-Wissen wichtig ist:

KCSA prüft Security nicht abstrakt, sondern im Kontext von Kubernetes und Cloud Native. Wer Pods, ServiceAccounts, RBAC, Secrets, Admission und NetworkPolicies nicht einordnen kann, wird die Sicherheitsfragen nur oberflächlich verstehen.

Passende Vorbereitung aus diesem Material:

• Fundamentals für Objektmodell und Basisressourcen,
• Advanced + Security für Threat Model, RBAC, Pod Security, NetworkPolicy, Secrets und Incident Response,
• einfache Security-Reviews ohne produktive Secrets.

Nicht ideal, wenn:

• du bereits CKA besitzt und Kubernetes-Security praktisch nachweisen willst.

Dann ist CKS der stärkere Nachweis.

4.4 CKA – Certified Kubernetes Administrator

Ziel: Nachweisen, dass du Kubernetes-Cluster administrieren, konfigurieren, betreiben und debuggen kannst.

Geeignet für:

• Kubernetes-Administratoren,
• Plattformteams,
• SREs,
• Cloud Engineers,
• DevOps Engineers mit Betriebsverantwortung,
• Personen, die CKS anstreben.

Typische Themen:

• Clusterarchitektur,
• Nodes,
• Scheduling,
• Workloads,
• Services,
• Networking,
• Storage,
• RBAC-Grundlagen,
• Troubleshooting,
• Upgrades und Wartungsgrundlagen,
• Backup-/Recovery-Grundverständnis.

Warum Kubernetes-Wissen wichtig ist:

CKA ist eine direkte Kubernetes-Administrationsprüfung. Theorie reicht nicht. Du musst in einer Shell mit kubectl arbeiten, Ressourcen analysieren und Fehler beheben.

Passende Vorbereitung aus diesem Material:

• 01-fundamentals-* für Objektmodell und sichere Bedienung,
• 02-intermediate-* für Workloads, Probes, Ressourcen, Scheduling, NetworkPolicy, Storage und Troubleshooting,
• 03-professional-* für Plattformbetrieb, Upgrades, Observability, GitOps, DR und Kosten.

Nicht ideal, wenn:

• du fast ausschließlich Anwendungen entwickelst und keine Clusteradministration betreibst.

Dann ist CKAD oft passender.

4.5 CKAD – Certified Kubernetes Application Developer

Ziel: Nachweisen, dass du Anwendungen auf Kubernetes designen, konfigurieren, bereitstellen, exponieren und debuggen kannst.

Geeignet für:

• Entwickler,
• DevOps Engineers,
• Application Engineers,
• Plattformnutzer,
• Personen, die Kubernetes primär aus Workload-Sicht verwenden.

Typische Themen:

• Pods,
• Deployments,
• Jobs und CronJobs,
• ConfigMaps und Secrets,
• Probes,
• Services,
• Ingress-Grundlagen,
• Resource Requests und Limits,
• Labels und Selectors,
• Volumes,
• SecurityContext-Grundlagen,
• Troubleshooting von Anwendungen.

Warum Kubernetes-Wissen wichtig ist:

CKAD prüft nicht Clusterbetrieb im Schwerpunkt, sondern den sicheren und reproduzierbaren Umgang mit Kubernetes-Objekten aus Anwendungssicht.

Passende Vorbereitung aus diesem Material:

• 01-fundamentals-*,
• 02-intermediate-*,
• praktische Übungen mit Deployments, Probes, Services, Jobs, CronJobs, ConfigMaps, Secrets, PVCs, Helm und Kustomize.

Nicht ideal, wenn:

• du primär Cluster, Nodes, Networking, Storageklassen und Plattformbetrieb verantwortest.

Dann ist CKA wichtiger.

4.6 CKS – Certified Kubernetes Security Specialist

Ziel: Nachweisen, dass du Kubernetes-Workloads und Kubernetes-Plattformen sicher betreiben, härten, prüfen und auf Incidents reagieren kannst.

Wichtige Voraussetzung:

• CKS setzt ein aktuelles CKA voraus. Ohne solide Admin-Praxis ist CKS nicht sinnvoll.

Geeignet für:

• Security Engineers,
• DevSecOps Engineers,
• Plattform-Security,
• Senior SREs,
• Kubernetes-Administratoren mit Security-Verantwortung,
• Personen, die Kubernetes-Risiken auditieren oder härten müssen.

Typische Themen:

• Cluster Setup Security,
• API Server und Control Plane,
• RBAC,
• ServiceAccounts,
• Pod Security Standards,
• SecurityContext,
• NetworkPolicies,
• Secrets,
• Supply Chain Security,
• Image Scanning,
• Admission Control,
• Runtime Security,
• Audit Logs,
• Incident Response.

Warum Kubernetes-Wissen wichtig ist:

CKS ist keine generische Security-Prüfung. Sie setzt voraus, dass du Kubernetes-Objekte, Clusterverhalten, kubectl, Workloads, Netzwerk und Betriebsprozesse bereits sicher beherrschst.

Passende Vorbereitung aus diesem Material:

• 04-advanced-security-*,
• Lösungen zu Advanced + Security,
• praktische Labs zu RBAC, Pod Security, NetworkPolicy, Admission, Secrets, Supply Chain, Runtime Detection und Incident Response,
• ergänzend 03-professional-* für Betriebs- und Plattformkontext.

Nicht ideal, wenn:

• du noch keine Kubernetes-Administration beherrschst,
• du nur theoretische Security-Grundlagen nachweisen willst.

Dann zuerst KCSA oder CKA.

5. Kubestronaut und erweiterte CNCF-Zertifizierungspfade

5.1 Kubestronaut

Kubestronaut ist ein CNCF-Programm für Personen, die alle fünf CNCF-Kubernetes-Zertifizierungen erfolgreich erworben und aktuell gehalten haben:

KCNA + KCSA + CKA + CKAD + CKS

Bedeutung:

• breiter Kubernetes-Kompetenznachweis,
• Kombination aus Grundlagen, Administration, Entwicklung und Security,
• besonders passend für Plattform Engineers, Senior DevOps Engineers, SREs und Kubernetes-Berater.

Empfohlene Reihenfolge:

1. KCNA
2. CKAD oder CKA
3. CKA oder CKAD
4. KCSA
5. CKS

Für Personen mit viel Betriebserfahrung ist auch möglich:

1. CKA
2. CKAD
3. CKS
4. KCNA
5. KCSA

Die erste Reihenfolge ist didaktisch sauberer. Die zweite Reihenfolge ist für erfahrene Praktiker oft schneller.

5.2 Golden Kubestronaut / erweiterte CNCF-Breite

Im CNCF-Umfeld gibt es neben den fünf Kern-Kubernetes-Zertifizierungen weitere Cloud-Native-Zertifizierungen, etwa zu Prometheus, Istio, Cilium, Argo, GitOps, Backstage, OpenTelemetry, Kyverno und Platform Engineering.

Diese erweitern das Profil von reiner Kubernetes-Bedienung zu einer kompletten Cloud-Native-Plattformkompetenz:

• Observability,
• Service Mesh,
• Netzwerk und Security,
• GitOps und Continuous Delivery,
• Policy-as-Code,
• interne Entwicklerplattformen,
• Telemetrie und Plattformbetrieb.

6. CNCF-Zertifizierungen, bei denen Kubernetes-Wissen besonders nützlich ist

Diese Zertifizierungen sind nicht alle „Kubernetes-Zertifizierungen“ im engen Sinn. Viele setzen aber voraus, dass du Kubernetes als Zielplattform verstehst.

6.1 Sinnvolle Kombinationen

7. Anbieter-Zertifizierungen mit direktem Kubernetes- oder Kubernetes-Plattformbezug

7.1 Red Hat OpenShift

Red Hat OpenShift ist eine Kubernetes-basierte Enterprise-Plattform. Kubernetes-Wissen ist hier sehr wichtig, reicht aber allein nicht aus, weil OpenShift eigene Konzepte ergänzt:

• Projects statt reiner Namespace-Sicht,
• Routes,
• BuildConfigs oder moderne Build-Flows,
• Security Context Constraints,
• Operator Lifecycle Manager,
• OpenShift-spezifische CLI oc,
• integrierte Registry-, Auth-, Netzwerk- und Plattformfunktionen.

Empfehlung:

• Für herstellerneutrales Kubernetes zuerst KCNA/CKA/CKAD.
• Für OpenShift-Jobrollen zusätzlich EX180/EX280/EX288 je nach Rolle.
• Für OpenShift-Security trotzdem CKS/KCSA/KCA als herstellerneutrale Ergänzung prüfen.

7.2 SUSE Rancher und Rancher Kubernetes Engine 2

SUSE/Rancher-Zertifizierungen sind besonders relevant, wenn Kubernetes über Rancher, Rancher Prime, RKE2 oder Multi-Cluster-Management betrieben wird.

Empfehlung:

• Für allgemeine Kubernetes-Kompetenz CKA als Basis.
• Für Rancher-/RKE2-Betrieb SUSE-Zertifizierungen ergänzen.
• Für Security KCSA/CKS/KCA/CCA als Ergänzung nutzen.

7.3 Abgrenzung: Personen-Zertifizierung vs. Produkt-/Provider-Programm

Nicht alles mit „Certified Kubernetes“ ist eine personenbezogene Prüfung. Im CNCF-Umfeld gibt es auch Programme wie:

Diese Programme sind für Unternehmen, Produkte oder Trainingsanbieter relevant, aber nicht dasselbe wie CKA, CKAD, CKS, KCNA oder KCSA für Einzelpersonen.

8. Cloud-Zertifizierungen, bei denen Kubernetes-Wissen hilfreich ist

Cloud-Zertifizierungen prüfen meist nicht Kubernetes allein. Trotzdem ist Kubernetes-Wissen in modernen Cloud-Rollen oft wichtig, weil EKS, AKS und GKE typische Plattformdienste sind.

8.1 Google Cloud

Google Cloud hat mit Google Kubernetes Engine (GKE) einen stark Kubernetes-bezogenen Managed Service. Kubernetes-Wissen ist besonders hilfreich bei:

Einordnung:

• Wer GKE betreibt, sollte mindestens CKAD- oder CKA-nahe Kubernetes-Praxis haben.
• Für Architekten ist CKA nicht zwingend, aber Kubernetes-Grundlagen plus GKE-Architekturwissen sind stark nützlich.

8.2 AWS

AWS nutzt mit Amazon Elastic Kubernetes Service (Amazon EKS) einen Managed-Kubernetes-Dienst. Kubernetes-Wissen ist besonders hilfreich bei:

Einordnung:

• Für EKS-Plattformbetrieb ist CKA sehr nützlich.
• Für EKS-Security ist CKS/KCSA nützlich.
• Für Anwendungsbereitstellung auf EKS ist CKAD nützlich.

8.3 Microsoft Azure

Azure nutzt mit Azure Kubernetes Service (AKS) einen Managed-Kubernetes-Dienst. Microsoft unterscheidet zwischen klassischen Microsoft Certifications und praxisnahen Applied Skills.

Einordnung:

• Für AKS-Betrieb ist CKA oder CKAD plus Azure-spezifisches AKS-Wissen sehr sinnvoll.
• Für AKS-Security ist CKS/KCSA plus Azure-IAM-/Policy-/Network-Know-how nützlich.
• Microsoft Applied Skills sind praktische Nachweise, aber nicht identisch mit klassischen Microsoft-Zertifizierungen.

9. Rollenbasierte Entscheidung: welche Zertifizierung passt zu welchem Ziel?

9.1 Einsteiger / Junior Cloud Engineer

Ziel: Cloud Native verstehen, Kubernetes-Begriffe sicher einordnen.

Empfohlener Pfad:

01 Fundamentals
  -> KCNA
  -> KCSA optional
  -> CKAD oder CKA nach Zielrolle

Warum:

KCNA gibt Orientierung, ohne sofort tiefes Cluster-Troubleshooting oder Security-Hardening zu verlangen.

9.2 Kubernetes Administrator / Plattformbetrieb

Ziel: Cluster betreiben, Workloads analysieren, Storage/Networking/Troubleshooting beherrschen.

Empfohlener Pfad:

01 Fundamentals
  -> 02 Intermediate
  -> 03 Professional
  -> CKA
  -> PCA oder CCA optional
  -> CKS bei Security-Verantwortung

Warum:

CKA ist der zentrale Nachweis für Kubernetes-Administration. PCA, CCA und CKS ergänzen Observability, Netzwerk und Security.

9.3 Kubernetes Application Developer

Ziel: Anwendungen für Kubernetes bauen, konfigurieren, deployen und debuggen.

Empfohlener Pfad:

01 Fundamentals
  -> 02 Intermediate
  -> CKAD
  -> CGOA oder CAPA
  -> PCA oder OTCA optional

Warum:

CKAD passt zu Workload-Modellierung, Probes, ConfigMaps, Secrets, Services, Jobs, CronJobs, Volumes und Debugging.

9.4 DevOps Engineer / CI/CD / GitOps

Ziel: Build, Test, Scan, Image-Promotion, GitOps, Rollout und Rollback beherrschen.

Empfohlener Pfad:

KCNA
  -> CKAD oder CKA
  -> CGOA
  -> CAPA
  -> Cloud-Provider-Zertifizierung je nach Plattform

Warum:

GitOps und Argo sind häufig Kubernetes-zentriert. Ohne Kubernetes-Objektmodell bleiben Rollouts, Diffs, Sync, Drift und Rollbacks unklar.

9.5 Security Engineer / DevSecOps

Ziel: Kubernetes-Risiken erkennen, Cluster und Workloads härten, Policies formulieren, Incidents bearbeiten.

Empfohlener Pfad:

KCNA
  -> KCSA
  -> CKA
  -> CKS
  -> KCA
  -> CCA optional

Warum:

CKS setzt CKA voraus. KCSA ist ein sinnvoller Einstieg. KCA ergänzt Policy-as-Code. CCA ergänzt CNI-, eBPF-, Netzwerk- und Security-Themen.

9.6 Platform Engineer / Internal Developer Platform

Ziel: Kubernetes als Plattformprodukt für mehrere Teams bereitstellen.

Empfohlener Pfad:

CKA
  -> CKAD
  -> CGOA
  -> CAPA
  -> PCA/OTCA
  -> CNPA
  -> CNPE
  -> CKS optional oder empfohlen

Warum:

Platform Engineering verbindet Architektur, GitOps, Self-Service, Observability, Security, Policy Enforcement, Runtime-Betrieb und Developer Experience.

9.7 OpenShift Administrator / OpenShift Developer

Ziel: Kubernetes-basierte Plattform Red Hat OpenShift betreiben oder Anwendungen darauf bereitstellen.

Empfohlener Pfad:

KCNA oder Kubernetes Fundamentals
  -> CKA oder CKAD
  -> Red Hat EX180 / Container-Grundlagen
  -> EX280 für Administration
  -> EX288 für Application Development

Warum:

OpenShift basiert auf Kubernetes, ergänzt aber eigene Plattformfunktionen. Kubernetes-Wissen beschleunigt das Verständnis, ersetzt aber nicht OpenShift-spezifische Praxis.

9.8 Rancher / RKE2 Administrator

Ziel: Kubernetes über Rancher, Rancher Prime oder RKE2 betreiben.

Empfohlener Pfad:

KCNA
  -> CKA
  -> SUSE Certified Administrator in RKE2
  -> SUSE Certified Administrator in SUSE Rancher Prime
  -> SUSE Deployment Specialist in RKE2 bei Lifecycle-Verantwortung

Warum:

Rancher und RKE2 sind Kubernetes-nahe Plattformen. CKA liefert die herstellerneutrale Basis, SUSE-Zertifizierungen ergänzen Produkttiefe.

10. Abgleich mit den Workshop- und Prüfungsleveln 01 bis 04

10.1 01 Fundamentals

Passt zu:

• KCNA,
• KCSA-Einstieg,
• Red Hat Container-/Kubernetes-Grundlagen,
• Cloud-Grundlagen mit Containerbezug,
• Vorbereitung auf CKAD/CKA.

Kernkompetenzen:

• Kubernetes-Zweck,
• Control Plane und Worker Nodes,
• Pods,
• Deployments,
• ReplicaSets,
• Services,
• Labels und Selectors,
• ConfigMaps und Secrets,
• Namespaces,
• Rollouts,
• erste Diagnose mit Logs, Events und Status.

Zertifizierungsrelevanz:

Fundamentals reicht noch nicht für CKA oder CKAD, bildet aber die notwendige Grundlage.

10.2 02 Intermediate

Passt zu:

• CKAD,
• CKA-Vorbereitung,
• Google Associate Cloud Engineer mit GKE-Aufgaben,
• Azure AKS Applied Skills,
• OpenShift Application Development,
• DevOps-Zertifizierungen mit Container-Deployment.

Kernkompetenzen:

• Deployment vs. StatefulSet vs. DaemonSet vs. Job vs. CronJob,
• Probes,
• Requests und Limits,
• QoS,
• LimitRange und ResourceQuota,
• Scheduling,
• NetworkPolicy,
• Ingress/Gateway,
• PVC/PV/StorageClass,
• Helm und Kustomize,
• systematisches Troubleshooting.

Zertifizierungsrelevanz:

Intermediate ist besonders wichtig für CKAD und bildet die praktische Grundlage für CKA.

10.3 03 Professional

Passt zu:

• CKA,
• Cloud-Architect- und DevOps-Zertifizierungen,
• CNPA/CNPE,
• SUSE Rancher / RKE2,
• Red Hat OpenShift Administration,
• Plattform- und SRE-Rollen.

Kernkompetenzen:

• Produktionsarchitektur,
• Managed vs. Self-managed vs. Hybrid,
• Node Pools und Sizing,
• Add-ons als Plattformprodukte,
• Upgrades und API Deprecations,
• Observability,
• Autoscaling,
• GitOps,
• Multi-Tenancy,
• Operatoren und CRDs,
• Backup und Disaster Recovery,
• Kostenmanagement.

Zertifizierungsrelevanz:

Professional ergänzt das, was in reinen Hands-on-Prüfungen oft nur indirekt sichtbar ist: Architektur, Betrieb, Ownership, SLOs und Plattformentscheidungen.

10.4 04 Advanced + Security

Passt zu:

• KCSA,
• CKS,
• KCA,
• CCA,
• Cloud-Security-Zertifizierungen mit Kubernetes-/Containerbezug,
• OpenShift-/Rancher-Security-Aufgaben,
• DevSecOps-Rollen.

Kernkompetenzen:

• Threat Modeling,
• RBAC und Identity,
• ServiceAccount Token-Automount,
• Pod Security Standards,
• SecurityContext,
• NetworkPolicy,
• Supply Chain Security,
• Admission Policies,
• Secrets Security,
• Runtime Detection,
• Compliance Evidence,
• Incident Response.

Zertifizierungsrelevanz:

Advanced + Security ist die direkte Vorbereitung auf CKS-nahe Fähigkeiten und ergänzt KCSA mit Praxis.

11. Zertifizierungs-Lernpfade

11.1 Pfad A: Breite Kubernetes-Grundlagen

01 Fundamentals
  -> KCNA
  -> 02 Intermediate
  -> CKAD oder CKA

Ziel: Von null auf belastbare Kubernetes-Grundlagen.

Abschlussfähigkeit:

• KCNA realistisch,
• CKAD/CKA nach zusätzlicher praktischer Übung.

11.2 Pfad B: Kubernetes Administrator

01 Fundamentals
  -> 02 Intermediate
  -> 03 Professional
  -> CKA
  -> PCA optional
  -> CCA optional

Ziel: Kubernetes-Cluster und Plattformen betreiben.

Pflichtübungen:

• Node- und Pod-Diagnose,
• Scheduling,
• Services und DNS,
• NetworkPolicy,
• Storage,
• RBAC,
• Rollouts,
• Upgrades und Backup-Grundlagen,
• Troubleshooting unter Zeitdruck.

11.3 Pfad C: Kubernetes Application Developer

01 Fundamentals
  -> 02 Intermediate
  -> CKAD
  -> CGOA oder CAPA

Ziel: Anwendungen sauber auf Kubernetes bereitstellen.

Pflichtübungen:

• Deployments,
• Jobs und CronJobs,
• Probes,
• ConfigMaps und Secrets,
• Services,
• Ingress/Gateway,
• Volumes,
• Helm/Kustomize,
• Debugging von CrashLoopBackOff, ImagePullBackOff und Service ohne Endpoints.

11.4 Pfad D: Kubernetes Security

01 Fundamentals
  -> 02 Intermediate
  -> KCSA
  -> CKA
  -> 04 Advanced + Security
  -> CKS
  -> KCA optional
  -> CCA optional

Ziel: Kubernetes-Security professionell prüfen und umsetzen.

Pflichtübungen:

• RBAC-Audit,
• Pod Security Restricted,
• ServiceAccount Token-Automount deaktivieren,
• NetworkPolicy Default Deny,
• Admission Policy,
• Secrets-Rotation,
• Supply-Chain-Review,
• Incident-Runbook,
• Evidence-Sammlung.

11.5 Pfad E: Platform Engineering

CKA
  -> CKAD
  -> 03 Professional
  -> CGOA
  -> CAPA
  -> CNPA
  -> CNPE
  -> CKS oder KCA als Security-Ergänzung

Ziel: Interne Entwicklerplattformen auf Cloud-Native-Basis konzipieren und betreiben.

Pflichtübungen:

• Plattform-Blueprint,
• GitOps-Fluss,
• Multi-Tenant-Namespace-Standard,
• Add-on-Matrix,
• Observability-SLO,
• Tenant Self-Service,
• Policy Enforcement,
• Kostenmodell,
• Betriebsübergabe.

11.6 Pfad F: Cloud Provider Kubernetes

KCNA oder Kubernetes Fundamentals
  -> CKAD/CKA je nach Rolle
  -> Cloud Provider Zertifizierung
  -> Provider-spezifisches Kubernetes: EKS, AKS oder GKE

Beispiele:

• GKE: Google Cloud Associate Cloud Engineer, Professional Cloud DevOps Engineer, Professional Cloud Architect.
• EKS: AWS Certified DevOps Engineer – Professional, AWS Solutions Architect Professional mit Container-/EKS-Kontext.
• AKS: Microsoft AKS Applied Skills, Azure DevOps Engineer Expert, Azure Solutions Architect Expert.

12. Themenmatrix: Kubernetes-Wissen nach Zertifizierung

13. Was für welche Prüfung praktisch geübt werden sollte

13.1 Für KCNA

Übe:

• Kubernetes-Komponenten erklären,
• apiVersion, kind, metadata, spec, status lesen,
• einfache Pods, Deployments und Services verstehen,
• Grundbegriffe des CNCF-Ökosystems,
• Container vs. VM vs. Pod,
• Cloud-Native-Grundprinzipien,
• einfache Security- und Observability-Grundlagen.

Nicht überpriorisieren:

• tiefe Cluster-Reparatur,
• komplexe RBAC-Eskalation,
• produktive Multi-Tenancy,
• fortgeschrittene Runtime Security.

13.2 Für KCSA

Übe:

• Bedrohungsmodell für Kubernetes,
• RBAC-Grundlagen,
• Pod Security Standards,
• NetworkPolicy-Grundlagen,
• Secrets und Base64-Abgrenzung,
• Admission-Grundlagen,
• Supply-Chain-Grundlagen,
• Compliance- und Security-Begriffe.

Nicht überpriorisieren:

• komplexe Shell-Speed-Aufgaben,
• vollständige CKS-Labs ohne Admin-Grundlage.

13.3 Für CKAD

Übe intensiv:

• YAML schnell und korrekt schreiben,
• Deployments, Jobs, CronJobs,
• ConfigMaps und Secrets,
• Probes,
• Volumes,
• Services,
• Labels und Selectors,
• Resource Requests und Limits,
• Debugging von Anwendungen,
• kubectl explain, kubectl logs, kubectl describe, kubectl get events.

Prüfe dich selbst:

kubectl apply --dry-run=server -f <manifest>.yml
kubectl rollout status deployment/<name> -n <namespace>
kubectl get pods --show-labels -n <namespace>
kubectl get svc,endpoints,endpointslices -n <namespace>
kubectl logs <pod> -n <namespace>

13.4 Für CKA

Übe intensiv:

• Cluster- und Node-Diagnose,
• Scheduling,
• Taints und Tolerations,
• Services und DNS,
• NetworkPolicy-Grundlagen,
• Storage und PVCs,
• RBAC,
• Rollouts,
• Troubleshooting,
• Backup- und Upgrade-Grundkonzepte,
• kubectl sicher unter Zeitdruck.

Prüfe dich selbst:

kubectl get nodes -o wide
kubectl describe node <node>
kubectl get events -A --sort-by=.metadata.creationTimestamp
kubectl auth can-i <verb> <resource> --as <subject> -n <namespace>
kubectl get pvc,pv,storageclass -A
kubectl describe pod <pod> -n <namespace>

13.5 Für CKS

Übe intensiv:

• RBAC-Audit mit kubectl auth can-i,
• Pod Security Restricted,
• securityContext,
• automountServiceAccountToken: false,
• NetworkPolicy Default Deny,
• Admission Policies,
• Secrets-Rotation,
• Image- und Supply-Chain-Review,
• Runtime Detection,
• Audit Logs,
• Incident Response und Evidence.

Prüfe dich selbst:

kubectl auth can-i get secrets --as system:serviceaccount:<ns>:<sa> -n <ns>
kubectl get role,rolebinding,clusterrole,clusterrolebinding -A
kubectl label namespace <ns> pod-security.kubernetes.io/enforce=restricted --overwrite
kubectl get networkpolicy -n <ns>
kubectl describe pod <pod> -n <ns>
kubectl get events -n <ns> --sort-by=.metadata.creationTimestamp

13.6 Für OpenShift-Zertifizierungen

Übe zusätzlich zu Kubernetes:

• oc statt nur kubectl,
• OpenShift Projects,
• Routes,
• Builds,
• ImageStreams oder aktuelle Build-Mechanismen,
• Security Context Constraints,
• OpenShift Operators,
• OpenShift Console,
• OpenShift-spezifisches RBAC,
• OpenShift Networking und Storage,
• OpenShift-Cluster-Administration.

13.7 Für Rancher/RKE2-Zertifizierungen

Übe zusätzlich zu Kubernetes:

• Rancher Prime Architektur,
• Cluster Import und Provisionierung,
• Downstream Cluster,
• Rancher Authentifizierung und Autorisierung,
• RKE2-Clusterbetrieb,
• Backup und Restore,
• Fleet/GitOps,
• Rancher Monitoring, Security und Observability,
• Multi-Cluster-Management.

13.8 Für Cloud-Provider-Zertifizierungen

Übe zusätzlich zu Kubernetes:

• IAM und Workload Identity,
• VPC/VNet/Subnetze,
• Load Balancer,
• Managed Node Pools,
• Autoscaling,
• Container Registry,
• Secrets Manager / Key Vault / Secret Manager,
• Cloud-native Logging und Monitoring,
• Provider-spezifische Sicherheits- und Betriebsmodelle.

14. Prüfungsvorbereitung ohne Brain Dumps

14.1 Zulässig und sinnvoll

• offizielle Exam Guides,
• offizielle Dokumentation,
• eigene Labs,
• eigene Notizen,
• öffentlich erlaubte Beispielaufgaben,
• Mock Exams, sofern sie keine echten Prüfungsfragen kopieren,
• Workshops und Übungen,
• Wiederholung von Kernaufgaben unter Zeitdruck.

14.2 Nicht verwenden

• Brain Dumps,
• echte Prüfungsfragen,
• kopierte geschützte Aufgaben,
• geteilte Prüfungs-Screenshots,
• Lösungen aus echten Prüfungssessions,
• nicht autorisierte Question Banks.

14.3 Warum das wichtig ist

Zertifizierungen sollen nachweisen, dass du reale Aufgaben lösen kannst. Gerade CKA, CKAD und CKS sind praxisnah. Wer nur Antworten auswendig lernt, scheitert später im Betrieb an einfachen Fehlern wie:

• falscher Namespace,
• falscher Selector,
• fehlender Endpoint,
• falscher ServiceAccount,
• PVC Pending,
• zu aggressive Liveness Probe,
• fehlende Requests,
• überbreites RBAC,
• unsichere Pod-Spec,
• unklare Incident-Evidence.

15. Prüfliste vor der Anmeldung

Vor jeder Zertifizierungsanmeldung prüfen:

16. Pflegehinweise für diese Datei

Diese Datei sollte regelmäßig aktualisiert werden, mindestens:

• einmal pro Quartal,
• vor jedem neuen Workshop-Durchlauf,
• vor jeder Prüfungsvorbereitung,
• nach größeren Kubernetes-Releases,
• nach Änderungen bei CNCF/Linux Foundation,
• nach Änderungen bei Red Hat, SUSE, AWS, Google Cloud oder Microsoft.

Empfohlene Pflegefelder:

Letzte Prüfung: <Datum>
Geprüfte Quellen:
- CNCF Certification Page
- Linux Foundation Certification Catalog
- Kubernetes Training Page
- Red Hat Certification Pages
- SUSE Certification Pages
- AWS Certification Exam Guides
- Google Cloud Certification Guides
- Microsoft Learn Credentials
Offene Punkte:
- Preise prüfen
- Exam-Versionen prüfen
- Sprachen prüfen
- Gültigkeitsdauer prüfen
- Voraussetzungen prüfen

17. Offizielle Quellen

17.1 CNCF / Kubernetes / Linux Foundation

• CNCF Cloud Native Certifications: https://www.cncf.io/training/certification/
• Kubernetes Training and Certification: https://kubernetes.io/training/
• Linux Foundation Certification Catalog: https://training.linuxfoundation.org/certification-catalog/
• Certified Kubernetes Administrator: https://training.linuxfoundation.org/certification/certified-kubernetes-administrator-cka/
• Certified Kubernetes Application Developer: https://training.linuxfoundation.org/certification/certified-kubernetes-application-developer-ckad/
• Certified Kubernetes Security Specialist: https://training.linuxfoundation.org/certification/certified-kubernetes-security-specialist/
• Kubernetes and Cloud Native Associate: https://training.linuxfoundation.org/certification/kubernetes-cloud-native-associate/
• Kubernetes and Cloud Native Security Associate: https://training.linuxfoundation.org/certification/kubernetes-and-cloud-native-security-associate-kcsa/
• Kubestronaut Bundle: https://training.linuxfoundation.org/certification/kubestronaut-bundle/
• Linux Foundation Certification Verification: https://training.linuxfoundation.org/certification/verify/

17.2 Red Hat

• Red Hat Certified Specialist in Containers and Kubernetes: https://www.redhat.com/en/services/certification/red-hat-certified-specialist-in-containers-and-kubernetes
• Red Hat Certified OpenShift Administrator exam / EX280: https://www.redhat.com/en/services/training/red-hat-certified-openshift-administrator-exam
• Red Hat Certified Advanced Developer in Cloud-native Applications / EX288: https://www.redhat.com/en/services/certification/rhcs-openshift-application-development
• Red Hat individual exams overview: https://www.redhat.com/en/services/certification/individual-exams

17.3 SUSE / Rancher

• SUSE Certified Administrator in SUSE Rancher Prime: https://www.suse.com/training/exam/sca_ran_prime/
• SUSE Certified Administrator in Rancher Kubernetes Engine 2: https://www.suse.com/training/exam/sca_rke2/
• SUSE Certified Deployment Specialist in Rancher Kubernetes Engine 2: https://www.suse.com/training/exam/scds_rke2/
• SUSE Certification Exams: https://www.suse.com/training/exam/

17.4 Google Cloud

• Google Cloud Certifications: https://cloud.google.com/learn/certification
• Associate Cloud Engineer: https://cloud.google.com/learn/certification/cloud-engineer
• Professional Cloud Architect Guide: https://cloud.google.com/learn/certification/guides/professional-cloud-architect
• Professional Cloud DevOps Engineer: https://cloud.google.com/learn/certification/cloud-devops-engineer
• Professional Cloud DevOps Engineer Guide: https://cloud.google.com/learn/certification/guides/cloud-devops-engineer
• Google Kubernetes Engine: https://cloud.google.com/kubernetes-engine

17.5 AWS

• AWS Certification Overview: https://aws.amazon.com/certification/
• AWS Certified DevOps Engineer – Professional: https://aws.amazon.com/certification/certified-devops-engineer-professional/
• AWS Certified DevOps Engineer – Professional Exam Guide: https://docs.aws.amazon.com/aws-certification/latest/devops-engineer-professional-02/
• In-scope services for AWS Certified DevOps Engineer – Professional: https://docs.aws.amazon.com/aws-certification/latest/devops-engineer-professional-02/dop-02-in-scope-services.html
• Amazon Elastic Kubernetes Service: https://aws.amazon.com/eks/

17.6 Microsoft Azure

• Microsoft Credentials Browse: https://learn.microsoft.com/en-us/credentials/browse/
• Microsoft Certified: DevOps Engineer Expert: https://learn.microsoft.com/en-us/credentials/certifications/devops-engineer/
• Exam AZ-400: https://learn.microsoft.com/en-us/credentials/certifications/exams/az-400/
• Microsoft Certified: Azure Solutions Architect Expert: https://learn.microsoft.com/en-us/credentials/certifications/azure-solutions-architect/
• Deploy containers by using Azure Kubernetes Service – Applied Skills Study Guide: https://learn.microsoft.com/en-us/credentials/applied-skills/resources/study-guides/apl-1001
• Azure Kubernetes Service documentation: https://learn.microsoft.com/en-us/azure/aks/

18. Empfehlung für diesen Workshop

Für diesen Workshop ist folgende Struktur sinnvoll:

01-fundamentals-*      -> KCNA-Basis und CKAD/CKA-Vorbereitung
02-intermediate-*      -> CKAD-Kern, CKA-Basis, Cloud-AKS/EKS/GKE-Praxis
03-professional-*      -> CKA-Erweiterung, Plattformbetrieb, Cloud-/Platform-Engineering-Pfade
04-advanced-security-* -> KCSA/CKS/KCA/CCA-Security-Pfad
05-official-certificates-kubernetes-DE.md -> Zertifizierungslandkarte und Lernpfade

Zusätzlich empfehlenswert:

certification-paths/
  kcna-checklist.md
  ckad-checklist.md
  cka-checklist.md
  kcsa-checklist.md
  cks-checklist.md
  openshift-path.md
  rancher-rke2-path.md
  cloud-provider-kubernetes-path.md

Jede Checkliste sollte enthalten:

• offizielle Exam-Seite,
• aktuelle Blueprint-Version,
• prüfungsrelevante Workshop-Dateien,
• praktische Mindestlabs,
• typische Fehlerbilder,
• Zeitplan,
• Nachweisdateien,
• offene Wissenslücken.