Ir al contenido principal
Español— Elegir un idioma
Menú

Seguridad y aislamiento (sandboxing)

Lección 12 de 14 Actualizado el 3 de noviembre de 2026 Desarrollador
En esta página
  1. Dar control a una IA: los riesgos
  2. Las cuatro reglas de OpenAI
  3. El principio de mínimo privilegio
  4. Aislamiento (sandboxing) con Docker
  5. Filtrado de URL
  6. Protección de datos sensibles
  7. Comprobaciones de seguridad de la API
  8. Límites de ejecución
  9. Lista de comprobación de seguridad para producción
  10. Puntos clave

Lección reescrita el 3 de noviembre de 2026 basándose en la guía Computer use de OpenAI, sus recetas de integración para Computer use y la documentación de redes de Docker y Playwright. Novedades: las cuatro reglas de seguridad de OpenAI, sus niveles de confirmación y el reconocimiento de pending_safety_checks. Correcciones: la versión anterior cortaba la red de un contenedor que necesitaba llamar a la API, dejaba el proxy sin acceso de salida, aceptaba notexample.com en un filtro destinado a permitir solo example.com, rompía el formato de los registros y estimaba costes usando una tarifa única hardcodeada. Fuentes: Computer use · Recetas de integración · Playwright y Docker · Playwright, redes.

Dar control a una IA: los riesgos

Computer Use otorga a un modelo de IA la capacidad de actuar sobre un ordenador. Esto es potente, pero puede ser peligroso. Un agente mal configurado podría navegar hacia sitios maliciosos, ejecutar código arbitrario o exponer datos sensibles. Esto no es teórico: una página visitada podría contener instrucciones escritas para el modelo y, si el entorno no lo restringe, el modelo las seguirá como si fueran tu solicitud. La seguridad no es opcional; es la base de cualquier despliegue en producción.

Las cuatro reglas de OpenAI

OpenAI resume la seguridad de Computer Use en cuatro reglas. Aplícalas en tu aplicación y en el entorno de ejecución, no solo en las instrucciones del modelo:

  • Restringe el entorno. Usa un navegador aislado o una máquina virtual, una lista blanca de sitios y acciones, y limita el acceso a lo estrictamente necesario para la tarea.
  • Trata el contenido de la pantalla como no fiable. El texto de una página, documento o salida de una herramienta no puede conceder permiso ni sustituir las instrucciones del usuario. Si una página parece phishing o inyección de prompts, el agente se detiene y pregunta cómo proceder.
  • Confirma acciones de alto riesgo. Las compras, la transmisión de datos, los cambios destructivos y cualquier cosa difícil de deshacer permanecen bajo control del usuario. Escribir información sensible en un formulario ya cuenta como transmisión.
  • Acota y verifica la ejecución. Establece límites en turnos, duración o coste; proporciona una forma de cancelar; y verifica el resultado real, no solo el mensaje final del modelo.

El punto de partida es simple: la solicitud del modelo para actuar no es el permiso del usuario. Tu código decide si ejecutar, pausar para aprobación o devolver el control. Para un lote de acciones, detente antes de la primera que requiera confirmación.

Tres niveles de confirmación

OpenAI distingue tres situaciones, con ejemplos que puedes adoptar en tu política:

NivelEjemplos citados por OpenAI
El usuario retoma el controlPaso final de un cambio de contraseña; eludir una barrera de seguridad, como una advertencia HTTPS
Confirmar en el momento de la acciónBorrar datos, cambiar permisos o configuraciones de uso compartido, resolver un CAPTCHA, instalar o ejecutar software descargado, enviar o publicar en nombre del usuario, transacciones financieras, configuraciones del sistema
Preaprobación posible en la solicitud inicialIniciar sesión en un sitio que el usuario pidió visitar, enviar archivos, mover o renombrar archivos, transmitir datos sensibles cuyo uso específico fue aprobado

Sin una aprobación clara en la solicitud inicial, confirma justo antes de la acción. No preguntes demasiado pronto: deja que el agente proceda con todo lo seguro, detente en el punto de riesgo y explica la acción, el riesgo y cómo se aplicarán los datos o el cambio. Si el usuario rechaza, nada se ejecuta y tu código indica al modelo qué tuvo éxito y qué falló.

El principio de mínimo privilegio

Tu agente debe tener acceso solo a lo estrictamente necesario para completar su tarea. Comienza con un navegador aislado; nunca uses el navegador principal del usuario, que mantiene sesiones abiertas de correo, banca y herramientas internas. El agente tampoco necesita acceso al sistema de archivos excepto para una carpeta de descargas dedicada, no necesita acceso a la red interna a menos que una aplicación empresarial lo requiera, y no debe tener derechos de administrador que puedan convertir un clic erróneo en un incidente del sistema. No montes archivos personales, credenciales ni el socket de Docker en su entorno. Por último, haz que la sesión sea efímera: borra los datos después de cada ejecución para que un flujo de trabajo nunca reutilice accidentalmente cookies o caché de la anterior.

Aislamiento (sandboxing) con Docker

Surgen dos preguntas: ¿dónde se ejecuta el navegador y dónde residen el bucle y la clave de API? La receta de Docker de OpenAI aísla un escritorio en un contenedor sin red, controlado desde el host mediante docker exec: solo el SDK en el host lee la clave. Esta es la configuración más estricta, pero solo funciona para tareas que no necesitan internet. Para otras tareas, OpenAI requiere un entorno cuya red de salida permita solo los sitios de la tarea.

Si mantienes Playwright y el agente debe navegar, puedes poner el bucle y el navegador en el mismo contenedor, siempre que se cumplan tres condiciones: un usuario sin privilegios, un navegador que no herede variables de entorno (para que no obtenga la clave) y una red de salida restringida a los sitios de la tarea y a la API.

# Imagen de Playwright para Python: navegadores y dependencias del sistema incluidos
FROM mcr.microsoft.com/playwright/python:v1.64.1-noble

WORKDIR /app

# El paquete playwright no está en la imagen: requirements.txt
# Fija playwright==1.64.1, la misma versión que la imagen
COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY src/ ./src/

# Usuario sin privilegios proporcionado por la imagen
USER pwuser

CMD ["python", "src/main.py"]

Playwright recomienda fijar la versión de la imagen. La imagen proporciona los navegadores, no la biblioteca de Python: instala la misma versión del paquete playwright. No ejecutes el contenedor como root, lo que desactiva el sandbox de Chromium. Para sitios no fiables, Playwright también recomienda su perfil seccomp, que añade las llamadas al sistema que este sandbox necesita al perfil predeterminado de Docker.

docker run --rm --init \
  --network agent-net \
  --security-opt seccomp=seccomp_profile.json \
  --ipc=host \
  --memory=2g --cpus=1.5 --pids-limit=256 \
  -e OPENAI_API_KEY \
  computer-use-agent

--init evita procesos zombi y --ipc=host, recomendado por Playwright, evita que Chromium se quede sin memoria compartida y se bloquee. Sin embargo, esa configuración comparte el espacio de nombres IPC del host con el contenedor. Si prefieres no abrirlo, aumenta la memoria compartida con --shm-size en su lugar, como hace la receta de OpenAI para su propio contenedor, y prueba con tus páginas más pesadas. Por último, -e OPENAI_API_KEY sin un valor hereda la variable de tu sesión: la clave no aparece en texto plano en la línea de comandos.

En el lado de Python, lanza el navegador con las precauciones de la receta de OpenAI (sandbox activado, entorno vacío, extensiones y acceso al sistema de archivos desactivados) y enrútalo a través del proxy de la siguiente sección, igual que el cliente de la API:

from openai import DefaultHttpx2Client, OpenAI
from playwright.sync_api import sync_playwright

PROXY = "http://agent-proxy:3128"

# Las llamadas a la API salen a través del proxy de filtrado
client = OpenAI(http_client=DefaultHttpx2Client(proxy=PROXY))

pw = sync_playwright().start()
browser = pw.chromium.launch(
    headless=True,
    chromium_sandbox=True,
    env={},  # el navegador no hereda variables de entorno, así que no la clave
    args=["--disable-extensions", "--disable-file-system"],
    proxy={"server": PROXY},
)
context = browser.new_context(
    viewport={"width": 1280, "height": 720},
    service_workers="block",  # ver filtrado de URL más abajo
)
page = context.new_page()

Restricciones de red específicas

Coloca el contenedor del agente en una red interna de Docker sin acceso externo. Un proxy Squid se une a esa red y se convierte en su única salida; el proxy también está conectado a una red normal. Todo lo que no esté explícitamente permitido no existe desde la perspectiva del agente.

# Red interna: sin acceso externo directo
docker network create --internal agent-net
# Red de salida, reservada para el proxy
docker network create sortie-proxy

# Proxy Squid (imagen mantenida por Canonical) con tu lista blanca
docker run -d --name agent-proxy --network sortie-proxy \
  -v "$PWD/squid.conf:/etc/squid/squid.conf:ro" \
  ubuntu/squid:6.6-24.04_beta

# El proxy se une a la red interna: esta es la única salida del agente
docker network connect agent-net agent-proxy
# squid.conf: permitir solo los dominios de la tarea y la API
http_port 3128
acl autorises dstdomain .example.com api.openai.com
http_access allow autorises
http_access deny all

El punto clave: el proxy está conectado a ambas redes. Si lo lanzaras solo en la red interna, no tendría acceso de salida por sí mismo. api.openai.com está en la lista porque, en esta configuración, el código del agente llama a la API desde dentro del contenedor. El navegador no lo necesita: el filtro de URL de la siguiente sección bloquea esas llamadas desde la página.

Filtrado de URL

Una segunda barrera, más fina, reside en el propio navegador. Interceptando solicitudes con page.route, compara cada URL con la lista blanca específica de la tarea (a menudo más corta que la del proxy) y aborta el resto, con un registro legible de cada bloqueo. Cuidado con la trampa de comparación de cadenas que advierte OpenAI: https://example.com.evil.test no debe pasar como https://example.com, y a la inversa, notexample.com termina en example.com. Compara el esquema, el host exacto (o un subdominio prefijado con un punto) y el puerto.

from urllib.parse import urlparse

def setup_url_filter(page, allowed_domains: list[str]):
    """Bloquea solicitudes a destinos no autorizados."""

    def autorisee(url: str) -> bool:
        parties = urlparse(url)
        hote = parties.hostname or ""
        return (
            parties.scheme == "https"
            and parties.port in (None, 443)
            and any(hote == d or hote.endswith("." + d) for d in allowed_domains)
        )

    def check_navigation(route):
        if autorisee(route.request.url):
            route.continue_()
        else:
            print(f"  BLOQUÉ : {route.request.url}")
            route.abort()

    page.route("**/*", check_navigation)


# El navegador solo necesita los sitios de la tarea: las llamadas a la API vienen de tu código Python, no de la página.
setup_url_filter(page, ["example.com"])

Esta capa complementa al proxy; no lo sustituye. Playwright señala que page.route no intercepta solicitudes gestionadas por un service worker, de ahí service_workers="block" en el contexto, y los WebSockets usan un mecanismo diferente (page.route_web_socket). El filtrado de red sigue siendo tu barrera principal.

Protección de datos sensibles

Ofuscar información en capturas de pantalla

Cada captura de pantalla va a la API: cualquier cosa visible en la pantalla sale de tu infraestructura. OpenAI recomienda mantener las credenciales fuera del texto de la página y de las capturas. Si la pantalla contiene datos sensibles, ofúscalos antes de enviar la captura al modelo. Un rectángulo negro sobre áreas conocidas es suficiente, siempre que conozcas sus coordenadas; por eso estandarizar el tamaño del viewport, como se cubrió anteriormente en este curso, ayuda. La ofuscación no cambia el tamaño de la imagen: las coordenadas devueltas por el modelo siguen siendo válidas.

import io

from PIL import Image, ImageDraw

def mask_sensitive_areas(screenshot_bytes: bytes, regions: list) -> bytes:
    """Ofusca áreas sensibles en una captura PNG."""
    img = Image.open(io.BytesIO(screenshot_bytes))
    draw = ImageDraw.Draw(img)

    for x, y, w, h in regions:
        draw.rectangle([x, y, x + w, y + h], fill="black")

    buffer = io.BytesIO()
    img.save(buffer, format="PNG")
    return buffer.getvalue()

Saber qué ocurre con las capturas

Las respuestas de la Responses API se almacenan por defecto: eso es lo que permite el encadenamiento mediante previous_response_id. Con store: false, debes reenviar tú mismo los elementos de turnos anteriores. OpenAI también señala que store: false no elimina todas las formas de retención, y las imágenes de entrada tienen sus propias excepciones: lee sus controles de datos antes de enviar pantallas que contengan datos personales.

Nunca registrar datos sensibles

El mismo razonamiento se aplica a los registros, que a menudo sobreviven mucho más que las capturas. Un filtro de registros reescribe patrones de riesgo antes de escribir: asignaciones de contraseñas, claves de API de OpenAI que comienzan por sk- y secuencias de 16 dígitos que se parecen a números de tarjeta. El filtro actúa sobre el mensaje final, por lo que también captura lo que registraste sin pensar.

import logging
import re

class SensitiveFilter(logging.Filter):
    """Ofusca datos sensibles antes de escribir los registros."""

    PATTERNS = [
        (re.compile(r"password['\"]?\s*[:=]\s*['\"]?[^\s,}]+", re.IGNORECASE), "password=***"),
        (re.compile(r"\bsk-[A-Za-z0-9_-]{20,}"), "sk-***"),
        (re.compile(r"\b\d{16}\b"), "****-****-****-****"),
    ]

    def filter(self, record):
        msg = record.getMessage()
        for pattern, replacement in self.PATTERNS:
            msg = pattern.sub(replacement, msg)
        record.msg = msg
        record.args = None  # el mensaje ya está formateado: no reformatearlo
        return True


handler = logging.StreamHandler()
handler.addFilter(SensitiveFilter())  # en el handler, también ve los logger hijos
logging.basicConfig(level=logging.INFO, handlers=[handler])

Dos detalles marcan la diferencia. Establecer record.args en None es esencial: de lo contrario, el mensaje ya formateado se volvería a formatear con sus argumentos, y cualquier % en una URL rompería la escritura. Y un filtro en el handler se aplica a todo lo que escribe, mientras que un filtro en un logger ignora los mensajes de sus logger hijos.

Comprobaciones de seguridad de la API

Cada computer_call lleva un campo pending_safety_checks: la lista de comprobaciones de seguridad que la API te pide gestionar antes de ejecutar las acciones, cada una con un id, code y message. El ejemplo oficial de OpenAI se detiene tan pronto como no está vacío. Si tu aplicación puede tener un humano que valide estos casos, reconócelos explícitamente devolviéndolos en acknowledged_safety_checks, junto con la siguiente captura de pantalla. El modelo no puede conceder esta aprobación en tu nombre, y el reconocimiento ocurre antes de la ejecución de la acción, nunca después.

def valider_verifications(appel) -> list[dict]:
    """Envía las comprobaciones pendientes a un operador; rechaza por defecto."""
    if not appel.pending_safety_checks:
        return []
    for verification in appel.pending_safety_checks:
        print(f"Vérification de sécurité [{verification.code}] : {verification.message}")
    if input("Autoriser ces actions ? [o/N] ").strip().lower() != "o":
        raise RuntimeError("Actions refusées par l'opérateur")
    return [
        {"id": v.id, "code": v.code, "message": v.message}
        for v in appel.pending_safety_checks
    ]


# En el bucle, antes de ejecutar acciones:
acquittees = valider_verifications(appel)
executer_actions(page, appel.actions)
sortie = {
    "type": "computer_call_output",
    "call_id": appel.call_id,
    "output": {
        "type": "computer_screenshot",
        "image_url": f"data:image/png;base64,{capturer_ecran(page)}",
        "detail": "original",
    },
}
if acquittees:
    sortie["acknowledged_safety_checks"] = acquittees

Límites de ejecución

También existe el riesgo más común: un agente que se descontrola sin romper nada, pero que funciona durante dos horas y quema tu presupuesto. La clase ExecutionLimits impone tres techos (turnos, duración y coste estimado) y lanza una excepción tan pronto como se alcanza uno. Las tarifas no están hardcodeadas: obténlas del modelo que estás usando en la página de precios de OpenAI, ya que varían según el modelo.

import time

class ExecutionLimits:
    """Impone techos de turnos, duración y coste al agente."""

    def __init__(
        self,
        prix_entree_par_million: float,  # tarifas para el modelo en uso
        prix_sortie_par_million: float,
        max_tours: int = 50,
        max_duree_s: int = 300,
        max_cout_usd: float = 5.0,
    ):
        self.prix_entree = prix_entree_par_million
        self.prix_sortie = prix_sortie_par_million
        self.max_tours = max_tours
        self.max_duree = max_duree_s
        self.max_cout = max_cout_usd
        self.debut = time.monotonic()
        self.tours = 0
        self.cout = 0.0

    def verifier(self):
        """Llama antes de cada solicitud: lanza un error si se alcanza un techo."""
        if self.tours >= self.max_tours:
            raise RuntimeError(f"Limite de tours atteinte ({self.max_tours})")
        if time.monotonic() - self.debut >= self.max_duree:
            raise RuntimeError(f"Durée maximale dépassée ({self.max_duree} s)")
        if self.cout >= self.max_cout:
            raise RuntimeError(f"Budget dépassé ({self.cout:.2f} $)")

    def compter(self, response):
        """Llama después de cada respuesta: acumula turnos y coste estimado."""
        self.tours += 1
        self.cout += response.usage.input_tokens / 1_000_000 * self.prix_entree
        self.cout += response.usage.output_tokens / 1_000_000 * self.prix_sortie

Esto es solo una estimación: sobreestima los tokens de entrada servidos desde la caché del prompt, que se facturan a una tarifa reducida, e ignora cualquier entorno alojado, que se factura por separado. Compáralo regularmente con el uso real de tu proyecto. Establece techos por flujo de trabajo: una prueba E2E de 30 segundos y una entrada de facturas de una hora no requieren los mismos umbrales.

Lista de comprobación de seguridad para producción

Antes de desplegar un agente de Computer Use en producción, verifica:

  • Navegador o escritorio aislado (contenedor o máquina virtual), usuario sin privilegios
  • Red de salida limitada a los sitios de la tarea y a la API si el bucle se ejecuta en el mismo entorno
  • Filtro de URL que compara esquema, host y puerto; service workers bloqueados
  • Clave de API mantenida fuera del código y fuera del alcance del navegador (env={})
  • Contenido de la pantalla tratado como no fiable: detener y escalar ante el primer signo de inyección
  • Confirmación humana antes de compras, envíos, borrados e introducción de datos sensibles
  • pending_safety_checks nunca reconocido sin validación humana
  • Límites de turnos, duración y coste
  • Registros filtrados, capturas no retenidas (o cifradas)
  • Sin archivos personales, credenciales ni socket de Docker montados en el entorno
  • Resultado verificado en la aplicación antes de anunciar el éxito
  • Mecanismo de parada de emergencia (kill switch)

El último punto es el que se olvida con más frecuencia, pero es el único que ayuda cuando todos los demás han fallado. Un kill switch es una forma de interrumpir el agente inmediatamente, sin esperar a que alcance uno de sus límites: un archivo STOP que el bucle comprueba en cada iteración, un docker stop en el contenedor o una bandera leída desde una variable compartida. Pruébalo antes de la producción, no el día que lo necesites.

Puntos clave

  • Las cuatro reglas de OpenAI: restringir el entorno, tratar la pantalla como no fiable, confirmar acciones de alto riesgo y acotar y verificar la ejecución
  • La solicitud del modelo para actuar no es un permiso: tu código ejecuta, suspende o devuelve el control
  • Aísla el navegador (usuario sin privilegios, perfil seccomp) y permite el tráfico de salida solo a los sitios de la tarea
  • Filtra las URL comparando esquema, host y puerto; nunca por un simple prefijo o sufijo de cadena
  • Reconoce pending_safety_checks solo después de la validación humana
  • Impón límites de turnos, duración y coste, y verifica el resultado real