Training Module

Kubernetes Einführung — der erste Blick unter die Haube

In diesem 90-Minuten-Modul steigt ihr ganz ohne Kubernetes-Vorwissen ein – ausdrücklich ohne die Voraussetzung “Docker Fortgeschritten”. Ihr verfolgt die Container-Evolution von Bare Metal über die virtuelle Maschine bis zum Container, versteht Namespaces und Cgroups als technisches Fundament und ordnet den Schritt vom Monolithen zu Microservices sowie das Bild von Pets vs. Cattle ein. Danach geht es um die Herkunft von Kubernetes aus Googles internem System Borg und die Rolle der CNCF, gefolgt von der Control-Plane-/Worker-Architektur mit Raft/Quorum als Konsensmechanismus und dem API-Call-Flow durch den Cluster. Zum Abschluss startet ihr euer eigenes erstes Kubernetes-Cluster und lest die ersten kubectl- Befehle. Die komplette Session läuft vollständig lokal, ohne Cloud-Account und ohne Kostenwirkung.

Academy Briefing vereinbaren

Oder sofort per Mail an kontakt@codecraft.academy

Format

90 Minuten, live (remote oder vor Ort), Input & Hands-on

Teilnehmende

Einsteiger ohne Kubernetes-Vorwissen, ohne Docker-Fortgeschritten-Voraussetzung

Voraussetzungen

Grundkenntnisse Kommandozeile, lauffähige lokale Docker-Umgebung

Warum dieses Training für deine Organisation wirkt

Vom Einzel-Host zum Cluster

Die Entwicklung von Bare Metal über die virtuelle Maschine zum Container – und warum diese Entwicklung mit Kubernetes noch nicht endet, sobald mehrere Hosts und viele Container koordiniert werden müssen.

Architektur verstehen

Control Plane und Worker Nodes als Grundgerüst, Raft/Quorum als Konsensmechanismus dahinter, und der API-Call-Flow, der beides verbindet – als solides Fundament für jedes vertiefende Kubernetes-Thema.

Erste eigene Berührung

Kein reiner Frontalvortrag: Am Ende der Session steht ein eigenes, selbst gestartetes Cluster, und die ersten kubectl-Ausgaben lassen sich bereits einordnen statt nur abzutippen.

Was Teilnehmende mitnehmen

  • Die Container-Evolution nachvollziehen: Bare Metal → virtuelle Maschine → Container, und was sich an Isolation und Ressourcennutzung dabei jeweils ändert.
  • Namespaces und Cgroups als die zwei Linux-Kernel-Mechanismen einordnen, auf denen Container-Isolation technisch aufbaut.
  • Den Schritt vom Monolithen zu Microservices sowie das Bild von Pets vs. Cattle verstehen – warum Orchestrierung erst ab einer bestimmten Systemgröße zum eigenen Thema wird.
  • Die Herkunft von Kubernetes aus Googles internem System Borg sowie die Rolle der Cloud Native Computing Foundation (CNCF) einordnen.
  • Die Control-Plane-/Worker-Architektur benennen und Raft/Quorum als Konsensmechanismus hinter der Control Plane verstehen.
  • Den API-Call-Flow nachvollziehen: wie eine Anfrage von kubectl durch den Cluster bis zum Worker Node läuft.
  • Ein eigenes erstes Kubernetes-Cluster starten und die ersten kubectl-Befehle lesen und interpretieren.

Für wen dieses Modul ideal ist

  • • Einsteiger:innen ohne jedes Kubernetes-Vorwissen, ausdrücklich ohne die Voraussetzung “Docker Fortgeschritten”
  • • Alle, die vor einem vertiefenden Hands-on-Modul erst die Grundbegriffe und die Architektur einordnen wollen
  • • Teams, die Kubernetes-Fachbegriffe (Control Plane, Pod, Cluster, Raft/Quorum) das erste Mal überhaupt hören

Rahmendaten

  • • Dauer: 90 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, kurzes Hands-on zum eigenen ersten Cluster
  • • Voraussetzungen: Grundkenntnisse Kommandozeile, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Container-Evolution (20 min): von Bare Metal über die virtuelle Maschine zum Container, und Namespaces/Cgroups als technisches Fundament dahinter.

  2. Monolith → Microservices, Pets vs. Cattle (15 min): warum wachsende Systeme in kleinere Dienste zerfallen und warum einzelne Server zunehmend austauschbar statt gehegt werden.

  3. Herkunft: Borg & CNCF (10 min): Kubernetes als Weiterentwicklung von Googles internem System Borg, und die Rolle der Cloud Native Computing Foundation als neutraler Träger.

  4. Architektur: Control Plane, Worker, Raft/Quorum, API-Call-Flow (25 min): die Grundarchitektur, der Konsensmechanismus Raft/Quorum hinter der Control Plane, und wie eine Anfrage von kubectl durch den Cluster läuft.

  5. Hands-on: erstes eigenes Cluster starten (20 min): mit minikube start ein lokales Cluster hochfahren und die erste kubectl-Ausgabe gemeinsam lesen.

Dieses Modul ist die Erstberührung mit Kubernetes-Konzepten und einem eigenen Cluster. Vertiefendes Hands-on – Migration eines Compose-Stacks, Ingress-Routing, Monitoring – folgt im Aufbaumodul Docker & Kubernetes: Vom Compose-Stack zum lokalen Cluster. Control-Plane- und Pod-Grundlagen werden dort nicht erneut erklärt, sondern vorausgesetzt.

Wer stattdessen zuerst den Kommandozeilen-Alltag selbst üben will – Minikube installieren und über den kompletten Lifecycle steuern, kubectl mit Alias und Kubeconfig einrichten, einen eigenen Namespace samt Deployment anlegen und debuggen – findet das im gleichrangigen, unabhängig buchbaren Modul Kubernetes: Minikube, kubectl & Kubeconfig. Kein hartes Prerequisite in beide Richtungen – dieses Modul hier erklärt die Architektur dahinter, das andere übt das Werkzeug.

Wer stattdessen die Kubernetes-Objekte des Alltags selbst schreiben will – Health-Checks, ReplicaSet/Deployment-Mechanik, Service-Typen, ConfigMap und Secret – findet das im Aufbaumodul Kubernetes Workloads & Konfiguration — die Objekte für den Alltag. Auch dieses Modul setzt das eigene erste Cluster aus diesem Kurs voraus und erklärt Control-Plane-/Worker-Architektur nicht erneut. Darauf aufbauend gibt es drei gleichrangige, voneinander unabhängige Vertiefungsmodule: Kubernetes Networking Vertiefung (Service Discovery, DNS, Ingress-Pfadregeln), Kubernetes Administration (RBAC, Node-Betrieb, Cluster-Netzwerk) und Kubernetes Anwendungsdesign (Multi-Container-Patterns, Jobs & Security Context) – alle drei setzen nur das Workloads-Modul voraus, nicht sich gegenseitig.

Hands-on Inhalte (Auszug)

Container-Evolution & Fundament

  • Bare Metal, virtuelle Maschine und Container als drei Isolationsstufen im Vergleich
  • Namespaces (Sichtbarkeit) und Cgroups (Ressourcenbegrenzung) als die zwei Linux-Mechanismen hinter jedem Container
  • Monolith vs. Microservices und Pets vs. Cattle als Denkmodelle für wachsende Systeme

Architektur & Herkunft

  • Kubernetes’ Herkunft aus Googles internem System Borg und die Rolle der CNCF
  • Control Plane und Worker Nodes als Grundarchitektur, Raft/Quorum als Konsensmechanismus
  • Der API-Call-Flow: wie eine kubectl-Anfrage durch den Cluster läuft

Erstes eigenes Cluster

  • Ein lokales Single-Node-Cluster mit minikube start –driver=docker hochfahren
  • Mit kubectl get nodes und kubectl get pods -A den laufenden Cluster und seine Control-Plane-Komponenten als Pods erkennen
  • Mit kubectl cluster-info den API-Server-Endpunkt bestätigen, der zuvor im API-Call-Flow eingeordnet wurde

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum lauffähigen eigenen Cluster) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen das Tempo auf euren Erfahrungsstand an.

Academy Briefing anfragen