0Pricing
AI Agents · Lección

Sandboxes de agentes basados en Docker

Creación de contenedores desechables para ejecutar código generado por agentes.

Sandboxes de agentes basados en Docker es una lección gratuita de AI Agents en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de AI Agents, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de AI Agents incluye 4 lecciones en total.

¿Por qué los agentes necesitan sandboxes?

Cuando un agente ejecuta código escrito por un LLM, ese código es no confiable. Puede intentar leer archivos confidenciales, establecer conexiones salientes o consumir recursos ilimitados.

Un sandbox aísla la ejecución del código para que los daños queden contenidos, independientemente de lo que haga el código.

Docker como capa de sandbox

Los contenedores Docker proporcionan un aislamiento ligero a nivel del sistema operativo. Cada fragmento de código se ejecuta dentro de un contenedor nuevo con límites explícitos de recursos y restricciones de red.

El SDK de Python para docker permite crear y destruir contenedores mediante programación desde el interior del agente.

import docker

client = docker.from_env()
print(client.version()['Version'])

Ejecución básica de un contenedor

client.containers.run() inicia un contenedor, ejecuta un comando y devuelve la salida como bytes. Establecer auto_remove=True elimina el contenedor después de que finaliza.

import docker

client = docker.from_env()

output = client.containers.run(
    'python:3.12-slim',
    'python -c "print(2 + 2)"',
    auto_remove=True
)

print(output.decode())  # '4'

Límites de memoria y CPU

Sin límites, un script descontrolado puede agotar la memoria del host. Pase mem_limit y nano_cpus para limitar el uso de recursos.

Si el proceso supera mem_limit, el contenedor finaliza por falta de memoria (OOM) y se lanza una excepción.

output = client.containers.run(
    'python:3.12-slim',
    'python -c "x = [0]*10**8"',   # tries to allocate ~800 MB
    mem_limit='256m',
    nano_cpus=1_000_000_000,        # 1 CPU
    auto_remove=True
)
# Raises docker.errors.ContainerError if OOM-killed

Deshabilitar la red

Establecer network_disabled=True impide que el contenedor realice llamadas de red salientes o entrantes; incluso fallan las consultas DNS. Esto evita la exfiltración de datos y las conexiones de retorno de comando y control.

output = client.containers.run(
    'python:3.12-slim',
    'python -c "import urllib.request; urllib.request.urlopen(\"http://example.com\")"',
    network_disabled=True,
    auto_remove=True
)
# Raises ContainerError: network unreachable

Tiempo de espera de ejecución

Un bucle infinito dentro del sandbox bloquearía su agente para siempre. Pase un timeout (en segundos) a containers.run() para que Docker elimine el contenedor cuando se alcance el límite de tiempo.

import docker
from docker.errors import ContainerError

client = docker.from_env()

try:
    output = client.containers.run(
        'python:3.12-slim',
        'python -c "while True: pass"',
        mem_limit='256m',
        network_disabled=True,
        auto_remove=True,
        timeout=30
    )
except Exception as e:
    print(f'Sandbox timeout or error: {e}')

Función auxiliar completa del sandbox

Envolver toda la configuración en una función reutilizable facilita llamarla desde las herramientas del agente. Devuelva tanto stdout como un indicador de estado para que el agente pueda actuar ante los errores.

import docker

client = docker.from_env()

def run_in_sandbox(code: str, timeout: int = 30) -> dict:
    cmd = f'python -c "{code.replace(chr(34), chr(39))}"'
    try:
        out = client.containers.run(
            'python:3.12-slim',
            cmd,
            mem_limit='256m',
            nano_cpus=500_000_000,
            network_disabled=True,
            auto_remove=True,
            timeout=timeout
        )
        return {'success': True, 'output': out.decode()}
    except Exception as e:
        return {'success': False, 'error': str(e)}

Montaje de un espacio de trabajo temporal

Si el código necesita leer archivos de entrada o escribir archivos de salida, monte un directorio temporal del host en el contenedor. Use volumes con el modo 'rw' para el espacio de trabajo y no monte nada más.

import tempfile, os

with tempfile.TemporaryDirectory() as tmpdir:
    # Write input data
    with open(os.path.join(tmpdir, 'data.txt'), 'w') as f:
        f.write('hello sandbox')

    output = client.containers.run(
        'python:3.12-slim',
        'python -c "print(open(\"/workspace/data.txt\").read())"',
        volumes={tmpdir: {'bind': '/workspace', 'mode': 'rw'}},
        mem_limit='256m',
        network_disabled=True,
        auto_remove=True
    )
    print(output.decode())

Sistema de archivos de solo lectura

Establezca read_only=True para montar como solo lectura el sistema de archivos raíz del contenedor. El código solo puede escribir en los volúmenes montados explícitamente. Esto evita las escrituras en /etc, /usr u otras rutas sensibles dentro de la imagen.

import tempfile

with tempfile.TemporaryDirectory() as tmpdir:
    output = client.containers.run(
        'python:3.12-slim',
        'python -c "open(\"/output/result.txt\",\"w\").write(str(1+1))"',
        volumes={tmpdir: {'bind': '/output', 'mode': 'rw'}},
        read_only=True,
        mem_limit='256m',
        network_disabled=True,
        auto_remove=True
    )
    print(open(f'{tmpdir}/result.txt').read())  # '2'

Integración del sandbox en una herramienta de agente

Registre el ejecutor del sandbox como una herramienta que el LLM pueda invocar. El agente genera código, la herramienta lo ejecuta de forma aislada y la salida vuelve al siguiente paso de razonamiento.

tools = [
    {
        'type': 'function',
        'function': {
            'name': 'execute_python',
            'description': 'Run a Python snippet in an isolated Docker sandbox.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'string', 'description': 'Python code to execute.'}
                },
                'required': ['code']
            }
        }
    }
]

def handle_tool_call(name, args):
    if name == 'execute_python':
        return run_in_sandbox(args['code'])

Gestión de errores y limpieza

Los contenedores pueden no iniciarse si el demonio de Docker no está ejecutándose o si la imagen no está en la caché. Gestione siempre docker.errors.DockerException y asegúrese de que los contenedores se limpien incluso cuando se produzcan excepciones.

from docker.errors import DockerException, ImageNotFound

def safe_run(code: str) -> dict:
    try:
        return run_in_sandbox(code)
    except ImageNotFound:
        # Pull the image first
        client.images.pull('python:3.12-slim')
        return run_in_sandbox(code)
    except DockerException as e:
        return {'success': False, 'error': f'Docker unavailable: {e}'}
    except Exception as e:
        return {'success': False, 'error': str(e)}

¿Qué configuración del sandbox es más importante para evitar la exfiltración de datos?

Un sandbox de agente debe impedir que el código ejecutado envíe datos robados a un servidor externo. ¿Qué parámetro de Docker bloquea directamente el acceso a la red saliente?

Resumen del sandbox de Docker

Los sandboxes basados en Docker proporcionan a los agentes un entorno de ejecución seguro al combinar límites de memoria y CPU, aislamiento de red, tiempos de espera de ejecución y sistemas de archivos de solo lectura.

Envuelva esta configuración en una función auxiliar reutilizable y expóngala como herramienta del agente para permitir que el LLM ejecute código generado de forma segura sin poner en riesgo el sistema host.

Preguntas frecuentes

¿La lección «Sandboxes de agentes basados en Docker» es gratis?

Sí — el texto completo de «Sandboxes de agentes basados en Docker» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de AI Agents, actualiza a CoddyKit PRO. El curso de AI Agents incluye 4 lecciones en total.

¿Qué aprenderé en «Sandboxes de agentes basados en Docker»?

Creación de contenedores desechables para ejecutar código generado por agentes. Practicas AI Agents con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar AI Agents?

No se requiere experiencia previa. AI Agents en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.

¿Cuánto tiempo toma la lección «Sandboxes de agentes basados en Docker»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de AI Agents?

Sí. Cada lección de AI Agents incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

  1. Sandboxes de agentes basados en Docker
  2. Aislamiento mediante máquinas virtuales para agentes de código de alta seguridad
  3. E2B y servicios de sandbox en la nube
  4. Políticas de seguridad para la ejecución de código
← Volver a AI Agents