Tailored news hub
home›Sistemas Agénticos›

Cómo sandboxed Potencia Entornos de Desarrollo Multi-inquilino con IA

Descubre cómo el motor de código abierto sandboxed crea entornos aislados, ejecuta agentes de codificación y proporciona URLs en vivo para aplicaciones, todo desde un único servidor Go.

Cómo sandboxed Potencia Entornos de Desarrollo Multi-inquilino con IA
#Agentes#Automatización#Código Abierto#Herramientas Dev#Sandboxing

sandboxed es el motor de código abierto que impulsa constructores de aplicaciones de IA, transformando un servidor en una plataforma multi-inquilino. Ofrece entornos de desarrollo en la nube aislados, agentes de codificación integrados y enlaces de vista previa. Crea contenedores Linux privados, ejecuta agentes de codificación (OpenCode o Claude Code) y asigna URLs en vivo, con persistencia de archivos y gestión de inactividad.

Qué hace sandboxed

sandboxed es el motor de código abierto que proporciona a cada usuario un entorno aislado tipo sandbox – un contenedor Linux privado con su propio sistema de archivos, límites de memoria y medidas de seguridad reforzadas. Una sola petición HTTP crea el sandbox, ejecuta un agente de codificación de IA (OpenCode o Claude Code) en su interior y expone una URL de vista previa en vivo.

Los sandboxes se suspenden al estar inactivos, liberando memoria, pero los espacios de trabajo persisten en disco. La siguiente petición reactiva automáticamente el contenedor y sirve la aplicación. Esta densidad permite que un solo servidor ejecute muchos inquilinos sin necesidad de máquinas virtuales siempre activas.

El plano de control es un único binario Go que interactúa con Docker mediante la CLI, con Traefik para el enrutamiento y TLS, y SQLite para el estado persistente – sin Kubernetes, base de datos separada ni cola de mensajes.

Úsalo si estás construyendo un constructor de aplicaciones de IA multiinquilino, un playground de programación o una plataforma de vista previa por usuario. Descártalo si solo necesitas uno o dos contenedores – un script de shell o docker run es más simple.

Instalación

Necesitas un servidor Linux con Docker Engine y el plugin de Compose. El script de instalación verifica Docker, construye la imagen base del sandbox y el plano de control, y luego inicia todo el conjunto.

Clona el repositorio: git clone https://github.com/tastyeffectco/sandboxes.git 2. Entra en el directorio y ejecuta el instalador: cd sandboxes && ./install.sh 3. Verifica que la API esté funcionando: curl http://127.0.0.1:9090/healthz → ok

El script escribe un archivo .env con valores predeterminados. Al finalizar, la API del plano de control está lista en http://127.0.0.1:9090.

git clone https://github.com/tastyeffectco/sandboxes.git
cd sandboxes
./install.sh

# Verify
curl http://127.0.0.1:9090/healthz
# → ok

Flujo de trabajo básico

  1. Crea un sandbox – especifica los puertos que necesita tu aplicación (ej., {"ports":[3000]}). La API devuelve un ULID único.
  2. Ejecuta un agente de codificación – Haz POST con una tarea que incluya un prompt y un nombre de agente (opencode o claude). El agente trabaja en ~/workspace/app.
  3. Transmite el progreso – Los Eventos Enviados por el Servidor (SSE) te permiten ver la salida del agente en tiempo real.
  4. Abre la vista previa – La aplicación está disponible instantáneamente en http://s-<id>-3000.preview.localhost. Para dominios de producción, HTTPS está disponible tras la configuración TLS.

Puedes inyectar claves API en el momento de la creación mediante el campo env (ej., ANTHROPIC_API_KEY). También puedes ejecutar cualquier comando directamente con POST /sandbox/{id}/exec y obtener un enlace de vista previa.

API=http://127.0.0.1:9090
# Create sandbox
ID=$(curl -s -XPOST $API/sandbox -H 'content-type: application/json' \
       -d '{"ports":[3000]}' | sed -E 's/.*"id":"([^"]+)".*/\1/')
echo "sandbox: $ID"

# Run a coding agent
curl -s -XPOST $API/v1/sandboxes/$ID/tasks -H 'content-type: application/json' \
  -d '{"prompt":"create a Vite app that shows a todo list and run it on port 3000","agent":"opencode"}'

# Stream events (replace <taskId>)
# curl -N $API/v1/sandboxes/$ID/tasks/<taskId>/events

# Preview URL: http://s-$ID-3000.preview.localhost

Resumen de la API y configuración

La API se ejecuta en http://127.0.0.1:9090. La autenticación está deshabilitada por defecto; actívala para producción con SANDBOXD_API_AUTH_DISABLED=false y define los tokens.

Endpoints clave:

  • POST /sandbox – crea un nuevo sandbox
  • POST /sandbox/{id}/exec – ejecuta un comando
  • POST /v1/sandboxes/{id}/tasks – inicia un agente de codificación
  • GET /v1/sandboxes/{id}/tasks/{taskId}/events – flujo de progreso SSE
  • DELETE /sandbox/{id} – detener/limpiar

La configuración reside en .env (plantilla .env.example). Variables importantes:

  • PREVIEW_DOMAIN – dominio para las URLs de vista previa
  • HTTP_PORT – puerto HTTP de Traefik
  • SANDBOXED_DATA_DIR – directorio de almacenamiento del espacio de trabajo
  • SANDBOXD_API_AUTH_DISABLED – alternar autenticación
  • SANDBOXD_API_TOKENS – pares nombre:secreto

Para TLS en producción, apunta *.preview.tudominio.com al servidor, establece PREVIEW_TLS=true y configura un certificado wildcard de Let's Encrypt.

Limitaciones y buenas prácticas

Limitaciones clave (calidad beta):

  • Aislamiento por contenedores, no VMs – no es de fiar para ejecutar código desconocido; añade gVisor o Firecracker si es necesario.
  • Autenticación de la API desactivada por defecto – debe habilitarse antes de la exposición pública.
  • Los enlaces de vista previa son públicos; sin control de acceso incorporado.
  • Sin cuotas de disco, salida abierta, solo servidor único, plano de control con permisos equivalentes a root.
  • El sistema está en fase beta; puedes encontrar asperezas.

Buenas prácticas:

  • Comienza con los valores locales predeterminados para desarrollo.
  • Habilita la autenticación de la API antes de ponerlo en producción – establece tokens fuertes.
  • Para producción, configura TLS con un wildcard de Let's Encrypt.
  • Inyecta las claves API al crear el sandbox, no en la imagen base.
  • Mantén el servidor seguro; el plano de control tiene acceso al socket de Docker.
  • Al escalar, prioriza un aislamiento más fuerte y un plan multinodo.
  • Lee el código fuente – el binario Go y SQLite son deliberadamente pequeños.

Procedimientos destacados

  • Desinstalación: ./uninstall.sh detiene el stack; añade --images para eliminar las imágenes Docker, --data para borrar todos los espacios de trabajo (con confirmación), o --all para una limpieza completa. Solo se ven afectados los objetos gestionados.
  • Suspensión por inactividad / activación bajo demanda: Tras un período de inactividad, los sandboxes se detienen pero los espacios de trabajo persisten. La siguiente solicitud de previsualización reinicia el contenedor de forma transparente, muestra una página de calentamiento y luego sirve la aplicación.
  • Reconciliación al arranque: Al iniciar, el plano de control reconcilia el estado de SQLite con Docker, reiniciando los sandboxes previstos y limpiando los huérfanos. Un reinicio del host no provoca la pérdida de definiciones ni rutas.
  • Ejecución de agentes: La imagen del sandbox incluye las CLIs OpenCode y Claude Code. Una tarea POST ejecuta el agente en modo headless, transmite la salida y captura el resultado. Pasa las claves API del proveedor mediante variables de entorno en el momento de la creación.
Artículos Relacionados