Cloud-Native Developer

Für Softwareentwickler: Sie üben, eigene Anwendungen auf einer von anderen betriebenen Kubernetes-Plattform bereitzustellen, zu konfigurieren und Fehler zu beheben, bis zur Vorbereitung auf die separat gebuchte Prüfung Certified Kubernetes Application Developer (CKAD) der Linux Foundation. Automatisierte Build-Pipelines, Telemetrie (Messdaten), Operatorentwicklung und GitOps-Auslieferung sind optionale Ergänzungen außerhalb der Kernroute.

Einstieg in 3 Fragen bestimmenRoute, Dauer & Preise ansehen

DER LERNPFAD IM ÜBERBLICK

Cloud-Native Developer: Stufen, Umfang und Reihenfolge

Die Route führt in 5 Stufen von „Vorwissen“ bis „Rollenfokus“. Workshops, Trainingstage und Preis beziehen sich auf die Kernroute.

  • 4 Workshops · Kernroute
  • 10–11 Trainingstage · Kernroute
  • 5.550 bis 6.105 € netto · Kernroute

  1. Vorwissen

    Bestehende Erfahrung kann einzelne Stationen ersetzen.

  2. Container-Fundament

    Eine der beiden Container-Grundlagen führt in den gemeinsamen Kubernetes-Einstieg.

  3. Kubernetes-Einstieg

    Praktische Grundlage für spätere Rollenaufgaben und Zertifizierungsziele mit praktischer Prüfung.

  4. Betriebspraxis

    Sie vertiefen Anwendungsbetrieb, Skalierung, Zugriffs- und Netzregeln, Betriebssignale und Konfiguration je Umgebung.

  5. Rollenfokus

    Dieser Lernpfad folgt einem Rollenpfad, den optionale Themen vertiefen.

Ihre Route durch den Lernpfad

EIGENER LERNPFAD

Was Sie bereits mitbringen

Prüfen Sie, welche Lernschritte Sie noch benötigen.

Einstieg mit 3 Fragen finden

TEAMROUTE: OPTIONAL

Ein gemeinsames Schulungsprogramm planen

Rollen → Kompetenzlücken → gemeinsamer Plan

Ergebnis: eine nachvollziehbare Route für das gesamte Team.

Ihre Selbsteinschätzung

Wählen Sie jeweils die Antwort, die Ihre aktuelle Situation am besten beschreibt.

Empfehlung ohne Kontaktdaten oder Anmeldung

Ziel durch diesen Lernpfad festgelegt

Kompetenzen, Reihenfolge, Workshops

Welche Kubernetes-Kompetenzen bauen aufeinander auf?

Die Lernschritte zeigen die empfohlene Reihenfolge dieses Pfads. Je nach Ziel kommen Spezialisierungen, optionale Vertiefungen oder Zertifizierungsziele hinzu. Zu jedem Lernschritt sehen Sie, welche Workshops die Inhalte abdecken.

So lesen Sie den Lernpfad
  • Pflicht oder empfohlen
  • Auswahl
  • Optionale Vertiefung
  • Weiterführender Lernpfad

Vorbereitung

Vorab bei Bedarf; nicht in Workshopzahl, Tagen und Preis eingerechnet.

5 Kompetenzen anzeigen

  • Vorwissen

    Bestehende Erfahrung kann einzelne Stationen ersetzen.

    • VORWISSENOptionalBEI BEDARF
      Linux und Netzwerkzugriff

      Kommandozeile, Prozesse, Dateisystem, Erreichbarkeit, Ports, SSH-Zugriff

      Sie üben Linux-Befehle, Prozesse und Dateirechte, prüfen Netzwerkschnittstellen, Erreichbarkeit und offene Ports und verbinden sich per SSH mit entfernten Rechnern. Der Linux-Workshop ist bei fehlenden Kenntnissen sinnvoll; YAML als Konfigurationsformat führen die Docker- und Podman-Workshops ein.

      Danach können Sie im Linux-Terminal Dateien, Rechte und Prozesse prüfen, Netzwerkprobleme eingrenzen und per SSH auf entfernten Rechnern arbeiten.

      Wenn Ihnen Linux-Praxis fehlt, nutzen Sie den Linux-Workshop; vorhandene Erfahrung genügt. Für die CKAD-Vorbereitung ist Vertrautheit mit der Linux-Kommandozeile wichtig, YAML-Dateien sollten Sie idealerweise bearbeiten können.

      4 Lernschritte

      1. Im Dateisystem navigieren

        Mit Shell-Befehlen navigieren Sie durch Verzeichnisse und suchen Dateiinhalte, um sich auf einem Linux-System zurechtzufinden.

      2. Rechte und Prozesse prüfen

        Sie prüfen Dateirechte und laufende Prozesse, um Zugriffsgrenzen zu verstehen und hängende Prozesse gezielt zu beenden.

      3. Netzwerkzugang untersuchen

        Netzwerkschnittstellen, Erreichbarkeit und offene Ports prüfen Sie getrennt, um Verbindungsprobleme einzugrenzen.

      4. Entfernte Rechner per SSH erreichen

        Über SSH verbinden Sie sich mit einem entfernten Rechner, um die Arbeit im Terminal auf ein anderes System zu übertragen.

      • Voraussetzung: Der Kubernetes-Einstieg setzt Linux- und Terminal-Grundlagen voraus; bringen Sie diese bereits mit, benötigen Sie den Linux-Workshop nicht.
    • VORWISSENOptionalBEI BEDARF
      Git und Zusammenarbeit

      Commits, Branches, Merges, Remotes, Reviews

      Sie versionieren Änderungen mit Git und üben die Zusammenarbeit über Branches und Reviews. Wählen Sie die Einführung in Git oder den Workshop mit GitLab als Plattform.

      Danach können Sie Änderungen mit Git versionieren, über Branches und Remotes teilen sowie nach einem Review zusammenführen und Merge-Konflikte lösen.

      Wenn Ihnen Git-Praxis fehlt, üben Sie Commits, Branches und Reviews mit Git oder GitLab.

      4 Lernschritte

      1. Änderungen als Commits festhalten

        Sie verfolgen Änderungen vom Arbeitsverzeichnis über die Staging Area bis zum Commit, um gezielt einen Stand zu versionieren.

      2. Arbeit auf Branches aufteilen

        Auf eigenen Branches bearbeiten Sie Änderungen getrennt und vergleichen sie, bevor Sie die Arbeit wieder zusammenführen.

      3. Änderungen über Remotes austauschen

        Mit Remote-Repositories teilen Sie Commits und unterscheiden das Abrufen fremder Änderungen von deren Integration.

      4. Änderungen prüfen und zusammenführen

        Im Review besprechen Sie Änderungen anhand ihrer Unterschiede und lösen Merge-Konflikte, um Beiträge abgestimmt zusammenzuführen.

      1 von 2 wählen

      Wählen Sie den Git-Workshop als Einstieg, bei GitLab im Team den GitLab-Workshop.

      • Voraussetzung: Die Arbeit an GitLab-Pipelines setzt Git-Grundlagen voraus; vorhandene Erfahrung kann den Grundlagenworkshop ersetzen.
      • Voraussetzung: Argo CD und Flux setzen Git-Kenntnisse mit Branches und Pull Requests voraus; ein zusätzlicher Workshop ist bei vorhandener Erfahrung nicht nötig.
    • VORWISSENOptionalBEI BEDARF
      Go für die Entwicklung

      Typen, Interfaces, Fehlerbehandlung, Tests, HTTP

      Sie übertragen vorhandene Programmiererfahrung auf Go und üben Typen, Interfaces, Fehlerbehandlung und Tests. Für die Operatorentwicklung ist dieser Workshop eine optionale Vorbereitung; dort beginnt die Arbeit mit einem Go-Crashkurs.

      Danach können Sie Go-Code mit Typen und Interfaces strukturieren, HTTP-Handler schreiben, Fehler explizit behandeln und Verhalten mit Unit Tests prüfen.

      Wenn Sie später Operatoren entwickeln möchten und Go noch nicht kennen, können Sie hier vorarbeiten. Programmiererfahrung in einer anderen Sprache ist erforderlich; der Operator-Workshop selbst beginnt bereits mit einem Go-Crashkurs.

      4 Lernschritte

      1. Daten und Funktionen in Go ausdrücken

        Vorhandene Programmierkenntnisse übertragen Sie auf Go-Typen, Kontrollstrukturen und Funktionen, um erste Abläufe zu formulieren.

      2. Verhalten über Interfaces verbinden

        Mit Structs, Methoden und Interfaces modellieren Sie Daten und Verhalten, damit Code mit unterschiedlichen Typen arbeiten kann.

      3. HTTP-Anfragen verarbeiten

        Mit der Standardbibliothek bauen Sie HTTP-Handler und verarbeiten JSON-Daten, um Go-Code über eine HTTP-Schnittstelle anzusprechen.

      4. Fehler behandeln und Verhalten testen

        Fehler behandeln Sie als Rückgabewerte und prüfen Verhalten mit Unit Tests, um Fehlerfälle im Code bewusst zu berücksichtigen.

      • DW17 Einführung in die Go-ProgrammierungBei Bedarf für eine ausführlichere Einführung in Go; Programmiererfahrung in einer anderen Sprache wird vorausgesetzt.Einsteiger3 TageOnline, Unterrichtssprache: Deutsch
      • Empfohlene Folge: Eine ausführlichere Go-Einführung kann Sie auf die Operatorentwicklung vorbereiten; der Operator-Workshop enthält bereits einen Go-Crashkurs.

  • Container-Fundament

    Eine der beiden Container-Grundlagen führt in den gemeinsamen Kubernetes-Einstieg.

    1 von 2 wählen

    Wählen Sie Podman bei Podman im Team oder auf der Zielplattform oder wenn Container ohne Root-Rechte laufen müssen, sonst Docker.

    • CONTAINEROptionalWAHL
      Docker-Grundlagen

      Images, Container, Volumes, Netzwerke

      Sie bauen Container-Images mit Dockerfiles, auch mit getrennten Bauphasen, und starten Container mit dauerhaftem Speicher und Netzwerkverbindungen. Mit Docker Compose betreiben Sie zusammengehörige Anwendungsdienste.

      Danach können Sie eigene Images bauen, Container mit dauerhaftem Speicher vernetzen und zusammengehörige Anwendungsdienste mit Docker Compose betreiben.

      Wenn Sie noch keine eigenen Container-Images bauen, ergänzen Sie Docker-Praxis für Ihr CKAD-Ziel; der Kubernetes-Einstieg setzt Container-Erfahrung nicht voraus. CKAD umfasst das Definieren, Bauen und Ändern von Images; die Agenda der CKAD-Vorbereitung enthält dafür keine eigene Übung.

      4 Lernschritte

      1. Images und Container unterscheiden

        Sie starten Container aus Images und untersuchen ihren Zustand, um die Vorlage von der laufenden Anwendung zu unterscheiden.

      2. Eigene Images bauen

        Beim Image-Bau trennen Sie Bauphasen und Laufzeitbestandteile, damit benötigte Bauwerkzeuge nicht im fertigen Image bleiben müssen.

      3. Speicher und Netzwerke anbinden

        Mit Volumes erhalten Sie Daten über Container-Neustarts hinweg und verbinden Container über Netzwerke für den Datenaustausch.

      4. Dienste mit Compose zusammenführen

        In Docker Compose beschreiben Sie Dienste, Speicher und Netzwerke mit YAML und prüfen deren Zusammenspiel in einer Anwendung.

      • Empfohlene Folge: Container-Erfahrung erleichtert den Kubernetes-Einstieg, ist für den Grundlagenworkshop aber keine Voraussetzung.
      • Ersatzroute: Das Bündel verbindet Docker und Kubernetes durchgängig mit gemeinsamer Buchung und Lerngruppe statt getrennten Terminen. Es setzt mehr Vorwissen voraus: Linux-Kommandozeile sowie Grundlagen der Entwicklung oder Systemadministration.
    • CONTAINERAlternativeWAHL
      Podman-Grundlagen

      Rootless Container, Pods, Images

      Sie bauen Container-Images mit Podman und betreiben Container ohne Root-Rechte mit dauerhaftem Speicher und Netzwerkverbindungen. Zusammengehörige Container fassen Sie in Pods zusammen.

      Danach können Sie Podman-Images bauen, Container ohne Root-Rechte mit Netzwerk und dauerhaftem Speicher betreiben und in Pods gruppieren.

      Wenn Ihr Team Podman nutzt oder Container ohne Root-Rechte benötigt, wählen Sie Podman statt Docker. Fehlende Praxis beim Bauen eigener Images ergänzen Sie hier für Ihr CKAD-Ziel; die Agenda der CKAD-Vorbereitung enthält dafür keine eigene Übung.

      4 Lernschritte

      1. Rootless-Betrieb verstehen

        An Podmans Architektur verstehen Sie, wie Container ohne zentralen Daemon unter Ihrem Benutzerkonto laufen.

      2. Images bauen und verwalten

        Sie bauen Images und verwalten sie in Registries, um Anwendungen als wiederverwendbare Grundlage für Container bereitzustellen.

      3. Netzwerk und Speicher anbinden

        Mit Netzwerken und Volumes verbinden Sie Container und erhalten Daten, wobei Sie Dateirechte im Rootless-Betrieb prüfen.

      4. Container in Pods zusammenführen

        In Pods fassen Sie zusammengehörige Container zusammen und prüfen ihre Kommunikation über das gemeinsam genutzte Netzwerk.

      • Empfohlene Folge: Container-Erfahrung erleichtert den Kubernetes-Einstieg, ist für den Grundlagenworkshop aber keine Voraussetzung.

Kernroute

Jede Nummer steht für einen eingerechneten Workshop, der mehrere Kompetenzen abdecken kann.

  1. Workshop-Schritt 1 von 4:

    Kubernetes-Einstieg

    Praktische Grundlage für spätere Rollenaufgaben und Zertifizierungsziele mit praktischer Prüfung.

    • KUBERNETES-EINSTIEGKernschrittSelbstangabeKERN
      Kubernetes-Einstieg

      Architektur, Pods, Deployments, Deployment-Strategien, Services, Namespaces, CoreDNS, Storage und CSI, ConfigMaps, Secrets, kubectl

      Sie stellen Anwendungen mit Kubernetes bereit, machen sie erreichbar und konfigurieren und untersuchen sie mit kubectl, dem Befehlswerkzeug für Kubernetes. Dazu richten Sie grundlegenden dauerhaften Speicher für Anwendungen ein.

      Danach können Sie Anwendungen in Kubernetes bereitstellen, erreichbar machen, mit Konfiguration und dauerhaftem Speicher versorgen und mit kubectl untersuchen.

      Wenn Ihnen Kubernetes-Praxis fehlt, stellen Sie im eigenen Cluster des Browserlabs eine Anwendung bereit, machen sie erreichbar und untersuchen und beheben Fehler mit kubectl. Die CKAD-Vorbereitung wiederholt Grundlagen im Prüfungstempo; Teams mit solider Kubernetes-Praxis können später in die Route einsteigen.

      5 Lernschritte

      1. Architektur und Pods verstehen

        Sie verfolgen das Zusammenspiel von Control Plane, Nodes und Pods und untersuchen mit kubectl den Zustand Ihrer ersten Pods.

      2. Anwendungen bereitstellen und aktualisieren

        Mit Deployments stellen Sie Anwendungen bereit und vergleichen Aktualisierungsstrategien, um deren Risiken einzuordnen.

      3. Erreichbarkeit und Namensauflösung

        Services machen Pods erreichbar, während Sie mit Namespaces Ressourcen gliedern und mit CoreDNS die Namensauflösung prüfen.

      4. Konfiguration vom Image trennen

        Über ConfigMaps und Secrets binden Sie Konfiguration und sensible Werte in Pods ein, damit diese getrennt vom Image bleiben.

      5. Dauerhaften Speicher prüfen

        Sie binden Volumes an Pods, ordnen CSI und StorageClasses ein und prüfen, ob Daten einen Pod-Neustart überstehen.

      • Voraussetzung: Die Arbeit mit Helm oder Kustomize setzt Kubernetes-Grundlagen voraus: Deployments, Services und einfache YAML-Manifeste.
  2. Workshop-Schritt 2 von 4:

    Betriebspraxis

    Sie vertiefen Anwendungsbetrieb, Skalierung, Zugriffs- und Netzregeln, Betriebssignale und Konfiguration je Umgebung.

    Hier vertiefen Sie Ihr Wissen über Workloads, Skalierung, Netzwerkzugriff und grundlegende Betriebssignale. Der jeweilige Lernpfad legt fest, ob Sie diese Vertiefung als Kern oder optional nutzen.

    • BETRIEBSPRAXISKernschrittSelbstangabeKERN
      Workloads und Skalierung

      StatefulSets, Datenbank-Operatoren, Scheduling, Ressourcenmanagement, HPA, VPA, KEDA

      Sie untersuchen zustandsbehaftete Workloads mit StatefulSets und setzen Datenbank-Operatoren ein. Mit Ressourcenangaben und Scheduling-Vorgaben steuern Sie die Platzierung von Pods. Autoscaling konfigurieren Sie mit HPA, VPA und KEDA.

      Danach können Sie StatefulSets untersuchen, Datenbank-Operatoren einsetzen, die Pod-Platzierung steuern und Autoscaling mit HPA, VPA und KEDA konfigurieren.

      Als Anwendungsentwickler untersuchen Sie, wie angeforderte Ressourcen und Obergrenzen, die Platzierung im Cluster (Scheduling) und automatische Skalierung Ihre Anwendung beeinflussen. Datenbank-Operatoren und ereignisgesteuerte Skalierung zeigen ergänzend Aufgaben des Plattformbetriebs.

      4 Lernschritte

      1. Zustandsbehaftete Workloads verstehen

        An einer Datenbank als StatefulSet untersuchen Sie, warum stabile Pod-Identitäten und dauerhafter Speicher zusammengehören.

      2. Datenbank-Operatoren einsetzen

        Sie richten Datenbank-Operatoren ein und betrachten ihre Vor- und Nachteile, um ihren Beitrag zum Datenbankbetrieb einzuschätzen.

      3. Ressourcen und Platzierung steuern

        Mit Ressourcenanforderungen und Scheduling-Vorgaben steuern Sie, auf welchen Nodes Pods laufen können, und beobachten ihre Platzierung.

      4. Skalierungsansätze unterscheiden

        Sie konfigurieren HPA, VPA und KEDA und unterscheiden dabei Pod-Anzahl, Ressourcenanpassung und Ereignisse als Skalierungsgrundlage.

    • BETRIEBSPRAXISKernschrittSelbstangabeKERN
      Netzwerk, Zugriff und Betrieb

      Ingress und Gateway API im Überblick, Service Mesh im Überblick, Network Policies, RBAC, Monitoring, Logging

      Sie ordnen Ingress, Gateway API und Service Mesh ein und üben RBAC und Network Policies. Mit Prometheus und Grafana richten Sie grundlegendes Monitoring ein, mit Loki das Logging. Gateway-API-Migration und Controller-Portabilität gehören nicht zum praktischen Umfang.

      Danach können Sie Netzwerkansätze einordnen, API-Zugriff und Kommunikation begrenzen sowie grundlegendes Monitoring und Logging für Kubernetes einrichten.

      Als Anwendungsentwickler prüfen Sie Zugriffsrechte (RBAC) und Netzwerkregeln (NetworkPolicies), um blockierte Anwendungszugriffe selbst zu diagnostizieren. Im selben Workshop Kubernetes Advanced richten Sie Überwachung und Protokollierung (Monitoring und Logging) ein, um den Betrieb zu verstehen, ohne Plattformverantwortung zu übernehmen.

      4 Lernschritte

      1. Routing und Service Mesh einordnen

        Sie vergleichen die Aufgaben von Ingress, Gateway API und Service Mesh, um deren Einsatzbereiche und Grenzen einzuordnen.

      2. API-Zugriff und Kommunikation begrenzen

        Mit RBAC begrenzen Sie API-Aktionen und mit Network Policies die Kommunikation, um diese Schutzaufgaben getrennt zu bearbeiten.

      3. Metriken erfassen und darstellen

        Sie richten Prometheus und Grafana per Operator ein, um Cluster-Metriken zu sammeln und in Dashboards sichtbar zu machen.

      4. Logs bündeln und Benachrichtigungen setzen

        Mit Loki bündeln Sie Cluster-Logs und ergänzen grundlegende Benachrichtigungen, damit Hinweise auf Betriebsprobleme zusammenkommen.

  3. Workshop-Schritt 3 von 4:
    • BETRIEBSPRAXISKernschrittSelbstangabeWAHL
      Manifeste verwalten

      Umgebungskonfiguration, Wiederverwendung, Helm oder Kustomize

      Sie strukturieren Kubernetes-Konfigurationen für unterschiedliche Umgebungen. Wählen Sie Helm mit Charts und Values oder Kustomize mit Bases, Overlays und Patches. Die Wahl umfasst die Arbeit mit einem Werkzeug, nicht mit beiden.

      Danach können Sie mit Helm oder Kustomize wiederverwendbare Kubernetes-Konfigurationen strukturieren, für Umgebungen anpassen und die erzeugten Ressourcen prüfen.

      Wenn Sie Anwendungskonfigurationen verwalten, wählen Sie nach Teampraxis Helm oder Kustomize und üben ein Werkzeug vertieft. Die CKAD-Vorbereitung führt beide kurz ein, Helm nur zur Nutzung bestehender Pakete: installieren, aktualisieren und zurückrollen, ohne eigene Charts zu schreiben.

      4 Lernschritte

      1. Gemeinsamkeiten und Unterschiede erkennen

        Sie unterscheiden gemeinsame Konfiguration von Umgebungsunterschieden, um wiederverwendbare Teile Ihrer Manifeste zu erkennen.

      2. Wiederverwendbare Struktur aufbauen

        Mit Helm oder Kustomize strukturieren Sie gemeinsame Ressourcen, damit Umgebungsvarianten auf derselben Grundlage aufbauen.

      3. Umgebungsvarianten umsetzen

        Im gewählten Werkzeug setzen Sie gezielte Anpassungen für Staging und Produktion um, damit jede Umgebung ihre eigene Konfiguration erhält.

      4. Erzeugte Ressourcen prüfen

        An den erzeugten Ressourcen prüfen Sie, wie gemeinsame Vorgaben und Anpassungen zusammenwirken, um Konfigurationsfehler zu erkennen.

      1 von 2 wählen

      Helm paketiert, versioniert und liefert Software als Charts; Kustomize passt vorhandene Manifeste je Umgebung per Overlay ohne Vorlagen an.

      • Empfohlene Folge: Charts oder Overlays bilden eine Grundlage für die Konfiguration, die Argo CD oder Flux abgleicht.
  4. Workshop-Schritt 4 von 4:

    Rollenfokus

    Dieser Lernpfad folgt einem Rollenpfad, den optionale Themen vertiefen.

    • ROLLENPFADKernschrittROLLENPFAD
      Development

      Anwendungen ausliefern, konfigurieren und Fehler untersuchen.

      Ab hier liegt der Schwerpunkt darauf, Anwendungen bereitzustellen, zu konfigurieren und zu debuggen.

    • ROLLENKOMPETENZKernschrittSelbstangabeROLLENPFAD
      Workloads entwickeln & debuggen

      Probes, Ressourcen, Debugging, Rollouts

      Sie stellen Anwendungen bereit und konfigurieren sie samt Zustandsprüfungen (Probes) und Ressourcenangaben; Fehler bei Aktualisierungen untersuchen Sie systematisch. Damit bereiten Sie sich auf die Prüfung Certified Kubernetes Application Developer (CKAD) vor; die Teilnahme ist keine Zertifizierung.

      Danach können Sie Workloads konfigurieren, Probes und Ressourcenangaben einsetzen, Rollouts steuern und Fehler mit kubectl systematisch untersuchen.

      Mit Kubernetes-Grundlagen vertiefen Sie Muster für zusammenarbeitende Container und üben zusätzliche Themen: Aufgaben und Zeitpläne (Jobs und CronJobs), Anwendungsidentitäten und Sicherheitsregeln (ServiceAccounts und SecurityContexts), Netzwerkregeln und externe Zugriffe (NetworkPolicies und Ingress) sowie die Nutzung eigener Ressourcentypen. Die CKAD-Vorbereitung wiederholt Grundlagen im Prüfungstempo mit direkten kubectl-Befehlen und enthält eine Prüfungssimulation; die Prüfung buchen Sie separat.

      4 Lernschritte

      1. Workloads aufbauen und konfigurieren

        Sie erstellen Pods und Deployments und binden Konfiguration ein, um Anwendungsausführung und Einstellungen getrennt zu verwalten.

      2. Zustand und Ressourcen beurteilen

        An Probes und Ressourcenangaben untersuchen Sie, wie Kubernetes auf den Anwendungszustand reagiert und wo Ressourcenbegrenzungen wirken.

      3. Rollouts steuern

        Mit Deployments üben Sie Aktualisierungen und Rollbacks, um den Wechsel zwischen Anwendungsversionen nachvollziehen und steuern zu können.

      4. Fehler anhand von Befunden eingrenzen

        Bei fehlerhaften Pods und Rollouts prüfen Sie Logs, Zustände und Ressourcenlimits, um mögliche Ursachen systematisch einzugrenzen.

      • DW5 CKAD-Prüfungsvorbereitungvertieft und praktisch geübtAufbau3 TageOnline, Unterrichtssprache: DeutschCKAD: Performance-Prüfung, 120 Min., Prüfungsanmeldung USD 445 (ein Wiederholungsversuch inklusive), Stand 4. August 2026; separat bei der Linux Foundation buchen und bezahlen, nicht in angezeigten Preisen enthalten.
      • Voraussetzung: Die geübte Bereitstellung, Konfiguration und Fehleranalyse bildet die Grundlage dafür, eigene Anwendungen auf einem vorhandenen Kubernetes-Cluster zu betreiben.
      5 weitere Beziehungen
      • Empfohlene Folge: Der Rollenpfad Development vertieft diese Kompetenz.
      • Optionale Vertiefung: Wenn Sie HTTP-Services entwickeln, können Sie die Kubernetes-Anwendungspraxis um Instrumentierung und Telemetrie-Pipelines ergänzen.
      • Optionale Vertiefung: Sie können die Anwendungspraxis bis zu eigenen Ressourcen und einem eigenen Kubernetes-Controller vertiefen.
      • Optionale Vertiefung: Sie können die Anwendungspraxis um Image-Builds und Prüfungen in GitLab-Pipelines ergänzen.
      • Optionale Vertiefung: Sie können die Bereitstellung Ihrer Anwendungen mit Argo CD oder Flux automatisieren.

Mögliche Ziele

Dieser Pfad baut die fachlichen Grundlagen für diese Ziele auf.

  • ZielEigene Anwendungen betreibenIn der Vorbereitung auf Certified Kubernetes Application Developer (CKAD) üben Sie Bereitstellung, Zugriff, Konfiguration und Fehleranalyse eigener Anwendungen auf bereitgestellten Clustern; Helm oder Kustomize ergänzt Konfiguration je Umgebung. Clusteradministration gehört nicht dazu; die Prüfung buchen und bezahlen Sie separat bei der Linux Foundation.

Vertiefung

Optional weiterlernen; nicht in Workshopzahl, Tagen und Preis eingerechnet.

5 Kompetenzen anzeigen

  • Rollenfokus

    Dieser Lernpfad folgt einem Rollenpfad, den optionale Themen vertiefen.

    • ROLLENKOMPETENZOptionalOPTIONAL
      Container-Images automatisiert bauen

      GitLab CI/CD: Bauen, Prüfen und Ausliefern, Pipelines, Runner zur Job-Ausführung, Build-Ergebnisse, Sicherheitsprüfungen, Testumgebungen

      Sie erstellen GitLab-Pipelines, steuern Jobs und bauen und veröffentlichen Container-Images. Dazu ergänzen Sie Scans und Deployment-Schritte und untersuchen Pipelinefehler. Git-Grundlagen werden vorausgesetzt.

      Danach können Sie GitLab-Pipelines zum Bauen, Prüfen und Veröffentlichen von Container-Images erstellen, Testumgebungen einbinden und Job-Fehler eingrenzen.

      Wenn Sie die Build-Pipeline verantworten, bauen und veröffentlichen Sie Container-Images mit GitLab CI/CD und ergänzen Prüfungen, unabhängig von der CKAD-Vorbereitung und auf Wunsch auch davor. Für Pipelines innerhalb des Clusters können Teams eine Tekton-Einführung anfragen; öffentliche Termine sind nicht ausgewiesen.

      4 Lernschritte

      1. Jobs und Runner zuordnen

        Sie gliedern eine GitLab-Pipeline in Jobs und Stages und ordnen Runner zu, damit Ablauf und Ausführungsort nachvollziehbar werden.

      2. Images und Build-Ergebnisse bereitstellen

        Sie bauen Container-Images für die Registry und geben Build-Ergebnisse als Artefakte weiter, damit nachfolgende Jobs sie nutzen können.

      3. Prüfungen und Testumgebungen einbinden

        Mit Scan-Jobs und Deployments in Testumgebungen prüfen Sie Images und Anwendungen innerhalb des Auslieferungsablaufs.

      4. Pipelinefehler eingrenzen

        Syntaxprüfung und Job-Logs helfen Ihnen, Konfigurationsfehler von Runner-, Image-Zugriffs- und Berechtigungsproblemen zu unterscheiden.

      2 weitere Beziehungen
      • Empfohlene Folge: Eine Pipeline oder Flux Image Automation schreibt die Referenz der neuen Image-Version nach Git; Argo CD oder Flux liefert die Anwendung anhand dieses Git-Stands aus.
      • Optionale Vertiefung: Für Bau- und Prüfabläufe direkt im Kubernetes-Cluster können Sie eine Tekton-Einführung anfragen; diese Alternative zur Ausführung ersetzt keine GitLab-CI/CD-Kompetenz.
    • VERTIEFUNGSKOMPETENZOptionalAUF ANFRAGE
      Pipelines mit Tekton

      Tekton, Automatisiertes Bauen und Prüfen, Kubernetes-Ressourcen, Aufgaben, Pipelines

      Tekton führt Abläufe zum automatisierten Bauen und Prüfen als Kubernetes-Ressourcen im Cluster aus und bietet damit eine alternative Ausführung für kontinuierliche Integration (CI). Eine Einführung in Tekton können Sie anfragen; sie ersetzt die GitLab-CI/CD-Kompetenz nicht.

      Wenn Ihr Entwicklungsteam Build- und Testaufgaben als Kubernetes-Ressourcen verwalten möchte, passt die Tekton-Einführung auf Anfrage als optionale Vertiefung nach der Pipeline-Praxis. Sie ergänzt den GitLab-Schritt für kontinuierliche Integration und Auslieferung, ersetzt ihn aber nicht.

      • DW51 Einführung in TektonWorkshop auf AnfrageAnfragen
    • ROLLENKOMPETENZOptionalOPTIONAL
      Auslieferung automatisieren

      Zustandsabgleich, Abweichungen, Umgebungen, Secrets ohne Klartext in Git, Argo CD oder Flux

      Mit Argo CD oder Flux liefern Sie Anwendungen aus Git aus und gleichen die verwalteten Kubernetes-Ressourcen mit ihrem Sollzustand ab. Sie erkennen und korrigieren Abweichungen von der Konfiguration in Git.

      Danach können Sie mit Argo CD oder Flux Anwendungen aus Git ausliefern, Umgebungen unterscheiden, Secrets ohne Klartext in Git einbinden und Abweichungen korrigieren.

      Wenn Sie die Bereitstellung von Anwendungen verantworten, wählen Sie Argo CD oder Flux nach Teampraxis, unabhängig von der CKAD-Prüfung. Hier verbinden Sie Image-Pipeline und Anwendungskonfiguration mit automatisierter Auslieferung aus Git (GitOps); Helm oder Kustomize werden behandelt, Vorkenntnisse darin sind keine Voraussetzung.

      4 Lernschritte

      1. Git als Sollzustand verstehen

        Sie verfolgen, wie Argo CD oder Flux Konfiguration aus Git abruft und verwaltete Ressourcen mit diesem Sollzustand abgleicht.

      2. Konfiguration nach Umgebung trennen

        Gemeinsame Basiskonfiguration und gezielte Anpassungen trennen Unterschiede zwischen Umgebungen, ohne alle Manifeste zu kopieren.

      3. Secrets ohne Klartext bereitstellen

        Sie vergleichen Verschlüsselung im Repository mit externem Secret-Bezug, damit vertrauliche Werte nicht im Klartext in Git stehen.

      4. Abweichungen und Fehler untersuchen

        Anhand von Git-Konfiguration und Controller-Rückmeldungen untersuchen Sie fehlgeschlagene Abgleiche und korrigieren Abweichungen.

      1 von 2 wählen

      Teamwerkzeug nutzen; Argo CD für Canary und Blue-Green mit Argo Rollouts samt Browserübersicht, Flux für automatische Image-Updates in Git.

    • VERTIEFUNGSKOMPETENZOptionalVERTIEFUNG
      Traces und Telemetrie

      OpenTelemetry, Instrumentierung, Kontextweitergabe, Collector, Tempo, Exportstörungen

      Sie instrumentieren HTTP-Webdienste mit OpenTelemetry und verfolgen Kontext über Dienstgrenzen. Im Collector verarbeiten Sie Traces, Metriken und Logs in getrennten Signal-Pipelines; in Grafana untersuchen Sie ihre Zusammenhänge und prüfen Exportfehler. Nötig sind HTTP-Entwicklungspraxis, sicherer Umgang mit Terminal, YAML und Containern, Grundlagen zu Pods, Deployments und Services sowie Grundkenntnisse in Go, Node.js mit JavaScript oder TypeScript, Python oder Java.

      Danach können Sie HTTP-Dienste instrumentieren, dienstübergreifende Anfragen verfolgen und mit verbundenen Signalen Anwendungsfehler von Telemetriestörungen unterscheiden.

      Wenn Sie als Entwickler Fehler Ihrer HTTP-Services im Produktivbetrieb untersuchen, ergänzen Sie Telemetrie (Messdaten); vorausgesetzt sind Erfahrung in der Serviceentwicklung, Grundkenntnisse in Go, Node.js mit JavaScript oder TypeScript, Python oder Java, Kubernetes-Grundlagen und sicherer Umgang mit Terminal, YAML und Containern. Vorbereitung auf die Prüfung OpenTelemetry Certified Associate (OTCA) können Sie zusätzlich anfragen; die Prüfung buchen Sie separat.

      5 Lernschritte

      1. Den Telemetriepfad verstehen

        API, SDK, Collector und Backends ordnen Sie im Datenfluss ein, um Erzeugung, Verarbeitung und Speicherung von Telemetrie zu unterscheiden.

      2. Anfragen mit Kontext instrumentieren

        Automatische Spans ergänzen Sie um fachlichen Kontext und prüfen die Kontextweitergabe, damit Anfragen über Dienstgrenzen nachvollziehbar bleiben.

      3. Signale im Collector verarbeiten

        Getrennte Collector-Pipelines für Traces, Metriken und Logs machen sichtbar, wie Signale empfangen, verarbeitet und exportiert werden.

      4. Telemetrie zur Fehlersuche verbinden

        In Grafana verknüpfen Sie Traces aus Tempo mit Metriken und Logs, um auffälliges Serviceverhalten anhand einzelner Anfragen zu untersuchen.

      5. Exportstörungen eingrenzen

        Anhand von Warteschlangen, Wiederholungsversuchen und Collector-Metriken unterscheiden Sie Exportstörungen von Fehlern der Anwendung.

      • DW11 Einführung in OpenTelemetryAufbau3 TageOnline, Unterrichtssprache: Deutsch
      • DW40 OpenTelemetry Certified Associate (OTCA)Prüfungsvorbereitung auf AnfrageOTCA: Multiple-Choice, 90 Min., Prüfungsanmeldung USD 250 (ein Wiederholungsversuch inklusive), Stand 16. September 2026; separat bei der Linux Foundation buchen und bezahlen, nicht in angezeigten Preisen enthalten.Anfragen
    • VERTIEFUNGSKOMPETENZOptionalVERTIEFUNG
      Operatoren entwickeln

      CRDs, Kubebuilder, Reconciliation, Finalizers, Webhooks, envtest

      Sie entwickeln mit Go und Kubebuilder einen Kubernetes-Operator, der eigene Ressourcen verwaltet: Sie modellieren diese, gleichen Soll- und Istzustand ab und testen mit envtest. Eine Go-Kurzeinführung ist enthalten; nötig sind solide Kubernetes-Kenntnisse, Linux-Kommandozeilenpraxis und Grundverständnis des Baus von Container-Images.

      Danach können Sie mit Go und Kubebuilder einen Operator entwickeln, der eigene Ressourcen validiert, Zustände abgleicht und Aufräumarbeiten steuert, und seine Logik mit envtest prüfen.

      Wenn Ihr Team Kubernetes um eigene Ressourcen und Controller erweitert, entwickeln Sie hier einen Operator. Solide Kubernetes-Praxis, Erfahrung mit der Linux-Kommandozeile und Verständnis von Container-Image-Builds sind erforderlich; Go-Vorkenntnisse sind optional, weil der Workshop mit einem Crashkurs beginnt.

      5 Lernschritte

      1. Eigene Ressourcen modellieren

        Mit Go und Kubebuilder modellieren Sie CRDs und unterscheiden gewünschten Zustand und Status als Grundlage Ihrer Operator-API.

      2. Zustände wiederholt abgleichen

        Sie implementieren Reconciliation so, dass wiederholte Aufrufe Soll- und Istzustand abgleichen, ohne doppelte Ressourcen anzulegen.

      3. Abhängige Ressourcen aufräumen

        Owner References und Finalizers helfen Ihnen, abhängige Objekte zuzuordnen und nötige Aufräumarbeiten vor dem Löschen auszuführen.

      4. Eingaben prüfen und ergänzen

        Mit Admission Webhooks prüfen Sie Eingaben und setzen Standardwerte, damit Ihre Operator-Logik auf gültigen Ressourcen aufbaut.

      5. Reconciliation gegen die API testen

        Mit envtest prüfen Sie Ihre Reconciliation-Logik gegen eine echte Kubernetes-API, um Fehler im Zustandsabgleich zu erkennen.

Welche Workshops umfasst die Beispielroute Cloud-Native Developer?

Die Beispielroute umfasst DW2, DW3, DW5 und wahlweise DW9 oder DW22. Sie deckt folgende Kompetenzen ab: Kubernetes-Einstieg, Workloads und Skalierung, Netzwerk, Zugriff und Betrieb, Manifeste verwalten und Workloads entwickeln & debuggen.

BEISPIELROUTE (ROLLENPFAD: DEVELOPMENT)

Cloud-Native Developer

Für Softwareentwickler: Sie üben, eigene Anwendungen auf einer von anderen betriebenen Kubernetes-Plattform bereitzustellen, zu konfigurieren und Fehler zu beheben, bis zur Vorbereitung auf die separat gebuchte Prüfung Certified Kubernetes Application Developer (CKAD) der Linux Foundation. Automatisierte Build-Pipelines, Telemetrie (Messdaten), Operatorentwicklung und GitOps-Auslieferung sind optionale Ergänzungen außerhalb der Kernroute.

Routenumfang
4
Trainingstage
10–11
Listenpreisbasis, netto p. P.
5.550–6.105 €
Einstiegsworkshop ansehen für Einführung in Kubernetes (DW2)

Eingerechnet: DW2, DW3, DW9 oder DW22 (ein Workshop) und DW5. Zusätzliche Workshops sind nicht eingerechnet.

Workshops dieser Beispielroute

Jeder Workshop zeigt Rolle, abgedeckte Kompetenzen und Planungsdaten.

4 Workshops, fachlich empfohlene Reihenfolge

Vorbereitung

Vorbereitung bei Bedarf

Nicht in Workshopzahl, Tagen und Preis eingerechnet.

Kernroute

  1. STARTPUNKT (KUBERNETES-EINSTIEG)

    DW2 Einführung in Kubernetes

    Wenn Ihnen Kubernetes-Praxis fehlt, stellen Sie im eigenen Cluster des Browserlabs eine Anwendung bereit, machen sie erreichbar und untersuchen und beheben Fehler mit kubectl. Die CKAD-Vorbereitung wiederholt Grundlagen im Prüfungstempo; Teams mit solider Kubernetes-Praxis können später in die Route einsteigen.

    ABGEDECKTE KOMPETENZEN

    Architektur, Pods, Deployments, Deployment-Strategien, Services, Namespaces, CoreDNS, Storage und CSI, ConfigMaps, Secrets, kubectl

    3 Tage, 1.665 € netto

    Termin auswählen

    Inhalte & Termine für Einführung in Kubernetes (DW2)

  2. BETRIEBSPRAXIS

    DW3 Kubernetes Advanced

    Als Anwendungsentwickler untersuchen Sie, wie angeforderte Ressourcen und Obergrenzen, die Platzierung im Cluster (Scheduling) und automatische Skalierung Ihre Anwendung beeinflussen. Datenbank-Operatoren und ereignisgesteuerte Skalierung zeigen ergänzend Aufgaben des Plattformbetriebs.

    ABGEDECKTE KOMPETENZEN

    StatefulSets, Datenbank-Operatoren, Scheduling, Ressourcenmanagement, HPA, VPA, KEDA, Ingress und Gateway API im Überblick, Service Mesh im Überblick, Network Policies, RBAC, Monitoring, Logging

    2 Tage, 1.110 € netto

    Termin auswählen

    Inhalte & Termine für Kubernetes Advanced (DW3)

  3. WAHLSCHRITT

    Manifeste verwalten

    Wählen Sie 1 von 2

    Wenn Sie Anwendungskonfigurationen verwalten, wählen Sie nach Teampraxis Helm oder Kustomize und üben ein Werkzeug vertieft. Die CKAD-Vorbereitung führt beide kurz ein, Helm nur zur Nutzung bestehender Pakete: installieren, aktualisieren und zurückrollen, ohne eigene Charts zu schreiben.

    ABGEDECKTE KOMPETENZEN

    Umgebungskonfiguration, Wiederverwendung, Helm oder Kustomize

  4. ROLLENKOMPETENZ

    DW5 CKAD-Prüfungsvorbereitung

    Mit Kubernetes-Grundlagen vertiefen Sie Muster für zusammenarbeitende Container und üben zusätzliche Themen: Aufgaben und Zeitpläne (Jobs und CronJobs), Anwendungsidentitäten und Sicherheitsregeln (ServiceAccounts und SecurityContexts), Netzwerkregeln und externe Zugriffe (NetworkPolicies und Ingress) sowie die Nutzung eigener Ressourcentypen. Die CKAD-Vorbereitung wiederholt Grundlagen im Prüfungstempo mit direkten kubectl-Befehlen und enthält eine Prüfungssimulation; die Prüfung buchen Sie separat.

    ABGEDECKTE KOMPETENZEN

    Probes, Ressourcen, Debugging, Rollouts

    3 Tage, 1.665 € netto

    Termin auswählen

    Inhalte & Termine für CKAD-Prüfungsvorbereitung (DW5)

Vertiefung

Optionale Vertiefung

Nicht in Workshopzahl, Tagen und Preis eingerechnet.
  • DW14 Einführung in GitLab CI/CD

    Wenn Sie die Build-Pipeline verantworten, bauen und veröffentlichen Sie Container-Images mit GitLab CI/CD und ergänzen Prüfungen, unabhängig von der CKAD-Vorbereitung und auf Wunsch auch davor. Für Pipelines innerhalb des Clusters können Teams eine Tekton-Einführung anfragen; öffentliche Termine sind nicht ausgewiesen.

    2 Tage, 1.110 € netto

    Inhalte & Termine für Einführung in GitLab CI/CD (DW14)
  • Auslieferung automatisieren

    Bei Bedarf: 1 von 2

    Wenn Sie die Bereitstellung von Anwendungen verantworten, wählen Sie Argo CD oder Flux nach Teampraxis, unabhängig von der CKAD-Prüfung. Hier verbinden Sie Image-Pipeline und Anwendungskonfiguration mit automatisierter Auslieferung aus Git (GitOps); Helm oder Kustomize werden behandelt, Vorkenntnisse darin sind keine Voraussetzung.

  • DW11 Einführung in OpenTelemetry

    Wenn Sie als Entwickler Fehler Ihrer HTTP-Services im Produktivbetrieb untersuchen, ergänzen Sie Telemetrie (Messdaten); vorausgesetzt sind Erfahrung in der Serviceentwicklung, Grundkenntnisse in Go, Node.js mit JavaScript oder TypeScript, Python oder Java, Kubernetes-Grundlagen und sicherer Umgang mit Terminal, YAML und Containern. Vorbereitung auf die Prüfung OpenTelemetry Certified Associate (OTCA) können Sie zusätzlich anfragen; die Prüfung buchen Sie separat.

    3 Tage, 1.665 € netto

    Inhalte & Termine für Einführung in OpenTelemetry (DW11)
Weiteren Workshop anzeigen
  • DW15 Kubernetes-Operatoren mit Go entwickeln

    Wenn Ihr Team Kubernetes um eigene Ressourcen und Controller erweitert, entwickeln Sie hier einen Operator. Solide Kubernetes-Praxis, Erfahrung mit der Linux-Kommandozeile und Verständnis von Container-Image-Builds sind erforderlich; Go-Vorkenntnisse sind optional, weil der Workshop mit einem Crashkurs beginnt.

    3 Tage, 1.665 € netto

    Inhalte & Termine für Kubernetes-Operatoren mit Go entwickeln (DW15)

Warum ist diese Route so aufgebaut?

Die Route folgt Lernfragen: Jede Station baut auf der vorherigen auf. Hier erfahren Sie, warum die Übergänge sinnvoll sind.

Fachlich empfohlene Reihenfolge, keine formale Prüfungszulassung.

Das Routenprinzip

Jede Station beantwortet eine andere Lernfrage.

  1. Kubernetes verstehen

    Wie stellen Sie Anwendungen auf Kubernetes bereit?

  2. Anwendungen im Cluster verstehen

    Wie beeinflussen Ressourcen, Skalierung und Zugriffsregeln Ihre eigene Anwendung?

  3. Manifeste verwalten

    Wie passen Sie Anwendungskonfigurationen (Manifeste) an unterschiedliche Umgebungen an?

  4. Anwendungen bereitstellen und debuggen

    Wie stellen Sie Anwendungen unter realistischen CKAD-Prüfungsbedingungen bereit und beheben Fehler?

Die fachliche Logik im Detail

Kurze Begründungen machen die Übergänge nachvollziehbar, ohne die Route erneut abzubilden.

  1. DW2 danach DW3: Kompetenzvoraussetzung

    Warum gehört Kubernetes Advanced in einen Entwicklerpfad zur CKAD-Vorbereitung?

    Kubernetes Advanced vertieft Ressourcen, Skalierung und Zugriffsregeln Ihrer Anwendung und berührt damit die CKAD-Themen Konfiguration, Sicherheit und Netzwerk, obwohl es kein Prüfungskurs ist. Die Inhalte des Kubernetes-Einstiegs werden vorausgesetzt. Wenn Sie diese aus umfassender Praxiserfahrung kennen, ist die Teilnahme am Einstiegskurs keine formale Zugangsvoraussetzung.

  2. DW3 danach DW9 / DW22: Empfohlene Reihenfolge

    Warum Clusterpraxis vor Helm oder Kustomize?

    Clusterpraxis hilft Ihnen, Konfigurationen einzuordnen; diese Reihenfolge ist empfohlen, nicht vorgeschrieben. Wählen Sie Helm für wiederverwendbare Anwendungspakete oder Kustomize für eine gemeinsame Grundkonfiguration mit Anpassungen je Umgebung.

  3. DW9 / DW22 danach DW5: Prüfungsvorbereitung

    Warum Helm oder Kustomize vor der CKAD-Vorbereitung?

    Die CKAD-Vorbereitung führt Helm zur Nutzung bestehender Pakete ohne eigene Charts und Kustomize kurz ein; vertiefte Praxis mit einem Werkzeug erleichtert diese Themen und ist empfohlen. Vorausgesetzt werden Kubernetes-Grundkenntnisse und Entwicklungs- oder Administrationserfahrung; Linux-Kenntnisse sind wichtig, YAML-Dateien sollten Sie idealerweise bearbeiten können. Für das CKAD-Ziel empfehlen wir außerdem Image-Build-Praxis, da die Agenda der CKAD-Vorbereitung dafür keine eigene Übung enthält.

Was ist fest, was flexibel?

Der Status zeigt, welche Kernstationen in den Gesamtwerten berücksichtigt sind und wo Vorwissen oder Lernziel Spielraum lassen. Optionale Ergänzungen zählen erst bei Auswahl dazu.

  • In dieser Route berücksichtigt

    Diese Station gehört mit einem zugeordneten Workshop zur Kernroute.

  • Auswahl gleichwertiger Workshops

    Sie wählen einen der angebotenen Workshops; Umfang, Dauer und Preis können sich unterscheiden.

  • Gleichwertige Alternative

    Wählen Sie Podman statt Docker, wenn Ihr Team bereits mit Podman arbeitet.

  • Optional

    Diese Ergänzung liegt außerhalb von Standardumfang und Preisbasis; buchen Sie sie nur für Teammitglieder, die sie benötigen.

  • Auf Anfrage

    Workshops und Prüfungsvorbereitung auf Anfrage: keine öffentlichen Termine oder Preise, außerhalb aller Summen; Umfang, Sprache, Format und Preis vereinbaren Sie nach einem Vorgespräch. Eine Anfrage ist weder Buchung noch Prüfungsanmeldung; Prüfungen buchen und bezahlen Sie separat bei der Linux Foundation.

Quellen dieser Route

Agenda · Übungsumgebung · Prüfungsstelle · geprüft am

Methodik und Quellen ansehen

Wie wird aus der Roadmap praktische Erfahrung?

Die Roadmap ordnet Kompetenzziel und Reihenfolge; die Workshopagenda zeigt die Inhalte. In Praxisworkshops wenden Sie das Wissen im browserbasierten Dojo an. Die Teilnahmebescheinigung dokumentiert die Workshopteilnahme, ersetzt aber keinen Prüfungsnachweis; Prüfungen für CKAD finden separat bei der Linux Foundation beziehungsweise CNCF statt.

Vom Lernziel zur Anwendung

4 nachvollziehbare Schritte

  1. Kompetenzziel

    Das Lernziel beschreibt eine konkrete Tätigkeit.

  2. Workshopagenda

    Inhalte und Reihenfolge sind nachvollziehbar.

  3. Dojo-Praxis

    In Praxisworkshops wenden Sie das Wissen in Dojo-Übungen an.

  4. Transfer & Einordnung

    Die Teilnahmebescheinigung dokumentiert Teilnahme, keine Zertifizierung.

Was „abgedeckt“ bedeutet und wie wir es belegen

4 Kriterien: direkt belegt

  • Sichtbar

    Inhalte sind nachvollziehbar

    „Abgedeckt“ ist eine redaktionelle Einordnung der sichtbaren Workshopagenda, kein Nachweis geprüfter Kompetenz.

  • Geordnet

    Reihenfolge ist begründet

    Die Agenda ordnet Themen in einer nachvollziehbaren Lernfolge.

  • Angewendet

    Wissen wird praktisch angewendet

    In Praxisworkshops wenden Sie das Wissen in Übungen im browserbasierten Dojo an.

  • Abgegrenzt

    Nachweise bleiben getrennt

    Die Teilnahmebescheinigung und der Prüfungsnachweis bleiben klar voneinander getrennt.

Fachlich geprüft vom Expertenteam der DevNinjas GmbH

Quellen geprüft am

Welcher Kubernetes-Lernpfad passt zu Ihrem Ziel?

Vergleichen Sie die verwandten Pfade nach Kompetenzen und fachlichem Schwerpunkt. Prüfen Sie vor der Buchung die Voraussetzungen des jeweiligen Workshops.

Kubernetes Administrator

Für Administratoren und Betriebsteams mit Linux-Praxis: Sie üben, Kubernetes-Cluster aufzubauen, zu warten und Fehler zu beheben. Der Pfad bereitet auf die Certified Kubernetes Administrator (CKA) Prüfung vor, separat bei der Linux Foundation buchbar. Optionale Vertiefungen richten sich nach Ihrer Teamverantwortung.

  • ROLLENSPEZIFISCHE ALTERNATIVE
  • Kernroute 12 Tage
  • 4 Workshops
  • ROLLENPFAD: OPERATIONS

Passt, wenn Sie dieselbe Basis nutzen, aber einen anderen fachlichen Schwerpunkt setzen möchten.

Kernrouten im Vergleich

In beiden Kernrouten

  • Kubernetes-EinstiegEinstieg
  • Workloads und Skalierung
  • Netzwerk, Zugriff und Betrieb

Nur in dieser Kernroute

  • Software mit Helm verwalten
  • Clusterbetrieb & Troubleshooting
Zum Lernpfad Kubernetes Administrator
Alle Kubernetes-Lernpfade vergleichen

Häufige Fragen zum Kubernetes-Lernpfad

Ein Lernpfad ist eine empfohlene Reihenfolge, keine Buchungspflicht. Welche Workshops sinnvoll sind, hängt von Ihren Container-Grundlagen, Ihrer Zielrolle und vorhandener Praxiserfahrung ab. Die angezeigte Dauer und der Preis beziehen sich auf die Kernroute.

CKAD oder CKA: Was passt zu meiner Entwicklerrolle?

Wenn Sie Kubernetes-Anwendungen entwickeln, passt die Vorbereitung zum Certified Kubernetes Application Developer (CKAD): Sie üben etwa, Konfiguration über ConfigMaps und Secrets einzubinden.

Für zusätzliche Verantwortung beim Clusteraufbau und der Wiederherstellung kommt die Vorbereitung zum Certified Kubernetes Administrator (CKA) infrage. Die Kubernetes-Zertifizierungsübersicht stellt die Prüfungsziele gegenüber.

Muss ich für den Cloud-Native-Developer-Lernpfad bereits Go beherrschen?

Go-Kenntnisse sind keine Voraussetzung für die Hauptroute des Cloud-Native-Developer-Lernpfads. Die CKAD-Vorbereitung verlangt Entwicklungs- oder Systemadministrationserfahrung, aber keine bestimmte Programmiersprache.

Die optionale Operatorentwicklung mit Go beginnt mit einem Go-Crashkurs. Sie setzt solide Kubernetes-Kenntnisse und praktische Programmiererfahrung in Go oder einer anderen Sprache voraus. Für eine ausführlichere Spracheinführung gibt es die Golang-Schulung, ebenfalls für Teilnehmende mit Programmiererfahrung in einer anderen Sprache.

Muss ich vor der CKAD-Vorbereitung Kubernetes-Cluster administriert haben?

Die CKAD-Vorbereitung verlangt keine Erfahrung in der Clusteradministration; Softwareentwicklung ist ebenfalls ein geeigneter beruflicher Hintergrund. Für die CKAD-Vorbereitung brauchen Sie Kubernetes-Kenntnisse sowie Erfahrung mit Linux und der Kommandozeile.

Entwicklungskenntnisse allein decken diese Grundlagen nicht ab. Für zusätzliche Vorbereitung finden Sie Angaben zu Kosten und zeitlicher Verteilung in der Lernpfad-Übersicht.

Welche Programmiersprachen kann ich im OpenTelemetry-Workshop nutzen?

Im OpenTelemetry-Workshop können Sie mit Go, Node.js mit JavaScript oder TypeScript, Python oder Java arbeiten. Sie benötigen Kenntnisse in der gewählten Sprache; die anderen Sprachen müssen Sie nicht beherrschen.

Die OpenTelemetry-Einführung beschreibt auch die nötige Praxis mit Terminal, YAML und Containern.

Vincent Sturm, Key Account Manager

Mit Vincent Ihre Teamroute besprechen

Mit Vincent besprechen Sie Ziele, Rollen, Zeitrahmen, Format und passende Workshopfolgen. Technische Fragen können Sie anschließend bei Bedarf mit unserem Trainerteam vertiefen.
Öffentliche Termine ansehen