0. Zielbild

Am Ende kannst du eine kleine Web-App versionieren, testen, containerisieren, per CI/CD ausliefern, in Kubernetes betreiben, per Terraform Infrastruktur beschreiben und mit Monitoring absichern.

Developer Laptop → Git Repository → CI/CD Pipeline → Container Registry → Kubernetes → Monitoring

1. Grundlagen: Linux, Netzwerk, Git

Baue ein solides Fundament, bevor du Tools stapelst.

Lernziele

• Linux-Dateisystem, Prozesse, Rechte, Services und Logs verstehen.
• IP, DNS, HTTP, TLS, Ports, Firewall und Load Balancer erklären.
• Git sicher nutzen: Branches, Pull Requests, Tags und Merge-Konflikte.

Praxis

1. Installiere WSL2, eine VM oder eine Cloud-VM.
2. Erstelle ein GitHub-Repository devops-lab.
3. Schreibe ein Diagnose-Skript für CPU, RAM, Disk und offene Ports.
4. Simuliere Fehler und dokumentiere die Lösung.

2. Scripting & Programmierbasis

Automatisiere wiederholbare Aufgaben verbindlich mit Bash. Python oder PowerShell dienen als optionale zweite Sprache für strukturierte Werkzeuge.

Lernziele

• Bash sicher und idempotent für Automatisierung nutzen.
• Optional Python oder PowerShell für kleine CLI-Tools einsetzen.
• JSON, YAML, Umgebungsvariablen und Exit Codes sicher verwenden.

Praxis

1. Schreibe healthcheck.sh, das eine URL prüft und bei Fehlern Exit Code 1 liefert.
2. Optional: Validiere eine JSON-Konfiguration mit Python oder PowerShell.
3. Erstelle ein Makefile mit test, lint, build und run.

3. Container mit Docker

Verpacke Anwendungen reproduzierbar und verstehe Images, Container, Volumes und Netzwerke.

Praxis

1. Baue eine kleine Web-App, bevorzugt mit Java/Spring Boot; alternativ mit Node.js, Python oder Go.
2. Schreibe ein sauberes Dockerfile.
3. Erstelle compose.yaml mit App und Datenbank.
4. Füge Healthchecks hinzu.

app/
  src/
  tests/
  Dockerfile
  compose.yaml
  .dockerignore

4. CI/CD mit GitHub Actions

Automatisiere Build, Tests, Security Checks und Deployment.

Praxis

1. Erstelle .github/workflows/ci.yml.
2. Pipeline: Checkout, Lint, Test, Docker Build.
3. Setze minimale permissions und pinne externe Actions im echten Repository auf vollständige Commit-SHAs.
4. Nutze Secrets für Registry-Zugangsdaten.
5. Füge einen manuellen Deployment-Trigger hinzu.

name: CI
on:
  pull_request:
  push:
    branches: [main]
permissions:
  contents: read
jobs:
  test-and-build:
    runs-on: ubuntu-latest
    steps:
      # Platzhalter durch einen geprüften vollständigen Commit-SHA ersetzen.
      - uses: actions/checkout@<FULL_COMMIT_SHA>
      - name: Run tests
        run: make test
      - name: Build image
        run: docker build -t devops-lab:${{ github.sha }} .

5. Cloud-Grundlagen

Verstehe IAM, Netzwerk, Compute, Storage, Datenbanken und Kostenkontrolle in einer Cloud.

Praxis

1. Lege ein Cloud-Konto oder eine lokale Alternative an.
2. Erstelle ein Budget oder einen Cost Alert.
3. Starte eine kleine VM oder nutze ein kostenloses Kubernetes-Lab.
4. Dokumentiere den Netzwerkfluss: Client → DNS → Load Balancer → App → DB.

6. Infrastructure as Code & Konfigurationsmanagement

Beschreibe Infrastruktur mit Terraform und verwalte Server-Konfigurationen mit Ansible.

Praxis

1. Erstelle main.tf, variables.tf, outputs.tf.
2. Nutze terraform fmt, validate, plan, apply, destroy.
3. Schreibe ein kleines Ansible-Playbook.
4. Dokumentiere, wo Terraform endet und Ansible beginnt.

infra/
  terraform/
    main.tf
    variables.tf
    outputs.tf
  ansible/
    inventory.ini
    playbook.yml

7. Kubernetes

Betreibe containerisierte Workloads mit Deployments, Services, Gateway API beziehungsweise bestehendem Ingress, ConfigMaps, Secrets und Helm.

Praxis

1. Starte einen lokalen Cluster mit kind, minikube oder Docker Desktop.
2. Erstelle Deployment und Service.
3. Veröffentliche den Dienst mit Gateway und HTTPRoute oder dokumentiere bewusst einen vorhandenen Ingress-Pfad.
4. Füge ConfigMap und Secret hinzu.
5. Nutze Readiness- und Liveness-Probes.
6. Optional: Paketierung mit Helm.

k8s/
  namespace.yml
  deployment.yml
  service.yml
  gateway.yml
  httproute.yml
  ingress-legacy.yml
  configmap.yml
  secret.example.yml

8. Observability

Mache Systeme beobachtbar mit Metriken, Logs, Dashboards und Alerts.

Praxis

1. Baue einen /metrics-Endpunkt ein oder nutze einen Exporter.
2. Starte Prometheus lokal oder im Cluster.
3. Erstelle ein Dashboard für Request Rate, Error Rate, Latency und CPU/Memory.
4. Definiere einen Alert für hohe Fehlerrate oder Nichterreichbarkeit.

9. Security, Reliability & Betrieb

Baue Sicherheit und Betriebsfähigkeit in den gesamten Pfad ein.

Praxis

1. Füge Dependency-Scanning oder Image-Scanning in CI ein.
2. Ersetze hartcodierte Secrets durch Secret Management.
3. Schreibe ein Runbook: „App ist nicht erreichbar“.
4. Teste Rollback eines Deployments.
5. Setze Ressourcenlimits in Kubernetes.

10. Portfolio-Projekte

11. 12-Wochen-Plan

12. Abschluss-Checkliste

Technisch

• ☐ App von Code bis Runtime erklären
• ☐ Docker Images bauen, debuggen und optimieren
• ☐ CI/CD Pipeline erstellen und analysieren
• ☐ Terraform planen und anwenden
• ☐ Kubernetes Deployments debuggen
• ☐ Monitoring und Alerts aufsetzen

Portfolio

• ☐ Klare README
• ☐ Architektur beschrieben
• ☐ Entscheidungen begründet
• ☐ Screenshots oder Logs erfolgreicher Deployments
• ☐ Runbook und Fehleranalyse

13. Quellen & Weiterlernen

• Docker Docs – Get started
• Docker Compose – Application model
• Kubernetes Basics
• Kubernetes Ingress und Gateway-Einordnung
• Terraform Docs
• Terraform Tutorials
• GitHub Actions Docs
• GitHub Actions – Continuous Integration
• GitHub Actions – Secure use
• Ansible Getting Started
• Prometheus Overview
• AWS DevOps

Empfohlenes Repository-Verzeichnis

devops-lab/
  README.md
  docs/
    architecture.md
    runbook.md
    incident-template.md
  app/
    src/
    tests/
    Dockerfile
    compose.yaml
    Makefile
  .github/workflows/
    ci.yml
    deploy.yml
  infra/
    terraform/
    ansible/
  k8s/
  monitoring/

14. Abschlussnachweis

Der Lernpfad gilt nicht durch Lesen als abgeschlossen, sondern durch einen nachvollziehbaren technischen Nachweis.

Abnahmefragen

1. Kann eine zweite Person das System ohne mündliche Hilfe bauen und starten?
2. Ist jedes Deployment einem Commit und einem unveränderlichen Artefakt zugeordnet?
3. Sind Fehler über Logs, Metriken und Traces eingrenzbar?
4. Sind Wiederherstellung, Rollback und Eskalation praktisch getestet?