Training Module

Docker Betrieb: Monitoring, Ressourcen & Registry

In diesem 2¼-Stunden-Modul geht es um den Dauerbetrieb: Restart-Policies und die typische Einrückungsfalle in compose.yaml, Ressourcenlimits über cgroups und schlanke Basis-Images, den Umgang mit Docker-Hub-Rate-Limits und Ausweichregistries, sowie – als inhaltlichen Kern – einen eigenen Monitoring-Stack aus Prometheus, Node Exporter, cAdvisor und Grafana. Zum Abschluss: Traefik als Reverse Proxy mit automatischem TLS, Alertmanager für Schwellwert-Alarme und Blackbox Exporter für die externe Erreichbarkeitsprüfung. Die Hands-on-Übung – den Restart-Bug per Skript statt durch Hochstarten finden – läuft komplett lokal und rein skriptbasiert, ganz ohne Cloud-Account und ohne Kostenwirkung.

Academy Briefing vereinbaren

Oder sofort per Mail an kontakt@codecraft.academy

Format

Ca. 2 Stunden 15 Minuten, live (remote oder vor Ort), Input & Hands-on

Teilnehmende

Absolvent:innen von “Docker Fortgeschritten” oder gleichwertige Vorkenntnisse in Docker Compose

Voraussetzungen

Sicherer Umgang mit compose.yaml (Services, Netzwerke, Volumes) sowie eine lauffähige Docker-Umgebung mit Docker Compose. Keine Cloud-/AWS-Kostenwirkung – die Hands-on-Übung läuft rein skriptbasiert.

Warum dieses Training für deine Organisation wirkt

Vom “läuft bei mir” zum Dauerbetrieb

Ein Container, der einmal manuell gestartet wurde, übersteht keinen Absturz und keinen Host-Reboot von selbst. Restart-Policies, Ressourcenlimits und eine unabhängige Registry-Strategie sind die Basis, bevor überhaupt von “Betrieb” die Rede sein kann.

Beobachtbarkeit statt Dashboard-Starren

Der Kern des Trainings: ein eigener Monitoring-Stack aus Prometheus, Node Exporter, cAdvisor und Grafana – Datenfluss, Compose-Setup und Dashboard-Grundlagen im Zusammenhang, ergänzt um Alertmanager und Blackbox Exporter für aktive Alarmierung statt reaktivem Nachschauen.

Praxis ohne Risiko

Die Hands-on-Übung – einen eingebauten Restart-Policy-Bug per Skript statt durch Hochstarten aufspüren – läuft komplett lokal und rein skriptbasiert. Kein eigener Cloud-Account, keine Kostenwirkung.

Was Teilnehmende mitnehmen

  • Restart-Policies (no, on-failure, always, unless-stopped) korrekt setzen – und die Einrückungsfalle erkennen, bei der restart: versehentlich unter environment: landet, ohne dass Compose das meldet.
  • Eine systemd-Unit als Alternative zur eingebauten Docker-Restart-Logik einordnen, samt Abgrenzung, wann welcher Ansatz sinnvoll ist.
  • Ressourcen über cgroups begrenzen (–memory/–cpus bzw. deploy.resources.limits in Compose) und Images über die richtige Basis-Image-Wahl (Alpine vs. Debian/UBI) sowie apk-Best-Practices schlank halten.
  • Mit Docker-Hub-Rate-Limits umgehen: Auth-Strategien, Ausweichregistries wie GHCR, ECR oder Quay, und insecure-registries in daemon.json für interne Registries einordnen.
  • Einen eigenen Monitoring-Stack aus Prometheus, Node Exporter, cAdvisor und Grafana im Compose-Setup aufbauen, den Datenfluss verstehen und ein erstes Dashboard einrichten.
  • Erreichbarkeit und Alarmierung ergänzen: Traefik als Reverse Proxy mit automatischem TLS, Alertmanager für Schwellwert-Alarme, Blackbox Exporter für die externe Erreichbarkeitsprüfung.
  • In einer Hands-on-Übung einen eingebauten Restart-Policy-Bug rein per Skript identifizieren, gegen eine Musterlösung abgleichen.

Für wen dieses Modul ideal ist

  • • Absolvent:innen von “Docker Fortgeschritten” oder Teams mit gleichwertigen Vorkenntnissen in Docker Compose
  • • Teams, die von manuell betriebenen Containern zu einem belastbaren, beobachtbaren Dauerbetrieb wechseln wollen
  • • Alle, die bisher weder Ressourcenlimits noch Monitoring strukturiert angefasst haben und jetzt den ersten eigenen Stack aufbauen möchten

Rahmendaten

  • • Dauer: ca. 2 Stunden 15 Minuten live (remote oder vor Ort)
  • • Format: Input, Live-Demo, skriptbasierte Hands-on-Übung mit Musterlösungs-Abgleich
  • • Voraussetzungen: abgeschlossenes Modul “Docker Fortgeschritten” oder gleichwertige Compose-Vorkenntnisse, lauffähige Docker-Umgebung mit Docker Compose, keine Cloud-Kostenwirkung

Modulaufbau & Agenda

  1. Docker im Dauerbetrieb: Restart-Policies & systemd (25 min): die vier Restart-Policies, die Einrückungsfalle unter environment:, eine systemd-Unit als Alternative – inklusive der skriptbasierten Hands-on-Übung.

  2. Ressourcen begrenzen & Images schlank halten (20 min): cgroups über –memory/–cpus bzw. deploy.resources.limits, Basis-Image-Wahl Alpine vs. Debian/UBI, apk-Best-Practices.

  3. Registry-Betrieb: Rate-Limits, Mirrors, Alternativen (15 min): Docker-Hub-Rate-Limits, Auth-Strategien, GHCR/ECR/Quay als Ausweichregistries, insecure-registries in daemon.json.

  4. Monitoring-Stack aufbauen: Prometheus, Node Exporter, Grafana (45 min, Kern): Datenfluss von Exporter über Prometheus zu Grafana, Compose-Setup mit vier Diensten, Dashboard-Grundlagen.

  5. Erreichbarkeit & Alarmierung: Traefik, Alertmanager, Blackbox Exporter (25 min): Reverse Proxy mit automatischem TLS, Schwellwert-Alarme, externe Erreichbarkeitsprüfung.

Container-spezifischer Dauerbetrieb ist nur ein Ausschnitt: Für Cloud-Architektur-Entscheidungen, On-Call-Organisation und Fehlerkultur auf Team-/Organisationsebene siehe DevOps Betrieb: Cloud-Architektur, On-Call & Fehlerkultur. Für die konzeptionelle Einordnung des eigenen Prometheus/Grafana-Stacks – Observability-Säulen, Tool-Kategorien wie Log-Server/Service Mesh/Error Tracking/Incident-Alerting, und das SRE-Framework SLA/SLO/SLI mit Error Budget – siehe DevOps Monitoring: Von Status-Checks zu Observability & SRE.

Hands-on Inhalte (Auszug)

Restart-Policies & systemd

  • Die vier Restart-Policies (no, on-failure, always, unless-stopped) und ihre Unterschiede im Detail
  • Den Restart-Bug per Python-Skript aufspüren statt durch Hochstarten – funktioniert komplett ohne laufenden Docker-Daemon
  • Eine systemd-Unit als Alternative zur Docker-eigenen Restart-Logik

Ressourcen & Images

  • deploy.resources.limits für CPU- und Speicherlimits direkt in Compose
  • Alpine vs. Debian/UBI als Basis-Image-Entscheidung
  • apk add –no-cache und –virtual .build-deps als Muster für schlanke Images

Monitoring-Stack

  • Prometheus, Node Exporter, cAdvisor und Grafana als Vier-Dienste-Compose-Setup
  • Scrape-Konfiguration und Service Discovery zwischen den vier Diensten
  • Ein erstes Dashboard aus einer PromQL-Query aufbauen

Erreichbarkeit & Alarmierung

  • Traefik-Labels für Routing und automatisches TLS statt offener Host-Ports
  • Alertmanager-Regeln für Schwellwert-Alarme (z. B. Host down, CPU-Auslastung)
  • Blackbox Exporter für die externe Erreichbarkeitsprüfung von außen

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zum lauffähigen Monitoring-Stack, Ergebnis der Hands-on-Übung) und werten sie im Anschluss transparent aus. Ergebnisse veröffentlichen wir, sobald sie belastbar sind.

Bereit, das Modul zu buchen?

Wir passen die Hands-on-Übung auf euren Erfahrungsstand und eure Zielumgebung an.

Academy Briefing anfragen