Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Nachweisen, dass du ein Python-Tool allein von der Spezifikation bis zur CI-geprüften Auslieferung bauen kannst · Dauer: 150 min Praxis + 20 min Fragen · Voraussetzung: Tag 15

Regeln

  • Du baust ein Tool: healthz prüft HTTP-Endpunkte aus einer TOML-Datei parallel und meldet das Ergebnis als Tabelle oder JSON mit sauberem Exit-Code.
  • Erlaubt: Anhang A, --help, docs.python.org, die Doku von typer, httpx und pydantic. Nicht erlaubt: KI-Assistenten und Code aus den Kapiteln kopieren.
  • Die vorgegebene Testdatei darfst du nicht ändern. Gewertet wird ausschließlich mit dem Prüfskript am Ende.
  • Bestanden: mindestens 70 von 100 Punkten und Aufgabe A6 (Qualität) erfüllt.
mkdir -p ~/py-lab/pruefung && cd ~/py-lab/pruefung
uv init -q -p 3.14 --package --name healthz healthz
cd healthz && mkdir -p tests lab/www

Teil 1: Praktische Prüfung

Spezifikation

healthz check services.toml [--json] [--concurrency 10]
healthz --version
  └─ config.load_config() ──► [Service, ...] ──► checks.check_all() ──► [Result, ...]
     ConfigError ──► Exit 2       pydantic         TaskGroup + Semaphore   Exit 0 | 1
  • healthz.checks.Service (pydantic): name (nicht leer), url (nur http/https, ohne Zugangsdaten wie https://user:pw@host), expect: int = 200, timeout: float = 2.0 (größer 0).
  • healthz.checks.Result: name, url, ok, status (int | None), ms (Dauer), error (Name der Exception oder leer).
  • healthz.config.load_config(path) -> list[Service] liest [[service]]-Tabellen. Fehlende Datei, kaputtes TOML, ungültige Felder, keine Services oder doppelte Namen: ConfigError.
  • async healthz.checks.check_all(services, client, concurrency=10) -> list[Result]: ein gemeinsamer httpx.AsyncClient, höchstens concurrency gleichzeitige Requests, Ergebnisse in der Reihenfolge der Eingabe. ok heißt: Status gleich expect. Netzfehler werden zu ok=False, status=None, error="ConnectError" – nie zu einer Exception.
  • CLI (healthz = "healthz.cli:app", typer): check gibt pro Service eine Zeile aus, mit --json eine Liste von Objekten mit genau den Feldern von Result. Exit 0: alle ok, 1: mindestens einer nicht ok, 2: ConfigError (Meldung auf stderr). --version gibt healthz <version> aus.
  • Qualität: ruff mit extend-select = ["E501", "B", "UP", "SIM", "I", "S"], mypy strict auf src, pytest mit Coverage mindestens 80 %.
  • Auslieferung: Version 1.0.0, Wheel in dist/, GitHub-Actions-Workflow .github/workflows/ci.yml (uv, ruff, mypy, pytest).

Vorgegebene Tests

cat > tests/test_pruefung.py <<'EOF'
"""Vorgegebene Prüfungstests – nicht ändern."""

import asyncio
import json
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer

import httpx
import pytest
from typer.testing import CliRunner

from healthz.checks import Service, check_all
from healthz.cli import app
from healthz.config import ConfigError, load_config

runner = CliRunner()
OK_TOML = """
[[service]]
name = "api"
url = "https://api.lab/healthz"

[[service]]
name = "db"
url = "http://db.lab:8080/"
expect = 204
timeout = 0.5
"""


def write(tmp_path, text):
    path = tmp_path / "services.toml"
    path.write_text(text, encoding="utf-8")
    return path


def test_load_config(tmp_path):
    services = load_config(write(tmp_path, OK_TOML))
    assert [s.name for s in services] == ["api", "db"]
    assert (services[0].expect, services[0].timeout) == (200, 2.0)
    assert (services[1].expect, services[1].timeout) == (204, 0.5)


@pytest.mark.parametrize(
    "text",
    [
        "",  # keine Services
        "kaputt =",  # kein TOML
        '[[service]]\nname = "x"\n',  # url fehlt
        '[[service]]\nname = "x"\nurl = "ftp://x.lab/"\n',  # nur http(s)
        '[[service]]\nname = "x"\nurl = "https://u:[email protected]/"\n',  # Zugangsdaten
        '[[service]]\nname = "x"\nurl = "https://x.lab/"\ntimeout = 0\n',
        OK_TOML + '\n[[service]]\nname = "api"\nurl = "https://b.lab/"\n',  # doppelt
    ],
)
def test_load_config_fehler(tmp_path, text):
    with pytest.raises(ConfigError):
        load_config(write(tmp_path, text))


def handler(request: httpx.Request) -> httpx.Response:
    if request.url.host == "down.lab":
        raise httpx.ConnectError("refused", request=request)
    return httpx.Response(200 if request.url.host == "ok.lab" else 503)


def test_check_all_reihenfolge_und_fehler():
    services = [
        Service(name="ok", url="https://ok.lab/"),
        Service(name="bad", url="https://bad.lab/"),
        Service(name="down", url="https://down.lab/"),
        Service(name="anders", url="https://ok.lab/", expect=204),
    ]

    async def run():
        transport = httpx.MockTransport(handler)
        async with httpx.AsyncClient(transport=transport) as client:
            return await check_all(services, client, concurrency=2)

    results = asyncio.run(run())
    assert [(r.name, r.ok, r.status) for r in results] == [
        ("ok", True, 200),
        ("bad", False, 503),
        ("down", False, None),
        ("anders", False, 200),
    ]
    assert "ConnectError" in results[2].error
    assert all(r.ms >= 0 for r in results)


class Lab(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200 if self.path == "/healthz" else 404)
        self.end_headers()

    def log_message(self, *args):
        pass


@pytest.fixture
def lab_url():
    server = ThreadingHTTPServer(("127.0.0.1", 0), Lab)
    threading.Thread(target=server.serve_forever, daemon=True).start()
    yield f"http://127.0.0.1:{server.server_address[1]}"
    server.shutdown()


def test_cli_exit_codes_und_json(tmp_path, lab_url):
    good = f'[[service]]\nname = "lab"\nurl = "{lab_url}/healthz"\n'
    assert runner.invoke(app, ["check", str(write(tmp_path, good))]).exit_code == 0
    bad = good + f'\n[[service]]\nname = "weg"\nurl = "{lab_url}/weg"\n'
    result = runner.invoke(app, ["check", str(write(tmp_path, bad)), "--json"])
    assert result.exit_code == 1
    data = json.loads(result.output)
    assert [(d["name"], d["ok"], d["status"]) for d in data] == [
        ("lab", True, 200),
        ("weg", False, 404),
    ]
    assert set(data[0]) == {"name", "url", "ok", "status", "ms", "error"}


def test_cli_config_fehler_und_version(tmp_path):
    result = runner.invoke(app, ["check", str(write(tmp_path, "kaputt ="))])
    assert result.exit_code == 2
    version = runner.invoke(app, ["--version"])
    assert version.exit_code == 0
    assert version.output.startswith("healthz ")
EOF

Lab-Daten

echo ok > lab/www/healthz
cat > lab/services.toml <<'EOF'
[[service]]
name = "lab"
url = "http://127.0.0.1:8781/healthz"

[[service]]
name = "fehlt"
url = "http://127.0.0.1:8781/gibt-es-nicht"

[[service]]
name = "aus"
url = "http://127.0.0.1:9/"
timeout = 0.5
EOF

Den Lab-Server startest du zum Ausprobieren selbst; das Prüfskript startet ihn eigenständig:

uv run python -m http.server 8781 --bind 127.0.0.1 --directory lab/www

Aufgaben

Aufgabe Inhalt Punkte
A1 Projekt: Python 3.14, Kommando healthz zeigt auf healthz.cli:app 5
A2 load_config mit pydantic-Validierung und ConfigError 15
A3 check_all: TaskGroup, Semaphore, Fehler pro Service abfangen 20
A4 CLI: Tabelle, --json, Exit-Codes 0/1/2, --version 15
A5 mindestens 3 eigene Tests (z. B. Timeout, leere Liste) 10
A6 ruff, ruff format, mypy strict, Coverage ≥ 80 % 10
A7 Version 1.0.0 per uv version, Wheel per uv build 10
A8 Live: lab, fehlt, aus liefern ok/nicht ok/nicht ok 10
A9 CI-Workflow, gültig laut actionlint 5

Erwartete Ausgabe im Live-Test (Zeiten variieren):

OK    200                76ms  lab  http://127.0.0.1:8781/healthz
FAIL  404                12ms  fehlt  http://127.0.0.1:8781/gibt-es-nicht
FAIL  ConnectError        2ms  aus  http://127.0.0.1:9/

Prüfskript

cat > pruefung.sh <<'EOF'
#!/usr/bin/env bash
# Prüfskript Abschlussprüfung: vergibt Punkte je Aufgabe
cd ~/py-lab/pruefung/healthz || exit 1
P=0
pts() {
  if eval "$3" >/dev/null 2>&1; then echo "✔ $2 (+$1)"; P=$((P + $1))
  else echo "✘ $2 (0/$1)"; fi
}
T="uv run pytest -q --no-cov tests/test_pruefung.py"
uv run python -m http.server 8781 --bind 127.0.0.1 --directory lab/www \
  >/dev/null 2>&1 &
sleep 2
pts 5 "A1 Projekt und Kommando" "grep -qx 3.14 .python-version && \
  grep -q '^healthz = \"healthz.cli:app\"' pyproject.toml"
pts 15 "A2 Konfiguration" "$T -k load_config"
pts 20 "A3 Parallele Checks" "$T -k check_all"
pts 15 "A4 CLI und Exit-Codes" "$T -k cli"
pts 10 "A5 Eigene Tests (mind. 3)" \
  "test \$(uv run pytest -q --no-cov --collect-only | grep -c '::') -ge 14"
pts 10 "A6 Qualität" "uv run ruff check && uv run ruff format --check && \
  uv run mypy && uv run pytest -q"
pts 10 "A7 Version 1.0.0 und Wheel" "uv run healthz --version | \
  grep -qx 'healthz 1.0.0' && test -f dist/healthz-1.0.0-py3-none-any.whl"
pts 10 "A8 Live gegen Lab-Server" "uv run healthz check lab/services.toml --json \
  | jq -e '[.[].ok] == [true, false, false]'"
pts 5 "A9 CI-Workflow gültig" \
  "test -f .github/workflows/ci.yml && uvx --from actionlint-py actionlint"
pkill -f 'http.server 8781'
echo "Punkte: $P / 100"
EOF
bash pruefung.sh

Erwartet bei voller Lösung:

✔ A1 Projekt und Kommando (+5)
✔ A2 Konfiguration (+15)
✔ A3 Parallele Checks (+20)
✔ A4 CLI und Exit-Codes (+15)
✔ A5 Eigene Tests (mind. 3) (+10)
✔ A6 Qualität (+10)
✔ A7 Version 1.0.0 und Wheel (+10)
✔ A8 Live gegen Lab-Server (+10)
✔ A9 CI-Workflow gültig (+5)
Punkte: 100 / 100

--no-cov schaltet die Coverage-Schwelle für die Teilläufe ab – sonst scheiterte A2 allein daran, dass vier Tests nicht 80 % des Codes abdecken. Die vorgegebenen Tests zählen 11, mit drei eigenen sind es 14.

Tipp: Arbeite in der Reihenfolge der Tests: uv run pytest -q --no-cov -k load_config zuerst grün bekommen, dann check_all, dann das CLI. Qualität und Auslieferung gehen in den letzten 20 Minuten schnell, wenn ruff und mypy von Anfang an mitlaufen.

Eine geprüfte Referenzlösung liegt im Begleitmaterial unter code/anhang-b-healthz/. Sieh sie dir erst nach der Prüfung an.

Teil 2: Fragen

Je Frage ein bis zwei Sätze, ohne Hilfsmittel. 20 von 25 richtig: Theorie bestanden.

  1. Was liegt in uv.lock, was in .venv, und was davon gehört ins Repo?
  2. Was bewirkt uv init --package gegenüber uv init, und wozu dient [project.scripts]?
  3. Warum ist def f(items=[]) ein Fehler, und wie löst @dataclass das?
  4. Was ist der Unterschied zwischen Iterable[LogEntry] und list[LogEntry] als Parametertyp?
  5. Wozu dient der * in def summarize(entries, *, since=None)?
  6. Warum lassen sich naive und zeitzonenbehaftete datetime-Werte nicht vergleichen, und was ist die Regel im Buch?
  7. Warum subprocess.run([...]) statt subprocess.run("...", shell=True)?
  8. Welche Exit-Codes verwendet das Buch, und warum ist 2 für Bedienfehler reserviert?
  9. Was bewirkt raise CertError(...) from err?
  10. Warum patcht man checkcert.core.socket.create_connection und nicht socket.create_connection?
  11. Wofür sind tmp_path, monkeypatch und caplog in pytest gut?
  12. Was prüft mypy --strict zusätzlich, und warum reicht ein Typ-Hint allein nicht?
  13. Warum braucht ein HTTP-Client immer einen Timeout, und welche Statuscodes wiederholt man mit Backoff?
  14. Was erledigt pydantic an der Grenze eines Tools, das ein normales Dict nicht kann?
  15. Wann hilft asyncio, wann ProcessPoolExecutor, und warum helfen Threads im Standard-Build nicht bei CPU-Last?
  16. Was macht eine TaskGroup, wenn ein Task eine Exception wirft?
  17. Warum rechnet costreport Geld in Cent als int (oder Decimal) statt als float?
  18. Was zeigen tottime und cumtime in cProfile?
  19. Warum hat @cache auf parse_stamp logsum langsamer gemacht, und wann wäre es richtig?
  20. Was spart ein Generator gegenüber einer Liste, und wann wird bei read_entries die Datei geöffnet?
  21. Warum teilt logsum die Datei in Byte-Bereiche, statt Zeilen an die Prozesse zu schicken?
  22. Was unterscheidet uv tool install, ein Wheel und ein zipapp beim Ausliefern?
  23. Wozu stream_options={"include_usage": True}, und was misst die TTFT?
  24. Warum ist eine strukturierte LLM-Ausgabe mit pydantic zwar formal, aber nicht inhaltlich verlässlich?
  25. Nenne drei Guardrails für eine Agenten-Schleife mit Tool Calling.

Lösungsschlüssel

  1. uv.lock pinnt alle Versionen exakt (ins Repo), .venv ist die lokale Umgebung (nie ins Repo, uv sync baut sie neu).
  2. Ein installierbares Paket im src/-Layout mit Build-Backend; [project.scripts] macht eine Funktion oder App zu einem Kommando im PATH.
  3. Der Default wird einmal beim Definieren erzeugt und von allen Aufrufen geteilt; dataclasses verbieten veränderliche Defaults und verlangen field(default_factory=list).
  4. Iterable akzeptiert alles Durchlaufbare, auch Generatoren – die Funktion verspricht nur einmaliges Iterieren und bleibt speicherfreundlich.
  5. Alle Parameter danach sind keyword-only; Aufrufe bleiben lesbar und Parameter lassen sich später umsortieren.
  6. Ohne Zeitzone ist der Zeitpunkt mehrdeutig, Python wirft TypeError; das Buch rechnet immer in UTC und macht Eingaben ohne Zone zu UTC.
  7. Die Argumentliste wird ohne Shell übergeben, Leerzeichen und ; in Dateinamen bleiben harmlos – keine Command Injection.
  8. 0 ok, 1 fachlicher Befund, 2 Bedienfehler, 3 Umgebung kaputt bzw. Nagios UNKNOWN; 2 ist die Konvention von argparse/click/typer, ein Retry hilft dort nicht.
  9. Es wirft die eigene Exception und hängt die ursprüngliche als __cause__ an; der Traceback zeigt beide, Tests können die Ursache prüfen.
  10. Patchen muss man dort, wo der Name nachgeschlagen wird – im Modul checkcert.core, das socket importiert hat.
  11. tmp_path: frischer Ordner pro Test; monkeypatch: Attribute und Umgebungsvariablen temporär ersetzen; caplog: Log-Meldungen einfangen und prüfen.
  12. Typ-Hints an jeder Funktion, kein implizites Any, keine ungeprüften Optionals; Python selbst ignoriert Hints zur Laufzeit.
  13. Ohne Timeout hängt ein Tool bei einem toten Server ewig; wiederholt werden 429, 500, 502, 503, 504 und Transportfehler – mit Backoff und Jitter, 4xx sonst nicht.
  14. Typen umwandeln und prüfen (URL, Datum, Literal), Pflichtfelder erzwingen, verständliche Fehler liefern und ein JSON-Schema erzeugen.
  15. asyncio bei viel Warten auf Netz/Disk, Prozesse bei CPU-Last; der GIL lässt im Standard-Build nur einen Thread gleichzeitig Python-Code ausführen.
  16. Sie bricht die übrigen Tasks ab und wirft eine ExceptionGroup, die man mit except* zerlegt.
  17. float kann Beträge wie 0,10 nicht exakt darstellen; Summen über tausende Zeilen weichen sonst um Cents ab.
  18. tottime ist die Zeit in der Funktion selbst, cumtime inklusive aller aufgerufenen Funktionen.
  19. Nur 25 % Treffer: Hashing und Verwaltung kosten mehr, und der unbegrenzte Cache hält 748 000 Objekte; richtig bei vielen Wiederholungen, dann mit lru_cache(maxsize=…).
  20. Es lebt immer nur ein Eintrag im Speicher statt aller; die Datei wird erst beim ersten next() geöffnet, also innerhalb von summarize.
  21. Pickling von Millionen Strings kostet mehr als das Parsen; Byte-Bereiche übertragen nur zwei Zahlen, jeder Prozess liest selbst.
  22. uv tool install legt ein eigenes venv mit Kommando an; ein Wheel ist das Standardpaket für Index und pip; ein zipapp ist eine Datei, braucht aber ein passendes Python auf dem Ziel.
  23. Ohne die Option liefert der Stream keine Token-Zahlen; TTFT ist die Zeit bis zum ersten Token, also die gefühlte Wartezeit.
  24. Das Schema erzwingt Form und Typen, nicht Wahrheit: Das Modell kann gültiges JSON mit falschem Befehl oder falscher Bewertung liefern.
  25. Allowlist der Tools, Argumente validieren, Obergrenzen für Schritte, Tool-Aufrufe und Zeit; außerdem nur read-only Tools und nie LLM-Text an eine Shell.

Teil 3: Selbsteinschätzung

Thema kann ich im Lab gemacht
uv, Projekte, ruff, pytest (Tag 0) [ ] [ ]
Syntax, Comprehensions (Tag 1) [ ] [ ]
Funktionen, dataclasses, Module, mypy (Tag 2) [ ] [ ]
typer, pathlib, subprocess, Exit-Codes (Tag 3) [ ] [ ]
Exceptions, Logging, Fixtures, Mocks (Tag 4) [ ] [ ]
Packaging, pre-commit, Versionierung (Tag 5) [ ] [ ]
httpx, Retries, pydantic (Tag 6) [ ] [ ]
asyncio, TaskGroup, Threads vs. Prozesse (Tag 7) [ ] [ ]
csv, sqlite3, polars (Tag 8) [ ] [ ]
FastAPI, TestClient, Dockerfile (Tag 9) [ ] [ ]
LLM-APIs, Streaming, strukturierte Ausgabe (Tag 10) [ ] [ ]
Embeddings, RAG, Evaluation (Tag 11) [ ] [ ]
Tool Calling, Agenten-Loop, MCP (Tag 12) [ ] [ ]
scikit-learn, PyTorch-Einstieg (Tag 13) [ ] [ ]
Profiling, Optimierung, Verteilung, CI (Tag 14) [ ] [ ]
Tools unter Zeitdruck (Tag 15) [ ] [ ]

Jede Zeile ohne zwei Kreuze: das Kapitel noch einmal durcharbeiten – diesmal ohne die Erwartet-Blöcke vorher zu lesen.