Ejecutar agentes de IA con Docker

IRC-Mania Die Seite rund um Sicherheit und Programmierung

Internet, Sicherheit , Internet Relay Chat

Gesponsert

Qué cubre este artículo sobre Docker para agentes

• Cómo ejecutar agentes de IA con Docker.
• Por qué Docker es importante para despliegues de agentes.
• Docker-Compose para stacks de agentes completos.
• Ejemplos prácticos con Ollama + Agent + Tools en contenedores.
• Buenas prácticas para aislamiento, escalado y mantenimiento.

Introducción: Docker para agentes explicado

Docker containeriza tu stack de agentes: Ollama en un contenedor, código del agente en otro, base de datos en un tercero. Todo aislado, reproducible, portátil. Para los agentes significa: entorno consistente, despliegue sencillo, aislamiento limpio.

Este artículo está dirigido a usuarios que desean ejecutar agentes con Docker. Encontrarás conceptos básicos en Docker y Ejecutar agentes de IA localmente.

¿Por qué necesito Docker para agentes?

Imagina que tu agente necesita Ollama, una base de datos, un Vector-Store y el código del agente. Sin Docker: instala todo manualmente, configura, espera que funcione. Con Docker: docker-compose up, todo se ejecuta, aislado, reproducible.

Docker para agentes en pocas palabras

Docker = contenedor para cada componente (Ollama, Agent, BD, Vector-Store). Docker-Compose orquesta todos los contenedores. Aislado, reproducible, portátil.

La idea central es: cada componente en un contenedor, todos juntos como stack.

¿Para quién es este artículo?

• DevOps que despliegan agentes.
• Self-hosters que ejecutan agentes en contenedores.
• Desarrolladores que quieren entornos reproducibles.
• Equipos que desean estandarizar stacks de agentes.

Términos importantes

• Docker - Plataforma de contenedores. Útil para: aislamiento.
• Docker-Compose - Multi-contenedor. Útil para: stacks.
• Ollama - Servidor de modelos. Útil para: en contenedor.
• Kubernetes - Orquestación. Útil para: despliegues grandes.

Docker-Compose para stack de agentes

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 (opcional)
  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

Dockerfile del agente

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"]

Ejemplo práctico: Agente en 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()

Comunicación entre contenedores

# El agente se comunica con Ollama a través de la red Docker
OLLAMA_URL = "http://ollama:11434"  # Service-Name como hostname

# ¡No localhost! La red Docker usa nombres de servicio
# ollama = nombre del contenedor
# 11434 = puerto en el contenedor

Notas de seguridad

• Aislamiento de contenedores: cada contenedor está aislado. Un contenedor comprometido no afecta a los demás.
• Red: la comunicación interna usa la red Docker, sin exponerla.
• Secretos: no incluyas secretos en la imagen. Usa variables de entorno o sistemas de gestión de secretos.
• Recursos: establece límites de CPU y memoria para evitar que un contenedor agote todos los recursos.
• Actualizaciones: actualiza los contenedores regularmente. Descarga nuevas imágenes.

Tropiezos típicos

• Localhost vs. nombre de servicio: los contenedores se comunican a través de nombres de servicio, no localhost.
• GPU en contenedor: para GPU necesitas nvidia-docker o —gpus all. No es trivial.
• Persistencia de datos: los datos del contenedor se pierden al reiniciar. Usa volumes para persistencia.
• Red: los contenedores necesitan una red común para comunicarse.
• Logs: los logs de contenedores pueden ser grandes. Configura rotación de logs.

Enlaces relacionados

• Docker - Conceptos básicos de Docker.
• Docker-Compose - Multi-contenedor.
• Ollama Docker - Ollama en Docker.
• Ejecutar agentes de IA localmente - Descripción general.
• Kubernetes - Para despliegues grandes.

Puntos clave:

• Docker = contenedor para cada componente del agente.
• Docker-Compose orquesta Ollama, Agent, BD, Vector-Store.
• Aislado, reproducible, portátil.
• Nombres de servicio para comunicación entre contenedores.
• Para producción: Docker es el estándar.

FAQ

Fuentes y lecturas adicionales

• Docker - Sitio oficial.
• Docker Compose - Documentación.
• Ollama Docker - Ollama en Docker.

Premium VPS Hosting

Schnelle und sichere VPS Server

Gesponsert