Platform Engineering lernen für den Quereinstieg: Kubernetes, CI/CD und KI-Workloads verstehen

Montagmorgen, ein Deployment schlägt fehl: Die Anwendung läuft auf dem Laptop der Entwicklung, aber nicht in der Cloud. Gleichzeitig braucht das Data-Team eine verlässliche Umgebung für ein KI-Modell, und die IT-Sicherheit fragt nach Zugriffsrechten sowie Protokollen. Genau an solchen Schnittstellen arbeitet Platform Engineering. Es sorgt dafür, dass Teams Software, Datenanwendungen und KI-Workloads sicher, nachvollziehbar und wiederholbar bereitstellen können.

Platform Engineering ist kein einzelnes Tool und keine Rolle, die man mit einem Zertifikat sofort beherrscht. Für Quereinsteiger:innen ist das eine gute Nachricht: Entscheidend sind zunächst tragfähige Grundlagen und ein Verständnis für Abläufe. Wer Linux bedienen, Änderungen mit Git verwalten, Anwendungen containerisieren und Deployments automatisieren kann, hat bereits einen sehr brauchbaren Startpunkt.

Infografik zu Platform Engineering lernen für den Quereinstieg: Kubernetes, CI/CD und KI-Workloads verstehen (KI-generiert).

Was Platform Engineering eigentlich macht

Platform Engineers bauen und betreiben eine interne technische Plattform für Entwicklungsteams. Diese Plattform stellt typische Bausteine bereit, damit andere Teams nicht jedes Mal Infrastruktur, Zugriffe, Deployment-Prozesse und Monitoring neu erfinden müssen.

Dazu gehören zum Beispiel:

• standardisierte Entwicklungs- und Testumgebungen
• automatisierte Build-, Test- und Release-Prozesse
• Container-Registries und Kubernetes-Cluster
• Zugriffs- und Berechtigungskonzepte
• Logging, Monitoring und Alarmierung
• Vorlagen für sichere Cloud-Ressourcen
• Plattformen für Datenpipelines oder KI-Anwendungen

Die Rolle liegt damit zwischen Softwareentwicklung, Cloud-Infrastruktur, Security und Betrieb. Sie ist nicht dasselbe wie klassische Systemadministration, DevOps oder Cloud Engineering, überschneidet sich aber mit allen drei Bereichen.

Ein wichtiger Unterschied: Platform Engineering denkt aus Sicht der internen Nutzer:innen. Die zentrale Frage lautet nicht nur: „Läuft der Cluster?“ Sondern auch: „Können Entwicklungsteams sicher und ohne unnötige Wartezeit eine Anwendung ausliefern?“ Gute Plattformen reduzieren Reibung, statt neue Tickets und Sonderwege zu erzeugen.

Die richtige Lernreihenfolge für deinen Einstieg

Viele Einsteiger:innen beginnen direkt mit Kubernetes. Sie installieren Minikube, kopieren ein Deployment-Beispiel und verlieren sich dann in YAML-Dateien, Netzwerkregeln und Fehlermeldungen. Kubernetes ist wichtig, aber als erster Schritt oft zu komplex.

Bei uns empfehlen wir eine Reihenfolge, in der jede Stufe auf einer echten praktischen Fähigkeit aufbaut.

Reihenfolge	Thema	Was du praktisch können solltest
1	Linux und Netzwerkgrundlagen	Shell nutzen, Dateien und Rechte verwalten, Prozesse prüfen, Ports verstehen
2	Git und GitHub oder GitLab	Branches anlegen, Änderungen zusammenführen, Merge-Konflikte nachvollziehen
3	Programmier- und Skriptgrundlagen	Kleine Automatisierungen mit Python oder Bash schreiben
4	Container	Dockerfile erstellen, Images bauen, Container lokal starten
5	CI/CD	Tests und Builds bei Änderungen automatisch ausführen
6	Cloud-Grundlagen	Identitäten, Netzwerke, Speicher und Berechtigungen verstehen
7	Kubernetes	Anwendungen deklarativ ausrollen, skalieren und beobachten
8	Betrieb und Security	Logs auswerten, Metriken nutzen, Secrets und Zugriffe absichern

Diese Reihenfolge bedeutet nicht, dass du jedes Thema vollständig meistern musst, bevor du das nächste ansiehst. Sie verhindert aber, dass du Werkzeuge nur auswendig bedienst. Wenn ein Container nicht startet, helfen dir Linux- und Netzwerkkenntnisse. Wenn eine Pipeline scheitert, brauchst du Git, Testverständnis und Logs. Wenn Kubernetes einen Pod nicht plant, sind Ressourcen, Images, Rechte und Konfiguration relevante Ansatzpunkte.

Linux, Git und Skripting: Das Fundament unter der Plattform

Platform Engineering findet überwiegend auf Linux-Systemen und in automatisierten Prozessen statt. Du musst dafür nicht jede Distribution administrieren können. Aber du solltest dich im Terminal sicher genug bewegen, um Probleme einzugrenzen.

Übe konkret:

• Verzeichnisse anlegen, kopieren und durchsuchen
• Dateirechte und Eigentümer:innen verstehen
• Prozesse, Speicherverbrauch und offene Ports prüfen
• Umgebungsvariablen verwenden
• Ausgaben von Programmen in Dateien schreiben und filtern
• Logs mit Werkzeugen wie grep, tail oder less lesen

Git ist ebenso zentral. Infrastruktur, Konfigurationen, Pipeline-Dateien und Kubernetes-Manifeste liegen heute meist versioniert im Repository. Du solltest daher nachvollziehen können, was ein Commit verändert, warum Reviews wichtig sind und wie ein Merge-Konflikt entsteht.

Skripting ergänzt diese Basis. Python eignet sich gut, um APIs anzusprechen, Konfigurationsdateien zu prüfen oder wiederkehrende Aufgaben zu automatisieren. Bash ist hilfreich, um Befehle und kleine Prozessschritte auf Linux-Systemen zu verbinden. Du musst nicht sofort komplexe Automatisierungen entwickeln. Ein kleines Skript, das Logdateien auswertet oder eine API abfragt, vermittelt bereits wichtige Denkweisen.

Wenn du Programmiergrundlagen systematisch aufbauen willst, hilft dir unser Beitrag „Softwareentwicklung von Grund auf lernen“. Besonders wichtig ist dabei, nicht nur Lösungen zu kopieren, sondern Fehler selbst zu lesen und zu untersuchen.

Container verstehen, bevor Kubernetes dazukommt

Container verpacken eine Anwendung mit ihren Abhängigkeiten in eine einheitliche, portable Einheit. Das reduziert Unterschiede zwischen Entwicklungsrechner, Testumgebung und Cloud. Docker ist dabei ein verbreitetes Werkzeug, aber das zugrunde liegende Konzept zählt mehr als ein einzelner Befehl.

Für ein erstes Projekt reicht eine kleine Webanwendung oder API. Containerisiere sie selbst und beantworte dabei diese Fragen:

• Welche Laufzeitumgebung benötigt die Anwendung?
• Welche Dateien müssen in das Image?
• Welche Konfiguration kommt über Umgebungsvariablen?
• Welchen Port stellt die Anwendung bereit?
• Wo werden Logs ausgegeben?
• Wie bleibt das Image klein und reproduzierbar?

Ein häufiger Fehler ist, Zugangsdaten direkt in ein Dockerfile oder Repository zu schreiben. Trainiere von Anfang an, sensible Werte getrennt von Code zu verwalten. Ebenso wichtig: Ein Container ist nicht automatisch sicher, nur weil er funktioniert. Nutze schlanke Basis-Images, halte Abhängigkeiten aktuell und arbeite möglichst nicht als Root-Nutzer:in im Container.

CI/CD: Automatisierung, die Qualität sichtbar macht

CI/CD steht für Continuous Integration und Continuous Delivery oder Deployment. Vereinfacht gesagt wird bei jeder Änderung automatisch geprüft, gebaut und gegebenenfalls bereitgestellt. Das spart nicht nur Zeit. Es macht Fehler früher sichtbar und schafft nachvollziehbare Abläufe.

Eine erste Pipeline muss nicht kompliziert sein. Für dein Portfolio-Projekt kann sie diese Schritte ausführen:

1. Code aus dem Repository abrufen.
2. Abhängigkeiten installieren.
3. Tests starten.
4. Ein Container-Image bauen.
5. Das Image mit einer eindeutigen Versionskennung ablegen.
6. Die Anwendung in einer Testumgebung aktualisieren.

Wichtig ist, dass du jeden Schritt erklären kannst. Was passiert, wenn ein Test fehlschlägt? Wann darf ein Release erfolgen? Welche Informationen stehen im Build-Log? Wie werden Zugangsdaten für eine Registry geschützt?

KI-Coding-Assistenten können beim Schreiben von Pipeline-Dateien helfen, aber sie ersetzen dieses Verständnis nicht. Unser Artikel „Programmieren lernen mit KI-Coding-Assistenten: So übst du richtig statt nur Code zu kopieren“ zeigt, wie du solche Werkzeuge zum Lernen statt zum blinden Übernehmen nutzt.

Kubernetes: Erst die Konzepte, dann die Komplexität

Kubernetes orchestriert Container. Es sorgt unter anderem dafür, dass Anwendungen in der gewünschten Anzahl laufen, bei Ausfällen neu gestartet werden und über Netzwerke erreichbar sind. In Unternehmen ist Kubernetes oft Teil der Plattform, aber selten die gesamte Plattform.

Für den Einstieg genügen zunächst diese Konzepte:

• Pod: die kleinste auslieferbare Einheit mit einem oder mehreren Containern
• Deployment: beschreibt, welche Version einer Anwendung wie oft laufen soll
• Service: macht eine Anwendung innerhalb oder außerhalb des Clusters erreichbar
• Namespace: trennt Teams, Anwendungen oder Umgebungen logisch
• ConfigMap und Secret: stellen Konfiguration und sensible Werte getrennt vom Container bereit
• Ingress: regelt den externen Zugriff auf Anwendungen
• Ressourcenlimits: begrenzen CPU- und Speicherverbrauch

Starte lokal mit einem kleinen Cluster und rolle deine containerisierte Anwendung aus. Ändere anschließend die Anzahl der Replikate, lies Logs und spiele bewusst einen Fehler ein, etwa einen falschen Port oder ein nicht vorhandenes Image. Erst wenn du diese Abläufe verstehst, lohnen sich weiterführende Themen wie Helm, GitOps, Service Mesh oder eigene Kubernetes-Operatoren.

KI-Workloads: Warum Plattformen hier wichtiger werden

KI-Anwendungen stellen besondere Anforderungen an Infrastruktur. Ein Chatbot, eine Retrieval-Anwendung oder ein Modell-Endpunkt benötigt oft Zugriff auf Datenquellen, Modelle, Secrets, Protokolle und teils spezialisierte Rechenressourcen. Gleichzeitig müssen Unternehmen nachvollziehen können, welche Daten verarbeitet werden und wer auf Systeme zugreifen darf.

Platform Engineering hilft, wiederkehrende Muster als sichere Standards anzubieten: eine vorbereitete Umgebung für Modelltests, kontrollierte Zugriffe auf Datenbanken, zentrale Protokollierung oder Vorlagen für Deployments. Das bedeutet nicht, dass du als Einsteiger:in sofort Modelle trainieren oder GPU-Cluster verwalten musst.

Sinnvoller ist es, zunächst eine kleine KI-Anwendung wie jeden anderen Dienst zu behandeln: Container bauen, Konfiguration trennen, Logs schreiben, Tests einrichten und die Anwendung kontrolliert ausrollen. Welche Grundlagen für agentische Anwendungen zusätzlich wichtig werden, erklären wir in „KI-Agenten entwickeln lernen: Welche Grundlagen du für den Einstieg 2026 brauchst“.

Was du bewusst später lernen solltest

Ein gutes Einstiegsprofil entsteht nicht dadurch, dass du möglichst viele Toolnamen sammelst. Diese Themen sind wertvoll, aber für den Anfang meist nachrangig:

• Multi-Cluster-Architekturen
• komplexe Service-Mesh-Konfigurationen
• eigene Terraform-Module für große Organisationen
• Hochverfügbarkeitsdesign für kritische Systeme
• GPU-Scheduling und verteiltes Modelltraining
• tiefe Kenntnisse in jeder großen Cloud-Plattform
• umfangreiche Zertifizierungspläne ohne eigene Praxis

Wähle stattdessen ein überschaubares Projekt, das den vollständigen Weg zeigt. Entwickle eine kleine Anwendung, versioniere sie mit Git, teste sie über eine Pipeline, verpacke sie als Container und rolle sie in Kubernetes aus. Dokumentiere Architektur, Entscheidungen, Sicherheitsannahmen und typische Fehler. Wie du daraus überzeugende Arbeitsproben machst, liest du in „Ein Portfolio mit echten Projekten aufbauen“.

Deine Checkliste für die ersten zwölf Wochen

• Richte eine Linux-Umgebung ein und arbeite regelmäßig im Terminal.
• Lege ein Git-Repository für ein eigenes kleines Projekt an.
• Schreibe eine einfache Anwendung oder API mit klarer README-Datei.
• Erstelle ein Dockerfile und starte die Anwendung lokal als Container.
• Baue eine Pipeline, die mindestens Tests und einen Image-Build ausführt.
• Lerne die Kernobjekte von Kubernetes an einem lokalen Cluster.
• Dokumentiere einen absichtlich erzeugten Fehler und deine Fehleranalyse.
• Ergänze Logging, Konfiguration über Umgebungsvariablen und eine sinnvolle Secret-Strategie.
• Erkläre dein Projekt einer fachfremden Person in verständlichen Worten.
• Prüfe, welche Rolle dir mehr liegt: Plattform, Cloud, Security oder Softwareentwicklung.

Platform Engineering belohnt Neugier, strukturiertes Troubleshooting und einen Blick für die Bedürfnisse anderer Teams. Du musst nicht alle Systeme selbst betreiben können. Aber du solltest verstehen, wie aus Code ein nachvollziehbar ausgelieferter Dienst wird und wo auf diesem Weg Risiken entstehen. Passende Seminare und Termine findest du bei uns auf cmt.de.