Mitglied werden – KI-Tutor mit vollen Antworten

Training Module

Linux-Grundlagen für DevOps

In diesem 120-Minuten-Modul holt ihr das Linux-Fundament praktisch nach, auf dem Docker und Kubernetes aufsetzen, statt es nur konzeptionell zu kennen. Nach einer kurzen Einordnung arbeitet ihr drei Hands-on-Blöcke auf einem selbst gebauten lokalen Docker-Container: Shell-Navigation, Dateisystemhierarchie und Berechtigungen/Ownership mit einer chmod/chown-Übung, danach Prozesse und Jobs sowie systemd/journald mit einer Übung, einen hängenden Prozess zu finden und zu beenden und einen Fehler aus Logs zu isolieren, und schließlich Netzwerk-Basics (Interfaces, DNS, Ports) mit ss und curl als Diagnosewerkzeuge für einen kaputten Service. Zum Abschluss führt ihr alle drei Fertigkeiten in einem vorbereiteten Mini-Szenario zusammen: ein Service ist aus mehreren Gründen gleichzeitig kaputt, ihr diagnostiziert und behebt ihn Schritt für Schritt. Komplett lokal, kein Cloud-Account, keine Kostenwirkung.

Academy Briefing vereinbaren

Oder sofort per Mail an mail@mhm-dl.de

Format

120 Minuten, live (remote oder vor Ort), Input & drei Hands-on-Blöcke plus zusammenführendes Fehlerdiagnose-Szenario

Teilnehmende

Einsteiger:innen und Quereinsteiger:innen in DevOps-Rollen, die vor “Docker Grundlagen” oder “Kubernetes Einführung” das Linux-Fundament praktisch statt nur begrifflich nachholen wollen

Voraussetzungen

Kein eigener Cloud-Account nötig: die Übungsumgebung ist ein selbst gebauter lokaler Docker-Container. Docker lokal installiert, keine Linux-Vorkenntnisse nötig, reines Einstiegsmodul.

Warum dieses Training für deine Organisation wirkt

Fundament statt nur Begriff

Teilnehmende tippen die Befehle selbst, statt Linux-Grundlagen nur als Folie vor Docker/Kubernetes gehört zu haben: chmod, chown, ps, kill, ss und curl laufen im eigenen Terminal gegen einen selbst gebauten Container.

Fehlerdiagnose statt Befehlsliste

Jeder Hands-on-Block endet mit einer echten Diagnoseaufgabe, einen hängenden Prozess finden, einen Fehler aus Logs isolieren, einen kaputten Service über Port/DNS eingrenzen, statt Befehle nur isoliert auswendig zu lernen.

Direkter Anschluss an Docker/Kubernetes

Jedes Container-Image und jeder Kubernetes-Node ist Linux: Wer Berechtigungen, Prozesse und Netzwerk-Diagnose schon im Container-losen Kontext beherrscht, versteht in den Folgemodulen schneller, was unter der Container-Abstraktion tatsächlich passiert.

Was Teilnehmende mitnehmen

  • Sich in der Shell sicher bewegen und die Linux-Dateisystemhierarchie (/etc, /var, /home, /usr, /tmp) einordnen, statt nur Pfade zu kopieren.
  • Berechtigungen (rwx, oktale Notation) und Ownership (User/Gruppe) lesen, mit chmod und chown/chgrp gezielt korrigieren und erklären, warum eine Berechtigung ein Skript lauffähig macht oder nicht.
  • Prozesse und Jobs unterscheiden (ps, pgrep, jobs, bg/fg, nohup), einen hängenden oder fehlerhaften Prozess gezielt per Signal (kill -TERM/-9) statt pauschal per Neustart beenden.
  • systemd und journald als das Standard-Init-/Logging-System heutiger Linux-Distributionen einordnen (systemctl status/start/stop/restart, journalctl -u, journalctl -xe) und erklären, warum ein Container-Image bewusst kein eigenes Init-System fährt.
  • Einen Fehler aus einem Log gezielt isolieren (grep, tail -f, Zeitfenster eingrenzen), statt das komplette Log von oben nach unten zu lesen.
  • Netzwerk-Basics anwenden: Interfaces (ip addr), lokale Namensauflösung (/etc/hosts, getent hosts) und offene Ports (ss -tlnp) lesen, mit curl gezielt gegen einen Service testen.
  • In einem zusammenführenden Mini-Szenario eine mehrfach kaputte Service-Konfiguration (Berechtigung, Prozess, Netzwerk) selbstständig diagnostizieren und beheben, Abgleich mit dem dokumentierten Lösungsweg.

Für wen dieses Modul ideal ist

  • • Einsteiger:innen und Quereinsteiger:innen in DevOps-Rollen ohne bisherige Linux-Praxis
  • • Alle, die direkt mit “Docker Grundlagen” oder “Kubernetes Einführung” starten wollten, aber merken, dass Shell/Berechtigungen/Prozesse/Netzwerk darin vorausgesetzt werden
  • • Teams, die den konzeptionellen Linux-Abschnitt aus “DevOps ganzheitlich: KI-Governance & Skill-Kompass” jetzt mit echter Hands-on-Tiefe nachholen wollen

Rahmendaten

  • • Dauer: 120 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, drei Hands-on-Blöcke und ein zusammenführendes Fehlerdiagnose-Szenario auf einem selbst gebauten Docker-Container
  • • Voraussetzungen: Kein eigener Cloud-Account nötig, Docker lokal installiert, keine Linux-Vorkenntnisse nötig

Modulaufbau & Agenda

  1. Kick-off & Abgrenzung (10 min): Format und Ablauf, Abgrenzung zum konzeptionellen Linux-Abschnitt in DevOps ganzheitlich: KI-Governance & Skill-Kompass (dort nur Landkarte ohne Hands-on-Tiefe, hier die praktische Vertiefung) und zu Docker Grundlagen (dort wird dieses Fundament bereits vorausgesetzt, hier wird es zuerst gelegt).

  2. Hands-on: Shell, Dateisystem & Berechtigungen (25 min): Shell-Navigation (cd, ls, find), die Linux-Dateisystemhierarchie im Überblick, Berechtigungen (rwx, oktale Notation) und Ownership lesen, danach eine vorbereitete Verzeichnisstruktur mit falschen Rechten und falscher Gruppenzugehörigkeit per chmod und chown/chgrp korrigieren, Abgleich mit der Musterlösung.

  3. Hands-on: Prozesse, systemd & Logs (25 min): Prozesse und Jobs unterscheiden (ps, pgrep, jobs, bg/fg), systemd/journald als Standard-Init-/Logging-System einordnen (systemctl, journalctl), danach einen hängenden Hintergrundprozess im Trainings-Container finden und gezielt per Signal beenden und einen Fehler aus einem vorbereiteten Logfile isolieren, Abgleich mit der Musterlösung.

  4. Hands-on: Netzwerk-Basics & Diagnose (25 min): Interfaces ( ip addr), lokale Namensauflösung (/etc/hosts, getent hosts) und offene Ports (ss -tlnp) im Überblick, danach einen absichtlich kaputten Service im Trainings-Container über eine Kombination aus falschem Port und falschem Hosts-Eintrag mit ss und curl diagnostizieren und wieder erreichbar machen, Abgleich mit der Musterlösung.

  5. Hands-on: Zusammenführende Fehlerdiagnose (25 min): ein vorbereitetes Mini-Szenario, in dem ein Service aus mehreren der drei vorherigen Ursachen gleichzeitig nicht erreichbar ist (Berechtigung, Prozess, Netzwerk), eigenständig durchdiagnostizieren und beheben, Abgleich mit dem dokumentierten Lösungsweg.

  6. Abschluss & Verweis auf Vertiefung (10 min): Zusammenfassung der vier Fertigkeiten, Verweis auf Docker Grundlagen und Kubernetes Einführung als nächste Schritte, in denen dieses Fundament jetzt vorausgesetzt wird.

Abgrenzung: Dieses Modul behandelt bewusst kein Container-/Orchestrierungswissen (dafür Docker Grundlagen und Kubernetes Einführung), keine vollständige Shell-Scripting-Vertiefung (Bash-Funktionen, Arrays, Trap-Handling) und keine Distributions-Paketverwaltung oder Benutzerverwaltung im Detail (apt/yum, useradd-Optionen). Auch die KI-Governance- und Skill-Kompass-Landkarte aus DevOps ganzheitlich: KI-Governance & Skill-Kompass wird hier nicht wiederholt, nur die dort nur konzeptionell erwähnte Linux-Ebene bekommt hier ihre eigenständige Hands-on-Tiefe.

Hands-on Inhalte (Auszug)

Shell, Dateisystem & Berechtigungen

  • Shell-Navigation und Dateisystemhierarchie im Überblick
  • rwx/oktale Notation lesen, mit chmod korrigieren
  • Falsche Gruppenzugehörigkeit per chown/chgrp beheben

Prozesse, systemd & Logs

  • Prozesse/Jobs mit ps, pgrep, jobs finden
  • Hängenden Prozess gezielt per Signal beenden (kill -TERM/-9)
  • systemd/journald einordnen, Fehler aus einem Logfile isolieren

Netzwerk-Diagnose

  • Interfaces und lokale Namensauflösung lesen (ip addr, /etc/hosts)
  • Offene Ports mit ss -tlnp prüfen
  • Kaputten Service mit curl gezielt eingrenzen und wieder erreichbar machen

Zusammenführendes Szenario

  • Mehrfach kaputter Service: Berechtigung, Prozess und Netzwerk gleichzeitig betroffen
  • Eigenständige Diagnose mit den Werkzeugen aus den drei vorherigen Blöcken
  • Abgleich mit dem dokumentierten Lösungsweg

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zur korrekt gelösten Mini-Szenario-Diagnose, Trefferquote bei der chmod/chown-Übung) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen das Fehlerdiagnose-Szenario auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen