KI-Agenten mit Docker betreiben

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Was dieser Artikel über Docker für Agenten behandelt

• Wie Du KI-Agenten mit Docker betreibst.
• Warum Docker für Agenten-Deployments wichtig ist.
• Docker-Compose für komplette Agenten-Stacks.
• Praxisbeispiele für Ollama + Agent + Tools in Containern.
• Best Practices für Isolation, Skalierung und Wartung.

Einleitung: Docker für Agenten verständlich erklärt

Docker containerisiert Deine Agenten-Stack: Ollama in einem Container, Agent-Code in einem anderen, Datenbank in einem dritten. Alles isoliert, reproduzierbar, portierbar. Für Agenten bedeutet das: Konsistente Umgebung, einfaches Deployment, saubere Isolation.

Dieser Artikel richtet sich an Anwender, die Agenten mit Docker betreiben wollen. Grundlagen findest Du in Docker und KI-Agenten lokal betreiben.

Warum brauche ich Docker für Agenten?

Stell Dir vor, Dein Agent braucht Ollama, eine Datenbank, ein Vector-Store und den Agent-Code. Ohne Docker: Installiere alles manuell, konfiguriere, hoffe dass es funktioniert. Mit Docker: docker-compose up, alles läuft, isoliert, reproduzierbar.

Docker für Agenten kurz erklärt

Docker = Container für jede Komponente (Ollama, Agent, DB, Vector-Store). Docker-Compose orchestriert alle Container. Isoliert, reproduzierbar, portierbar.

Der Kerngedanke lautet: Jede Komponente in einem Container, alle zusammen als Stack.

Für wen ist dieser Artikel gedacht?

• DevOps, die Agenten deployen.
• Self-Hoster, die Agenten in Containern betreiben.
• Entwickler, die reproduzierbare Umgebungen wollen.
• Teams, die Agenten-Stacks standardisieren.

Wichtige Begriffe

• Docker - Container-Plattform. Wann nützlich: für Isolation.
• Docker-Compose - Multi-Container. Wann nützlich: für Stacks.
• Ollama - Modellserver. Wann nützlich: im Container.
• Kubernetes - Orchestrierung. Wann nützlich: für große Deployments.

Docker-Compose für Agenten-Stack

version: "3.8"

services:
  # Modellserver
  ollama:
    image: ollama/ollama:latest
    ports:
      - "11434:11434"
    volumes:
      - ollama_data:/root/.ollama
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    networks:
      - agent_net

  # Vektordatenbank
  qdrant:
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"
    volumes:
      - qdrant_data:/qdrant/storage
    networks:
      - agent_net

  # Agent
  agent:
    build: ./agent
    ports:
      - "8000:8000"
    environment:
      - OLLAMA_URL=http://ollama:11434
      - QDRANT_URL=http://qdrant:6333
    depends_on:
      - ollama
      - qdrant
    networks:
      - agent_net

  # Workflow-Tool (optional)
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5678:5678"
    volumes:
      - n8n_data:/home/node/.n8n
    networks:
      - agent_net

volumes:
  ollama_data:
  qdrant_data:
  n8n_data:

networks:
  agent_net:
    driver: bridge

Agent-Dockerfile

FROM python:3.11-slim

WORKDIR /app

# Dependencies
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

# Agent-Code
COPY . .

# Health check
HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
    CMD python -c "import requests; requests.get('http://localhost:8000/health')"

# Start
CMD ["python", "agent.py"]

Praxisbeispiel: Agent in Docker

# agent.py
import os
import requests
from fastapi import FastAPI

app = FastAPI()

OLLAMA_URL = os.getenv("OLLAMA_URL", "http://ollama:11434")
QDRANT_URL = os.getenv("QDRANT_URL", "http://qdrant:6333")

@app.get("/health")
def health():
    return {"status": "ok"}

@app.post("/agent")
async def run_agent(task: dict):
    """Agent-Endpoint"""
    # Agent-Logik hier
    response = requests.post(f"{OLLAMA_URL}/api/chat", json={
        "model": "llama3.1",
        "messages": [{"role": "user", "content": task["task"]}],
        "tools": tools,
        "stream": False
    })
    return response.json()

Multi-Container-Kommunikation

# Agent kommuniziert mit Ollama über Docker-Netzwerk
OLLAMA_URL = "http://ollama:11434"  # Service-Name als Hostname

# Nicht localhost! Docker-Netzwerk nutzt Service-Namen
# ollama = Container-Name
# 11434 = Port im Container

Sicherheitshinweise

• Container-Isolation: Jeder Container ist isoliert. Ein kompromittierter Container betrifft nicht alle.
• Netzwerk: Interne Kommunikation über Docker-Netzwerk, nicht exponieren.
• Secrets: Keine Secrets im Image. Environment-Variablen oder Secrets-Management.
• Ressourcen: CPU/Memory-Limits setzen, damit ein Container nicht alle Ressourcen frisst.
• Updates: Container regelmäßig aktualisieren. Neue Images pullen.

Typische Stolpersteine

• Localhost vs. Service-Name: Container kommunizieren über Service-Namen, nicht localhost.
• GPU im Container: Für GPU: nvidia-docker oder —gpus all. Nicht trivial.
• Datenpersistenz: Container-Daten gehen verloren bei Neustart. Volumes für Persistenz.
• Netzwerk: Container brauchen gemeinsames Netzwerk für Kommunikation.
• Logs: Container-Logs können groß werden. Log-Rotation konfigurieren.

Weiterführende Links

• Docker - Docker-Grundlagen.
• Docker-Compose - Multi-Container.
• Ollama Docker - Ollama in Docker.
• KI-Agenten lokal betreiben - Übersicht.
• Kubernetes - Für große Deployments.

Key Takeaways:

• Docker = Container für jede Agenten-Komponente.
• Docker-Compose orchestriert Ollama, Agent, DB, Vector-Store.
• Isoliert, reproduzierbar, portierbar.
• Service-Namen für Container-Kommunikation.
• Für Produktion: Docker ist Standard.

FAQ

Quellen und weiterführende Literatur

• Docker - Offizielle Website.
• Docker Compose - Dokumentation.
• Ollama Docker - Ollama in Docker.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert