Training Module

Kubernetes: Minikube, kubectl & Kubeconfig

In diesem 130-Minuten-Modul steigt ihr direkt praktisch in die tägliche Arbeit mit Kubernetes ein: Minikube auf macOS, Linux oder Windows installieren und über den kompletten Lifecycle (start/stop, pause/unpause, delete) steuern, dazu das integrierte Registry-Add-on. Danach richtet ihr kubectl ein – inklusive Shell-Alias, Tab-Autocompletion und einem genauen Blick in die Kubeconfig-Datei. Im Kern der Session legt ihr einen eigenen Namespace an, erzeugt ein Deployment-Manifest per –dry-run=client statt es von Hand zu schreiben, wendet es deklarativ mit apply an und lernt get, describe, logs, exec und port-forward zum Prüfen und Debuggen kennen. Zum Abschluss ordnet ihr die Objekthierarchie Manifest → Deployment → ReplicaSet → Pod ein, skaliert per Manifest-Edit und öffnet das Kubernetes Dashboard. 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

130 Minuten, live (remote oder vor Ort), Input & durchgängiges Hands-on ab Modul 3

Teilnehmende

Einsteiger:innen ohne Kubernetes-Vorwissen als Pflicht-Voraussetzung, eigenständig nutzbar auch ohne Kubernetes Einführung

Voraussetzungen

Grundkenntnisse Kommandozeile, lauffähige lokale Docker-Umgebung (Docker Desktop, OrbStack oder Colima)

Warum dieses Training für deine Organisation wirkt

Vom Install zum eigenen Cluster

Minikube auf macOS, Linux oder Windows installieren, mit dem docker-Treiber starten und über den kompletten Lifecycle (pause/unpause, stop/start, delete) steuern – ohne dass unterschiedliche VM-Treiber zu Stolpersteinen werden.

kubectl als tägliches Werkzeug

Nicht nur einzelne Befehle abtippen, sondern Shell-Alias, Autocompletion und die Kubeconfig-Datei einmal wirklich verstehen – die Grundlage, auf der jedes weitere Kubernetes-Modul aufsetzt.

Vom Namespace bis zum Debugging

Ein durchgängiges Hands-on: eigener Namespace, Manifest-Erzeugung per –dry-run=client, apply, Zustandsprüfung mit get/describe, Debugging mit logs/ exec/port-forward und Skalierung – bis zum Dashboard.

Was Teilnehmende mitnehmen

  • Minikube auf macOS, Linux oder Windows installieren und den kompletten Lifecycle beherrschen: stop/start für vollständiges Herunterfahren mit freigegebenem Arbeitsspeicher, pause/unpause zum kurzfristigen Einfrieren im RAM, delete für den kompletten Rückbau.
  • Die integrierte Minikube-Registry aktivieren und über eval $(minikube docker-env) direkt gegen den clusterinternen Docker-Daemon bauen, ohne doppelten Speicherverbrauch auf der eigenen Festplatte.
  • kubectl installieren, einen Shell-Alias samt Tab-Autocompletion einrichten und die Kubeconfig-Datei (~/.kube/config) in ihren drei Bausteinen clusters/users/contexts lesen und verstehen.
  • Einen eigenen Namespace anlegen, ein Deployment-Manifest per kubectl create … –dry-run=client -o yaml erzeugen statt es von Hand zu schreiben, und es deklarativ per kubectl apply anwenden.
  • Laufende Ressourcen mit kubectl get und kubectl describe abfragen sowie mit kubectl logs, kubectl exec -it und kubectl port-forward in einen laufenden Container hineindebuggen.
  • Die Kubernetes-Objekthierarchie von Manifest über Deployment und ReplicaSet bis zum einzelnen Pod nachvollziehen, per Manifest-Edit und erneutem apply hochskalieren, und den eigenen Namespace fest als Arbeitskontext setzen.
  • Das Kubernetes Dashboard über minikube dashboard öffnen und als grafische Ergänzung zu den einzelnen kubectl-Befehlen einordnen.

Für wen dieses Modul ideal ist

  • • Einsteiger:innen, die Minikube und kubectl nicht nur kennen, sondern selbst bedienen wollen
  • • Teams, die nach der konzeptionellen Kubernetes Einführung jetzt den Kommandozeilen-Alltag üben wollen – das Modul setzt sie aber nicht zwingend voraus
  • • Alle, die vor einem Deployment- oder Migrations-Hands-on erst sicher mit Namespace, apply und kubectl-Debugging umgehen wollen

Rahmendaten

  • • Dauer: 130 Minuten (ca. 2 Stunden 10 Minuten) live (remote oder vor Ort)
  • • Format: Input, Live-Demo, durchgängiges Hands-on ab Modul 3
  • • Voraussetzungen: Grundkenntnisse Kommandozeile, lauffähige lokale Docker-Umgebung, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Minikube installieren & Lifecycle (25 min): Installation auf macOS/Linux/Windows, minikube start –driver=docker, die drei Steuerungsebenen pause/unpause vs. stop/start vs. delete, sowie das integrierte Registry-Add-on.

  2. kubectl installieren, Alias/Autocompletion, Kubeconfig (20 min): Installation je Betriebssystem, dauerhafter Shell-Alias k mit Tab-Autocompletion, sowie die Kubeconfig-Datei mit clusters/users/contexts lesen und den Cluster-Zugriff prüfen.

  3. Hands-on: Namespaces, imperativ vs. deklarativ, apply (25 min): die vier Standard-Namespaces einordnen, create/replace gegen apply abgrenzen, ein Deployment-Manifest per –dry-run=client -o yaml erzeugen, um einen eigenen Namespace ergänzen und anwenden.

  4. Ressourcen abfragen & Debugging (25 min): kubectl get/describe zur Zustandsprüfung, kubectl logs für Log-Ausgaben, kubectl exec -it für eine interaktive Shell im Container, kubectl port-forward mit lokalem Browser-Test.

  5. Objekthierarchie, Skalierung, Kontext & Dashboard (25 min): die Kaskade Manifest → Deployment → ReplicaSet → Pod, Replicas per Manifest-Edit und erneutem apply hochskalieren, den Namespace fest als Arbeitskontext setzen (kubectl config set-context –current –namespace=…), und das Kubernetes Dashboard öffnen.

Zzgl. 10 Minuten Puffer/Q&A – macht in Summe 130 Minuten.

Dieses Modul ergänzt inhaltlich das Einstiegsmodul Kubernetes Einführung — der erste Blick unter die Haube (Container-Evolution, Control-Plane-/Worker-Architektur, Raft/Quorum, API-Call-Flow) – ist aber kein hartes Prerequisite und funktioniert eigenständig. Wer die Architektur-Grundbegriffe dahinter noch nicht kennt, findet sie dort vertieft; wer direkt selbst mit Minikube und kubectl arbeiten will, kann hier ohne Umweg einsteigen.

Installationsüberschneidung mit dem Aufbaumodul Docker & Kubernetes: Vom Compose-Stack zum lokalen Cluster (dort ebenfalls Minikube/kubectl im Ordner mein-k8s-projekt, Voraussetzung “Docker Fortgeschritten”) – dieses Modul hier vertieft dafür kubectl selbst deutlich weiter (Namespace-Handling, Debugging mit logs/exec/port-forward, Objekthierarchie), statt direkt in eine kompose-Migration einzusteigen. Die beiden Module sind unabhängig voneinander buchbar.

Hands-on Inhalte (Auszug)

Minikube: Installation & Lifecycle

  • macOS (Homebrew), Linux (deb/rpm/Binary) und Windows (winget/Chocolatey) im Vergleich installieren
  • minikube start –driver=docker, dazu pause/unpause vs. stop/start vs. delete mit ihren jeweiligen Ressourcen-Effekten
  • Die integrierte Registry aktivieren und per eval $(minikube docker-env) direkt im Cluster bauen

kubectl & Kubeconfig

  • Installation, Shell-Alias k und Tab-Autocompletion für zsh/bash dauerhaft einrichten
  • Die Kubeconfig-Datei (~/.kube/config) in clusters/users/contexts lesen und den aktiven current-context verstehen
  • kubectl get namespaces als erster Verbindungstest gegen den Cluster

Namespace, Deployment & Debugging

  • Einen eigenen Namespace anlegen, ein Deployment-Manifest per –dry-run=client -o yaml erzeugen und per apply anwenden
  • kubectl get/describe zur Zustandsprüfung, kubectl logs/exec -it/port-forward zum Debuggen und lokalen Testen des laufenden Pods

Objekthierarchie, Skalierung & Dashboard

  • Die Kaskade Manifest → Deployment → ReplicaSet → Pod nachvollziehen
  • Replicas per Manifest-Edit und erneutem apply hochskalieren, den Namespace fest als Arbeitskontext setzen
  • Das Kubernetes Dashboard über minikube dashboard öffnen

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum ersten angewendeten eigenen Manifest) 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