[{"data":1,"prerenderedAt":-1},["ShallowReactive",2],{"blog-containerisierung-von-ki-anwendungen-docker":3},{"id":4,"title":5,"author":6,"body":7,"date":658,"description":659,"extension":660,"image":661,"meta":662,"navigation":663,"path":664,"readingTime":665,"seo":666,"stem":667,"tags":668,"__hash__":674},"content/blog/containerisierung-von-ki-anwendungen-docker.md","Docker für KI-Deployment: Containerisierung in der Praxis","KIlian",{"type":8,"value":9,"toc":631},"minimark",[10,14,17,20,25,44,48,51,65,69,72,132,138,142,196,200,203,211,214,225,228,236,241,245,279,283,379,383,386,392,395,401,404,410,413,419,422,428,431,437,440,446,451,455,511,515,532,536,553,557,562,565,569,572,576,579,583,586,590,593,597,600,604,607,611,614,618,621,625,628],[11,12,13],"p",{},"Viele ML-Teams scheitern nicht am Modell — sondern am Betrieb. Unterschiedliche Umgebungen, fragile Abhängigkeiten und inkonsistente CUDA-Setups machen Releases langsam und riskant.",[11,15,16],{},"Docker löst genau dieses Problem: Ein reproduzierbares, portables Paket Ihrer KI-Anwendung, das lokal, auf der GPU-Workstation und im Cluster gleich läuft. In diesem Guide bündeln wir Best Practices für sauberes docker-basiertes KI-Deployment, inklusive GPU, Caching und Skalierung.",[11,18,19],{},"Sie bekommen eine klare Schritt-für-Schritt-Anleitung, minimalen Beispielcode und eine Pre-Flight-Checkliste, damit Ihr nächstes Release stabil und schnell live geht.",[21,22,24],"h2",{"id":23},"tldr","TL;DR",[26,27,28,32,35,38,41],"ul",{},[29,30,31],"li",{},"Containerisieren Sie Modell, Code und Server in separaten, schlanken Schichten; pinnen Sie Python-, CUDA- und Framework-Versionen.",[29,33,34],{},"Nutzen Sie Multi-Stage-Builds, Non-Root-User und reproduzierbare Lockfiles für zuverlässige Docker-Images.",[29,36,37],{},"Für GPU: NVIDIA Container Toolkit installieren, passende CUDA-Runtime wählen und mit docker run --gpus all starten.",[29,39,40],{},"Cachen Sie Modellartefakte über Volumes/Registry-Downloads; trennen Sie Build-Time und Run-Time Downloads bewusst.",[29,42,43],{},"Starten Sie lokal mit Docker Compose; skalieren Sie in Produktion auf Kubernetes oder einen Managed Container Service.",[21,45,47],{"id":46},"was-bedeutet-containerisierung-von-ki-anwendungen","Was bedeutet Containerisierung von KI-Anwendungen?",[11,49,50],{},"Containerisierung bedeutet, eine KI-Anwendung samt Laufzeitumgebung, Abhängigkeiten und Konfiguration als isoliertes, portables Artefakt (Docker-Image) zu paketieren. Das Ergebnis ist ein Container, der auf jeder kompatiblen Host-Maschine identisch läuft — unabhängig von lokal installierten Bibliotheken. Für KI-Workloads umfasst das typischerweise:",[26,52,53,56,59,62],{},[29,54,55],{},"Python-Interpreter und Libraries (z. B. PyTorch, Transformers)",[29,57,58],{},"Systembibliotheken (z. B. CUDA, cuDNN für GPU)",[29,60,61],{},"Modellartefakte und Konfiguration",[29,63,64],{},"Einen Webserver (z. B. FastAPI/Uvicorn) für Inference-Endpunkte",[21,66,68],{"id":67},"architektur-vom-notebook-zum-produktionsreifen-container","Architektur: Vom Notebook zum produktionsreifen Container",[11,70,71],{},"Der Weg vom Notebook zur robusten Container-App führt über eine klare Trennung der Verantwortlichkeiten.",[26,73,74,88,99,110,121],{},[29,75,76,77],{},"App-Schicht:\n",[26,78,79,82,85],{},[29,80,81],{},"API-Server (FastAPI/Flask) mit klaren Endpunkten",[29,83,84],{},"Vor-/Nachverarbeitung, Validierung, Logging",[29,86,87],{},"Health-/Readiness-Probes",[29,89,90,91],{},"ML-Schicht:\n",[26,92,93,96],{},[29,94,95],{},"Modell-Lade- und Inferenzlogik",[29,97,98],{},"Versionierte Checkpoints aus dem Model Registry (z. B. MLflow, HF Hub)",[29,100,101,102],{},"System-Schicht:\n",[26,103,104,107],{},[29,105,106],{},"Basis-Image (CPU oder GPU)",[29,108,109],{},"Paket- und OS-Abhängigkeiten",[29,111,112,113],{},"Konfiguration:\n",[26,114,115,118],{},[29,116,117],{},"Umgebungsvariablen (z. B. MODEL_ID, BATCH_SIZE)",[29,119,120],{},"Secrets (Tokens) via Secret-Store/Kubernetes Secrets",[29,122,123,124],{},"Artefakte:\n",[26,125,126,129],{},[29,127,128],{},"Persistenz/Caching via Volumes oder Objekt-Storage",[29,130,131],{},"Telemetrie (Metriken, Traces) via Sidecar/Agent",[133,134,135],"blockquote",{},[11,136,137],{},"Praxis-Tipp: Halten Sie Container zustandslos. Caches und Modell-Downloads gehören in Volumes oder Remote-Speicher; so bleiben Ihre Images klein und Deployments wiederholbar.",[21,139,141],{"id":140},"docker-builds-für-ml-best-practices","Docker-Builds für ML: Best Practices",[26,143,144,147,150,161,180,188],{},[29,145,146],{},"Multi-Stage-Builds: Abhängigkeiten in einer eigenen Schicht installieren, App-Code zuletzt kopieren, um Caching zu nutzen.",[29,148,149],{},"Schlanke Basis-Images: python:3.11-slim für CPU; pytorch/pytorch:...-runtime oder nvidia/cuda:...-runtime für GPU.",[29,151,152,153],{},"Reproduzierbarkeit:\n",[26,154,155,158],{},[29,156,157],{},"Pin-Versionen in requirements.txt oder poetry.lock",[29,159,160],{},"CUDA/cuDNN-Versionen explizit wählen, passend zum Framework",[29,162,163,164],{},"Sicherheit und Größe:\n",[26,165,166,169,172],{},[29,167,168],{},"Non-Root-User",[29,170,171],{},"Unnötige Build-Tools entfernen",[29,173,174,175,179],{},".dockerignore pflegen (z. B. .venv, ",[176,177,178],"strong",{},"pycache",")",[29,181,182,183],{},"Start-up-Zeit:\n",[26,184,185],{},[29,186,187],{},"Warmup beim Containerstart (Modell laden, ggf. JIT/ONNX/TensorRT vorbereiten)",[29,189,190,191],{},"Observability:\n",[26,192,193],{},[29,194,195],{},"Prometheus-Metriken/Logs direkt integrieren",[21,197,199],{"id":198},"gpu-support-mit-docker","GPU-Support mit Docker",[11,201,202],{},"Für GPU-Inferenz benötigen Sie:",[26,204,205,208],{},[29,206,207],{},"Installiertes NVIDIA-Treiberset auf dem Host (Treiber kompatibel mit der gewünschten CUDA-Version)",[29,209,210],{},"NVIDIA Container Toolkit (nvidia-container-toolkit)",[11,212,213],{},"Start mit GPU per CLI:",[215,216,221],"pre",{"className":217,"code":219,"language":220},[218],"language-text","docker run --rm -p 8080:8080 --gpus all your-org/ki-api:latest\n","text",[222,223,219],"code",{"__ignoreMap":224},"",[11,226,227],{},"Wahl des Basis-Images:",[26,229,230,233],{},[29,231,232],{},"CPU: python:3.11-slim (Torch CPU Wheels)",[29,234,235],{},"GPU: pytorch/pytorch:2.3.1-cuda12.1-cudnn8-runtime oder nvidia/cuda:12.1.0-cudnn8-runtime-ubuntu22.04 plus pip install torch==…+cu121",[133,237,238],{},[11,239,240],{},"Praxis-Tipp: Stimmen Sie CUDA, cuDNN und Framework exakt ab. Mischen Sie keine cu117-Wheels mit einem cu121-Base-Image.",[21,242,244],{"id":243},"daten-modelle-und-caching","Daten, Modelle und Caching",[26,246,247,258,269],{},[29,248,249,250],{},"Modelle:\n",[26,251,252,255],{},[29,253,254],{},"Aus Model Registry beziehen (MLflow, Hugging Face Hub, S3) — nie “heimlich” im Build ohne Versionierung",[29,256,257],{},"Hash- oder Versions-Pin (z. B. commit SHA) verwenden",[29,259,260,261],{},"Caching:\n",[26,262,263,266],{},[29,264,265],{},"Hugging Face: HF_HOME als Volume mounten",[29,267,268],{},"Torch/TensorRT/ONNX-Cache in Volume für schnellere Warmups",[29,270,112,271],{},[26,272,273,276],{},[29,274,275],{},"MODEL_ID, REVISION, TOKEN als Env-Vars",[29,277,278],{},"Secrets nicht ins Image backen",[21,280,282],{"id":281},"deployment-optionen-lokal-bis-cluster","Deployment-Optionen: Lokal bis Cluster",[284,285,286,305],"table",{},[287,288,289],"thead",{},[290,291,292,296,299,302],"tr",{},[293,294,295],"th",{},"Option",[293,297,298],{},"Vorteile",[293,300,301],{},"Nachteile",[293,303,304],{},"Wann einsetzen",[306,307,308,323,337,351,365],"tbody",{},[290,309,310,314,317,320],{},[311,312,313],"td",{},"Docker lokal",[311,315,316],{},"Schnell, einfaches Debugging",[311,318,319],{},"Keine Hochverfügbarkeit",[311,321,322],{},"Entwicklung, POCs",[290,324,325,328,331,334],{},[311,326,327],{},"Docker Compose",[311,329,330],{},"Mehrere Services, lokale Parität",[311,332,333],{},"Limitierte Orchestrierung",[311,335,336],{},"Dev/Stage, kleine Inferenz-Services",[290,338,339,342,345,348],{},[311,340,341],{},"Kubernetes",[311,343,344],{},"Skalierung, Self-Healing, GPU-Scheduling",[311,346,347],{},"Höhere Komplexität",[311,349,350],{},"Produktion, Multi-Region, SLOs",[290,352,353,356,359,362],{},[311,354,355],{},"Managed (ECS, GKE, AKS)",[311,357,358],{},"Weniger Ops-Aufwand",[311,360,361],{},"Anbieterbindung, Kosten",[311,363,364],{},"Produktion ohne eigenes Control Plane",[290,366,367,370,373,376],{},[311,368,369],{},"Serverless-Container (Cloud Run)",[311,371,372],{},"Zero-Scale, schnelles Go-Live",[311,374,375],{},"Kaltstarts, begrenzte GPUs",[311,377,378],{},"Spiky Traffic, kleine Modelle",[21,380,382],{"id":381},"schritt-für-schritt-ein-fastapi-model-server-containerisieren","Schritt für Schritt: Ein FastAPI-Model-Server containerisieren",[11,384,385],{},"Minimaler API-Server (CPU-Beispiel)",[215,387,390],{"className":388,"code":389,"language":220},[218],"# app.py\nfrom fastapi import FastAPI\nimport torch\nfrom torchvision.models import resnet18, ResNet18_Weights\n\napp = FastAPI()\nweights = ResNet18_Weights.DEFAULT\nmodel = resnet18(weights=weights).eval()\n\n@torch.inference_mode()\n@app.get(\"/healthz\")\ndef health():\n    return {\"status\": \"ok\"}\n\n@torch.inference_mode()\n@app.post(\"/predict\")\ndef predict(item: dict):\n    # Beispiel: nur Struktur, echte Vorverarbeitung weglassen\n    # In der Praxis: Tensor bauen, normalisieren, model(tensor)\n    return {\"prediction\": \"class_x\", \"confidence\": 0.9}  # Platzhalter\n",[222,391,389],{"__ignoreMap":224},[11,393,394],{},"requirements.txt",[215,396,399],{"className":397,"code":398,"language":220},[218],"fastapi==0.110.0\nuvicorn[standard]==0.29.0\ntorch==2.2.2\ntorchvision==0.17.2\n",[222,400,398],{"__ignoreMap":224},[11,402,403],{},"Dockerfile (CPU, schlank, reproduzierbar)",[215,405,408],{"className":406,"code":407,"language":220},[218],"# syntax=docker/dockerfile:1.6\nFROM python:3.11-slim\n\nENV PYTHONDONTWRITEBYTECODE=1 \\\n    PYTHONUNBUFFERED=1 \\\n    PIP_NO_CACHE_DIR=1\n\n# Systemdeps minimal halten; libgl1 für torchvision, falls nötig\nRUN apt-get update && apt-get install -y --no-install-recommends \\\n    libglib2.0-0 libgl1 ca-certificates && \\\n    rm -rf /var/lib/apt/lists/*\n\nWORKDIR /app\nCOPY requirements.txt .\nRUN pip install --upgrade pip && pip install -r requirements.txt\n\n# Non-Root User\nRUN useradd -m appuser\nUSER appuser\n\nCOPY --chown=appuser:appuser . .\n\nEXPOSE 8080\nCMD [\"uvicorn\", \"app:app\", \"--host\", \"0.0.0.0\", \"--port\", \"8080\"]\n",[222,409,407],{"__ignoreMap":224},[11,411,412],{},"Build & Run",[215,414,417],{"className":415,"code":416,"language":220},[218],"docker build -t ki-api:cpu .\ndocker run --rm -p 8080:8080 ki-api:cpu\n",[222,418,416],{"__ignoreMap":224},[11,420,421],{},"GPU-Variante (Basis-Image tauschen)",[215,423,426],{"className":424,"code":425,"language":220},[218],"# Dockerfile.gpu (Auszug)\nFROM pytorch/pytorch:2.3.1-cuda12.1-cudnn8-runtime\nWORKDIR /app\nRUN pip install --upgrade pip && pip install fastapi==0.110.0 uvicorn[standard]==0.29.0\nCOPY . .\nEXPOSE 8080\nCMD [\"uvicorn\", \"app:app\", \"--host\", \"0.0.0.0\", \"--port\", \"8080\"]\n",[222,427,425],{"__ignoreMap":224},[11,429,430],{},"GPU starten",[215,432,435],{"className":433,"code":434,"language":220},[218],"docker build -f Dockerfile.gpu -t ki-api:gpu .\ndocker run --rm -p 8080:8080 --gpus all ki-api:gpu\n",[222,436,434],{"__ignoreMap":224},[11,438,439],{},"Lokale Orchestrierung mit Compose (CPU)",[215,441,444],{"className":442,"code":443,"language":220},[218],"# docker-compose.yml\nservices:\n  api:\n    build: .\n    ports:\n      - \"8080:8080\"\n    environment:\n      - HF_HOME=/models/cache\n    volumes:\n      - ./models:/models\n",[222,445,443],{"__ignoreMap":224},[133,447,448],{},[11,449,450],{},"Praxis-Tipp: Für GPU unter Compose nutzen Sie entweder docker run --gpus all oder aktivieren Geräte-Zugriff entsprechend Ihrer Docker/Compose-Version. Halten Sie die Compose-Datei für Dev CPU-first, und testen Sie GPU separat.",[21,452,454],{"id":453},"pre-flight-checkliste-vor-dem-ki-deployment-mit-docker","Pre-Flight-Checkliste vor dem KI-Deployment mit Docker",[26,456,457,465,473,481,489,496,503],{},[29,458,459,460],{},"Versions-Pins:\n",[26,461,462],{},[29,463,464],{},"Python-, Framework-, CUDA-/cuDNN-Versionen festgelegt",[29,466,467,468],{},"Sicherheitsbasis:\n",[26,469,470],{},[29,471,472],{},"Non-Root-User, nur benötigte Ports offen, Secrets via Env/Secret-Store",[29,474,475,476],{},"Build-Time:\n",[26,477,478],{},[29,479,480],{},"Multi-Stage, .dockerignore gepflegt, Layer klein",[29,482,483,484],{},"Startverhalten:\n",[26,485,486],{},[29,487,488],{},"Health-/Readiness-Probes, Warmup vorhanden",[29,490,123,491],{},[26,492,493],{},[29,494,495],{},"Modellquelle versioniert, Cache als Volume",[29,497,190,498],{},[26,499,500],{},[29,501,502],{},"Logs strukturiert, Metriken/Tracing integriert",[29,504,505,506],{},"Skalierung:\n",[26,507,508],{},[29,509,510],{},"Ressourcenlimits (CPU/RAM), Concurrency, Batch-Größe getestet",[21,512,514],{"id":513},"best-practices-für-ki-container","Best Practices für KI-Container",[26,516,517,520,523,526,529],{},[29,518,519],{},"Trennen Sie Build- und Run-Zeit-Downloads. Modelle in Run-Zeit laden, aber Cache mounten, um Kaltstarts zu reduzieren.",[29,521,522],{},"Nutzen Sie Feature-Gates/Flags für experimentelle Modelle statt separater Images.",[29,524,525],{},"Verwenden Sie ONNX/TensorRT oder TorchScript, wenn Latenz kritisch ist; bauen Sie diese Artefakte deterministisch.",[29,527,528],{},"Definieren Sie klare SLOs (Latenz, Durchsatz) und testen Sie mit Lastprofilen, die der Produktion ähneln.",[29,530,531],{},"Halten Sie Images pro Zielplattform (CPU/GPU) getrennt; keine “One-Size-Fits-All”-Images.",[21,533,535],{"id":534},"typische-fehler-und-wie-man-sie-vermeidet","Typische Fehler und wie man sie vermeidet",[26,537,538,541,544,547,550],{},[29,539,540],{},"Ungepinntes CUDA/Torch führt zu Laufzeitfehlern. Lösung: Exakte Versionen pinnen und kompatible Base-Images nutzen.",[29,542,543],{},"Modelle im Image backen bläht Layer auf. Lösung: Download bei Start, Cache via Volume, oder artefaktorientierte Sidecar.",[29,545,546],{},"Root-User im Container erhöht Risiko. Lösung: Non-Root-User und minimalistische OS-Pakete.",[29,548,549],{},"Fehlende Healthchecks erschweren Rollouts. Lösung: /healthz und Readiness-Probe implementieren.",[29,551,552],{},"“Works on my GPU” im Team. Lösung: Einheitliche Devcontainer/Compose-Profile, CI-Builds auf GPU-Runnern.",[21,554,556],{"id":555},"häufige-fragen-faq","Häufige Fragen (FAQ)",[558,559,561],"h3",{"id":560},"was-ist-der-unterschied-zwischen-vm-und-docker-für-ki-workloads","Was ist der Unterschied zwischen VM und Docker für KI-Workloads?",[11,563,564],{},"VMs virtualisieren das gesamte Betriebssystem, Container teilen sich den Host-Kernel. Docker-Container starten schneller, sind leichter und besser für wiederholbares KI-Deployment geeignet. VMs können sinnvoll sein, wenn Sie harte Isolation oder heterogene Betriebssysteme benötigen.",[558,566,568],{"id":567},"wie-stelle-ich-sicher-dass-mein-docker-image-reproduzierbar-ist","Wie stelle ich sicher, dass mein Docker-Image reproduzierbar ist?",[11,570,571],{},"Pinnen Sie alle Versionen in requirements.txt/poetry.lock, wählen Sie ein festes Basis-Image und bauen Sie in CI mit definiertem Build-Arg/Tag. Vermeiden Sie unversionierte “latest”-Tags und externe Netzwerkzugriffe ohne Checksums während des Builds.",[558,573,575],{"id":574},"wie-gehe-ich-mit-großen-modellgewichten-um","Wie gehe ich mit großen Modellgewichten um?",[11,577,578],{},"Laden Sie Modelle bei Start aus einer Registry oder einem Objekt-Store und cachen Sie lokal via Volume. Für schnellere Inferenz können Sie konvertierte Artefakte (ONNX/TensorRT) separat versionieren und per Init-Container bereitstellen.",[558,580,582],{"id":581},"wie-aktiviere-ich-gpu-unterstützung-in-docker","Wie aktiviere ich GPU-Unterstützung in Docker?",[11,584,585],{},"Installieren Sie das NVIDIA Container Toolkit und verwenden Sie ein passendes CUDA- oder Framework-Runtime-Image. Starten Sie den Container mit docker run --gpus all und prüfen Sie mit nvidia-smi im Container, ob die GPU sichtbar ist.",[558,587,589],{"id":588},"ist-docker-compose-für-produktion-geeignet","Ist Docker Compose für Produktion geeignet?",[11,591,592],{},"Compose eignet sich primär für Entwicklung und Staging. Für Produktion mit hohen SLAs, Rolling Updates und Autoscaling empfiehlt sich Kubernetes oder ein Managed Container Service, der GPUs orchestrieren kann.",[558,594,596],{"id":595},"wie-skaliere-ich-eine-ki-api-horizontal","Wie skaliere ich eine KI-API horizontal?",[11,598,599],{},"Nutzen Sie mehrere Replikas hinter einem Load Balancer und begrenzen Sie Concurrency pro Pod/Container. Warme Modellcaches, Batch-Inferenz und asynchrone Pipelines helfen, Durchsatz und Latenz in Balance zu halten.",[558,601,603],{"id":602},"wie-messe-ich-die-performance-meiner-container","Wie messe ich die Performance meiner Container?",[11,605,606],{},"Integrieren Sie Metriken (z. B. Prometheus-Endpoints) für Latenz, Durchsatz, Fehlerquoten, GPU-Auslastung und Speicher. Ergänzen Sie Profiling/Tracing, um Bottlenecks in Vorverarbeitung, Inferenz und Serialisierung zu identifizieren.",[558,608,610],{"id":609},"was-ist-mit-sicherheit-und-compliance","Was ist mit Sicherheit und Compliance?",[11,612,613],{},"Scannen Sie Images (SBOM, Vulnerability Scans), minimieren Sie OS-Pakete und verwenden Sie Signaturen/Policies (z. B. cosign). Secrets kommen über Secret-Management, nicht in ENV-Dateien oder Layern.",[558,615,617],{"id":616},"kann-ich-mehrere-modelle-in-einem-container-betreiben","Kann ich mehrere Modelle in einem Container betreiben?",[11,619,620],{},"Ja, aber trennen Sie Modelle logisch per Endpunkt/Route und limitieren Sie Speicherverbrauch. Für bessere Isolierung und unabhängige Skalierung empfiehlt sich ein Container pro Modell oder ein Multi-Model-Server mit klaren Ressourcengrenzen.",[21,622,624],{"id":623},"fazit","Fazit",[11,626,627],{},"Docker macht KI-Deployment berechenbar: gleiche Umgebung, klar definierte Abhängigkeiten, schnelle Rollouts — lokal, auf der GPU-Workstation und im Cluster. Mit den gezeigten Best Practices, dem Beispiel-Dockerfile und der Checkliste reduzieren Sie Risiken und beschleunigen Releases.",[11,629,630],{},"Starten Sie jetzt: Containerisieren Sie Ihren Inferenzservice anhand der Schritt-für-Schritt-Anleitung und testen Sie lokal mit Compose. Wenn Sie Unterstützung bei GPU-Tuning, Sicherheits-Reviews oder Kubernetes-Deployment wünschen, sprechen Sie uns für ein technisches Architektur-Review oder einen Entwickler-Workshop an.",{"title":224,"searchDepth":632,"depth":632,"links":633},2,[634,635,636,637,638,639,640,641,642,643,644,645,657],{"id":23,"depth":632,"text":24},{"id":46,"depth":632,"text":47},{"id":67,"depth":632,"text":68},{"id":140,"depth":632,"text":141},{"id":198,"depth":632,"text":199},{"id":243,"depth":632,"text":244},{"id":281,"depth":632,"text":282},{"id":381,"depth":632,"text":382},{"id":453,"depth":632,"text":454},{"id":513,"depth":632,"text":514},{"id":534,"depth":632,"text":535},{"id":555,"depth":632,"text":556,"children":646},[647,649,650,651,652,653,654,655,656],{"id":560,"depth":648,"text":561},3,{"id":567,"depth":648,"text":568},{"id":574,"depth":648,"text":575},{"id":581,"depth":648,"text":582},{"id":588,"depth":648,"text":589},{"id":595,"depth":648,"text":596},{"id":602,"depth":648,"text":603},{"id":609,"depth":648,"text":610},{"id":616,"depth":648,"text":617},{"id":623,"depth":632,"text":624},"2026-03-30","So containerisieren Sie KI-Anwendungen mit Docker: reproduzierbares KI-Deployment, saubere Builds, GPU-Support und Skalierung. Mit Checkliste und Beispielen.","md","/images/blog/ai-consulting-ki-beratung.png",{},true,"/blog/containerisierung-von-ki-anwendungen-docker",10,{"title":5,"description":659},"blog/containerisierung-von-ki-anwendungen-docker",[669,670,671,672,341,673],"Docker","KI Deployment","MLOps","Containerisierung","GPU","mE8KBB5woUvAwwdOObfhrX3PXgTDjv-PJLn3I_d6Aww"]