Training Module

Docker Model Runner: KI-Modelle lokal betreiben, MCP im Überblick

Sprachmodelle laufen meist über Cloud-Dienste – mit Datenabfluss, Kosten pro Anfrage und Limits. Der Docker Model Runner (DMR) führt quantisierte Open-Weight-Modelle stattdessen direkt lokal aus. In diesem 2-Stunden-Modul baut ihr einen Ein-Datei-KI-Übersetzer: ein 15-Zeilen-Python-Skript, ein Dockerfile und eine compose.yaml mit dem models:-Key, der ein Modell deklarativ einbindet und automatisch LLM_MODEL/LLM_URL in den Container injiziert. Anders als das Ausgangsmaterial, das für Docker Desktop auf Apple Silicon geschrieben ist, läuft dieses Modul komplett auf reiner Linux-Docker-Engine – Aktivierung per apt-get install docker-model-plugin statt Desktop-GUI, CPU-Backend ohne GPU-Zwang, mit dem kleinsten verfügbaren quantisierten ai/gemma3-Modell statt eines großen 8B-Modells. Danach ordnet ihr den Docker-MCP-Katalog ein – wie er KI-Werkzeuge per Container-Sandboxing sicher an lokale Daten heranlässt. Dieser Teil bleibt bewusst konzeptionell: Die MCP-Toolkit-Oberfläche existiert nur in Docker Desktop, ein verlässlicher Linux-CLI-Pfad ist öffentlich nicht ausreichend belegt für eine verifizierte Übung.

Academy Briefing vereinbaren

Oder sofort per Mail an kontakt@codecraft.academy

Format

Ca. 2 Stunden, live (remote oder vor Ort), Input & Hands-on, ein konzeptioneller Block

Teilnehmende

Absolvent:innen von “Docker Fortgeschritten” oder gleichwertige Compose-Kenntnisse, keine KI-Vorkenntnisse nötig

Voraussetzungen

Sicherer Umgang mit compose.yaml aus den Docker-Vorgängermodulen. Reine Linux-Docker-Engine reicht aus (kein Docker Desktop, kein GPU-Zwang). Keine Cloud-/API-Kosten für den lokalen DMR-Teil.

Warum dieses Training für deine Organisation wirkt

KI-Modelle wie jede andere Abhängigkeit

Der models:-Key in Compose behandelt ein Sprachmodell wie eine Datenbank oder einen Cache: deklariert, versioniert, automatisch verdrahtet. Kein manuelles API-Key-Management, kein externer Dienst, den ihr erst freigeben müsst.

Ehrlich auf eure Infrastruktur übersetzt

Das Ausgangsmaterial ist für Docker Desktop auf Apple Silicon gedacht. Dieses Modul läuft stattdessen auf einer reinen Linux-Docker-Engine-Sandbox ohne verschachtelte Virtualisierung und ohne garantierte GPU – demselben Umfeld, in dem eure Build- und Deploy-Infrastruktur tatsächlich läuft.

Sicherheits-Sandboxing eingeordnet, nicht überversprochen

Der Docker-MCP-Katalog zeigt, wie Container-Sandboxing einer KI kontrollierten Zugriff auf lokale Werkzeuge gibt – als fundierte Einordnung, nicht als brüchige Linux-Behelfsübung auf Basis eines einzelnen Community-Blogposts.

Was Teilnehmende mitnehmen

  • Einordnen, was der Docker Model Runner (DMR) macht, woher die geprüften Modelle im Docker-Hub-Namespace ai/ kommen und was Quantisierung für Dateigröße und Antwortqualität bedeutet.
  • Den DMR auf reiner Linux-Docker-Engine aktivieren: apt-get install docker-model-plugin statt Docker-Desktop-GUI, Verifikation per docker model version.
  • Ein KI-gestütztes Ein-Datei-Backend bauen: ein 15-Zeilen-Python-Skript, das über zwei von Compose automatisch injizierte Umgebungsvariablen (LLM_MODEL, LLM_URL) mit dem lokalen Modell im OpenAI-kompatiblen Format spricht.
  • Ein Sprachmodell deklarativ über den models:-Top-Level-Key in Compose einbinden und per docker compose up automatisch herunterladen, starten und verdrahten lassen.
  • Das kleinste verfügbare quantisierte ai/gemma3-Modell bewusst statt eines großen 8B-Modells wählen – mit CPU-Backend, ohne GPU-Zwang, lauffähig auf einer schlanken Sandbox-Instanz.
  • Den Docker-MCP-Katalog konzeptionell einordnen: Model Context Protocol, Container-Sandboxing als Sicherheitsmechanismus für KI-Werkzeugzugriff – bewusst als Einordnung ohne eigenes Hands-on, weil die MCP-Toolkit-GUI nur in Docker Desktop existiert.

Für wen dieses Modul ideal ist

  • • Absolvent:innen von “Docker Fortgeschritten” oder Teams mit gleichwertigen Compose-Kenntnissen
  • • Teams, die lokale KI-Modelle in Docker-Workflows evaluieren wollen, bevor sie eine Cloud-API-Anbindung entscheiden
  • • Alle, die MCP als Konzept verstehen wollen, ohne eine fragile Linux-Behelfsübung mitzumachen

Rahmendaten

  • • Dauer: ca. 2 Stunden live (remote oder vor Ort)
  • • Format: Input, durchgehendes Hands-on zum DMR, konzeptioneller Block zu MCP
  • • Voraussetzungen: abgeschlossenes Modul “Docker Fortgeschritten” oder gleichwertige Compose-Kenntnisse, reine Linux-Docker-Engine (kein Docker Desktop nötig), keine Cloud-Kostenwirkung für den lokalen Teil

Modulaufbau & Agenda

  1. Begrüßung & Einordnung (10 min): Format, warum lokale KI-Modelle in Docker Sinn ergeben, und die zentrale Abweichung vom Ausgangsmaterial: reine Linux-Docker-Engine statt Docker Desktop auf Apple Silicon.

  2. Docker Model Runner: Grundlagen & Modelle (20 min): was der DMR macht, der Docker-Hub-Namespace ai/, Quantisierung als Kompromiss zwischen Dateigröße und Qualität, Aktivierung per docker-model-plugin und docker model version.

  3. Hands-on: Der Ein-Datei-KI-Übersetzer (60 min, Kern): app.py, Dockerfile und compose.yaml mit models:-Key selbst bauen, docker compose up ausführen und die Übersetzung im Terminal sehen.

  4. Docker-MCP-Katalog: Sicherheits-Sandboxing für KI-Werkzeuge (20 min, konzeptionell, kein Hands-on): Model Context Protocol als offener Standard, Container-Sandboxing als Sicherheitsmechanismus, warum dieser Teil hier bewusst ohne eigene Übung bleibt.

  5. Zusammenfassung & Ausblick (10 min): Aufräumen mit docker compose down, die drei Säulen DMR/Compose-models:/MCP im Überblick, Einordnung gegenüber Cloud-LLM-Anbindungen.

Dieses Modul setzt keine KI-Vorkenntnisse voraus, aber sicheren Umgang mit compose.yaml aus Docker Fortgeschritten. Governance-Fragen rund um KI-Werkzeuge (Datenschutz, Lizenz-Grauzonen, Cloud-Act) sind bereits Teil von DevOps ganzheitlich: KI-Governance & Skill-Kompass und werden hier nicht wiederholt – dieses Modul ergänzt die dortige Einordnung um den praktischen, lokalen Hands-on-Einstieg.

Hands-on Inhalte (Auszug)

DMR-Grundlagen

  • Aktivierung per apt-get install docker-model-plugin, Verifikation per docker model version
  • Geprüfte Modelle im Namespace ai/ auf Docker Hub, Quantisierung als Größe-Qualität-Kompromiss
  • docker model list/pull/rm zur manuellen Modellverwaltung

Ein-Datei-KI-Übersetzer (Kern-Hands-on)

  • Ein 15-Zeilen-Python-Skript ohne externe pip-Pakete, nur Standardbibliothek
  • Ein schlankes Dockerfile auf Basis von python:3.11-slim
  • Eine compose.yaml mit models:-Key, kleinstes quantisiertes ai/gemma3-Modell, CPU-Backend

MCP-Katalog (konzeptionell)

  • Model Context Protocol als offener Standard für Werkzeugzugriff von Sprachmodellen
  • Container-Sandboxing als Antwort auf Prompt-Injection-Risiken bei lokalem Dateizugriff
  • Ausdrücklich kein Hands-on – die MCP-Toolkit-GUI existiert nur in Docker Desktop

Aufräumen & Einordnung

  • docker compose down zum sauberen Abbau
  • DMR/Compose-models:/MCP als drei zusammenhängende Bausteine im Überblick
  • Lokaler DMR-Teil ohne Cloud-API-Kosten – keine Verallgemeinerung auf KI-Nutzung insgesamt

Dieses Modul ist Teil unserer Pilotphase. Gemeinsam mit euch definieren wir passende Metriken (z. B. Zeit bis zur ersten lokalen Übersetzung, Ergebnis des Compose-models:-Hands-on) 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