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

Aislamiento (Sandboxing) y Límites de Seguridad

Lección 11 de 20 Actualizado el 2 de noviembre de 2026 Desarrollador
En esta página
  1. Aislamiento (Sandboxing) y Límites de Seguridad
  2. Arquitectura del Sandbox
  3. Qué hay disponible
  4. Qué está limitado
  5. Seguridad de los datos
  6. Gestión de errores de ejecución
  7. Buenas prácticas
  8. Puntos clave

Actualizado el 2 de noviembre de 2026 según la documentación de OpenAI: la herramienta Code Interpreter requiere ahora un parámetro container (añadido a todos los ejemplos). La red del contenedor, cerrada por defecto, puede abrirse ahora a una lista blanca de dominios. Las reglas del ciclo de vida del contenedor (memoria, caducidad, reutilización) siguen la guía oficial. Los archivos adjuntos a un mensaje se suben con el propósito user_data, tal como recomienda OpenAI para las entradas del modelo. Fuentes: Code Interpreter · Acceso a la red del contenedor · API de contenedores · API de archivos.

Aislamiento (Sandboxing) y Límites de Seguridad

Los límites del entorno aislado (sandbox) no son errores que debas sortear: son las propiedades que hacen aceptable la ejecución de código generado. Un entorno aislado de la red, con una vida útil corta y límites de recursos, no puede exfiltrar tus datos, dejar estado acumulado indefinidamente ni consumir recursos sin límite.

Conocer estos límites de antemano te evita depurar lo imposible. Las tres preguntas recurrentes —por qué falla pip install, por qué mi archivo desapareció entre llamadas, por qué mi procesamiento se bloquea con un archivo grande— tienen respuesta a continuación, y ninguna se debe a un error.

Arquitectura del Sandbox

Code Interpreter ejecuta el código en un contenedor, una máquina virtual aislada alojada por OpenAI, con las siguientes propiedades:

  • Red cerrada por defecto: sin solicitudes salientes, excepto para una lista blanca de dominios explícitamente abierta (ver más abajo).
  • Vida útil corta: el contenedor caduca tras 20 minutos de inactividad y todo su contenido se borra entonces.
  • Memoria limitada: 1 GB por defecto, o 4, 16 o 64 GB bajo petición (memory_limit), con su propia tarifa para cada nivel.
from openai import OpenAI

client = OpenAI()

# Sin una lista blanca, la descarga fallará: no hay acceso a la red
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Descarga el contenido de https://example.com usando requests",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# El modelo explicará que el acceso a la red no está disponible
print(response.output_text)

Qué hay disponible

Bibliotecas preinstaladas

OpenAI no publica una lista oficial de paquetes del contenedor, y esta cambia con el tiempo. Un sondeo publicado por un desarrollador en el foro de OpenAI en noviembre de 2025 contó 389 paquetes, incluidas las bibliotecas esperadas para análisis: pandas, numpy, scipy y statsmodels para datos; matplotlib, seaborn y plotly para visualización; Pillow para imágenes; sympy para matemática simbólica; openpyxl para Excel. En lugar de asumir, pide al modelo que las inventaríe al inicio de un proyecto:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Lista los paquetes de Python instalados con sus versiones, "
          "y muestra luego la versión de Python.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)

Las versiones importan tanto como los nombres: el mismo sondeo mostró pandas 1.5.3, anterior a pandas 2.0. Si tu procesamiento depende de una función reciente, verifica que existe antes de construir sobre ella.

Sistema de archivos

El código lee y escribe archivos dentro del contenedor. Los archivos que crea el modelo se citan en su respuesta y se descargan usando las funciones fichiers_generes y telecharger de la Lección 10:

# El modelo puede crear archivos dentro del contenedor
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Crea un archivo CSV con 100 líneas de datos de prueba "
          "(name, age, city, salary) y devuélvelo.",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

for ann in fichiers_generes(response):
    telecharger(client, ann, ann.filename)

Qué está limitado

Acceso a la red

Por defecto, el contenedor no tiene acceso saliente: ni pip install, ni llamadas a API, ni descargas. Este es el límite más estructural, y es intencionado: el código generado no puede enviar nada a ningún sitio. Lo que necesite tu procesamiento debe estar presente en el contenedor o ser subido por ti; y si los datos están en línea, la herramienta de búsqueda web los obtendrá a menudo en su lugar.

# Sin una lista blanca (caso por defecto), imposible:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (sin descargas)
# - Acceso a API externas
# - Envío de correos electrónicos

Existe la posibilidad de abrir el acceso, pero se decide en dos niveles. Un administrador define primero la lista blanca de la organización en el panel de control; cada solicitud declara luego una network_policy que solo puede restringirla más: una solicitud que pida un dominio ausente de la lista de la organización fallará.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Actualiza pandas con pip y muestra luego la versión instalada.",
    tools=[{
        "type": "code_interpreter",
        "container": {
            "type": "auto",
            "network_policy": {
                "type": "allowlist",
                "allowed_domains": ["pypi.org", "files.pythonhosted.org"],
            },
        },
    }],
)

Abrir dominios tiene un coste, y OpenAI lo dice claramente: es una puerta para la exfiltración de datos mediante inyección de prompts. Autoriza solo dominios de confianza que un atacante no pueda usar para recibir datos, y ten cuidado con el alojamiento compartido, donde cualquiera puede montar un servidor que registre tus solicitudes.

Persistencia entre llamadas

La falta de persistencia sorprende a muchos al encadenar llamadas: el DataFrame cargado en la primera llamada ya no existe en la segunda. La regla exacta depende del modo auto: crea un nuevo contenedor, a menos que el contexto del modelo ya contenga una llamada a Code Interpreter cuyo contenedor siga activo; en ese caso, lo reutiliza. Dos llamadas independientes trabajan cada una en la suya propia, mientras que una llamada encadenada a la anterior (con previous_response_id) encuentra la suya si no ha caducado. Dentro de una única llamada, múltiples ejecuciones de código sí comparten la misma sesión.

# Primera llamada: crea un archivo
response1 = client.responses.create(
    model="gpt-5.6-terra",
    input="Crea una variable x = 42 y guárdala en un archivo",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)

# Segunda llamada, independiente de la primera: nuevo contenedor
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Lee el archivo creado anteriormente",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Error: archivo no encontrado

Para mantener resultados entre llamadas sin depender del contexto, haz que trabajen en el mismo contenedor. Créalo explícitamente con la API de Contenedores y pasa su ID a cada llamada: los archivos producidos por un paso siguen disponibles para el siguiente. Por defecto, caduca tras 20 minutos de inactividad y sus datos se pierden entonces permanentemente: descarga lo que quieras conservar y elimínalo tú mismo después.

def pipeline_avec_persistance(etapes: list[str]) -> list:
    """Ejecuta pasos sucesivos en el mismo contenedor."""
    conteneur = client.containers.create(name="pipeline")
    resultats = []

    for etape in etapes:
        response = client.responses.create(
            model="gpt-5.6-terra",
            input=etape,
            tools=[{"type": "code_interpreter", "container": conteneur.id}],
        )
        resultats.append(response.output_text)

    # Tras descargar los archivos útiles (Lección 10)
    client.containers.delete(conteneur.id)
    return resultats

No devuelvas archivos generados como input_file: sus IDs (cfile_…) se refieren a archivos del contenedor, no a archivos de la API de Files.

Memoria y procesamiento pesado

La documentación no publica una duración máxima de ejecución; el límite concreto es la memoria del contenedor, elegida al crearlo y válida durante toda su vida. Para un archivo grande, elige un nivel adecuado y haz que el trabajo se divida. Más allá de eso —entrenamiento de modelos, cómputo masivo— necesitas usar tu propia infraestructura, quedando el contenedor como herramienta para el análisis interactivo.

# Patrón para procesamiento pesado: más memoria, trabajo dividido
with open("transactions.csv", "rb") as f:
    fichier = client.files.create(file=f, purpose="user_data")

response = client.responses.create(
    model="gpt-5.6-terra",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": (
                "Procesa este archivo CSV de 500.000 líneas en lotes de 50.000. "
                "Para cada lote, calcula estadísticas y acumula los resultados."
            )},
            {"type": "input_file", "file_id": fichier.id}
        ]
    }],
    tools=[{"type": "code_interpreter", "container": {"type": "auto", "memory_limit": "4g"}}],
    instructions="Si el procesamiento rischia ser largo, divídelo en pasos "
                "y muestra el progreso."
)

Seguridad de los datos

Datos sensibles

Los datos copiados en el contenedor se borran cuando este caduca o se elimina. No es el caso de un archivo subido mediante la API de Files: permanece allí hasta que lo elimines, a menos que establezcas una caducidad (expires_after, entre una hora y treinta días). Y el razonamiento de cumplimiento no se detiene ahí: tus datos han salido de tu infraestructura para ser procesados por un tercero. Pseudonimizar antes de enviar cuesta unas pocas líneas y reduce lo que sale, porque un ID de cliente que nunca sale no puede plantear ningún problema.

Un hash con clave (HMAC) proporciona pseudónimos estables de un envío al siguiente, que nadie puede vincular a los valores originales sin la clave. Según el RGPD, el resultado sigue siendo datos personales pseudonimizados, no anónimos: la clave debe permanecer contigo.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # secreto mantenido fuera del código


def pseudonyme(valeur) -> str:
    return hmac.new(CLE, str(valeur).encode(), hashlib.sha256).hexdigest()[:16]


def analyser_donnees_sensibles(fichier_path: str, colonnes_a_masquer: list[str]):
    """Pseudonimiza los datos antes de enviarlos a Code Interpreter."""
    df = pd.read_csv(fichier_path)
    for col in colonnes_a_masquer:
        if col in df.columns:
            df[col] = df[col].map(pseudonyme)

    fichier_pseudo = "/tmp/donnees_pseudonymisees.csv"
    df.to_csv(fichier_pseudo, index=False)

    # Envío con caducidad automática tras una hora
    with open(fichier_pseudo, "rb") as f:
        fichier = client.files.create(
            file=f,
            purpose="user_data",
            expires_after={"anchor": "created_at", "seconds": 3600},
        )

    response = client.responses.create(
        model="gpt-5.6-terra",
        input=[{
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Analiza las tendencias en estos datos"},
                {"type": "input_file", "file_id": fichier.id}
            ]
        }],
        tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
    )
    client.files.delete(fichier.id)  # sin esperar a la caducidad
    return response.output_text

Código generado

El aislamiento protege tu sistema, no la corrección del resultado: el código se ejecuta en OpenAI, en un contenedor desechable, y nunca toca tus máquinas. El riesgo se traslada a lo que haces con sus salidas. Si recuperas el código para ejecutarlo en tu lado, revísalo como si fuera código de terceros. Y si el contenedor tiene una lista blanca, ten en cuenta que un archivo malicioso puede contener instrucciones que empujen al modelo a enviar datos a esos dominios.

Gestión de errores de ejecución

El código puede fallar en el sandbox. El modelo generalmente intenta corregirlo:

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Calcula la matriz inversa de una matriz singular [[1,2],[2,4]]",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
    instructions="Si el código produce un error, explica por qué "
                "y propone una alternativa."
)

# El modelo ejecuta el código, detecta el LinAlgError,
# luego explica que la matriz es singular y propone
# la pseudoinversa de Moore-Penrose

Buenas prácticas

# 1. Sé específico en tus instrucciones
# Mal:
input_vague = "Analiza estos datos"

# Bien:
input_precis = ("Carga este CSV con pandas. "
               "Calcula la media, la mediana y la desviación estándar de la columna 'amount'. "
               "Identifica los valores mayores que 3 desviaciones estándar. "
               "Genera un diagrama de caja.")

# 2. Solicita código comentado
instructions = "Comenta cada paso del código. Muestra resultados intermedios."

# 3. Gestiona archivos grandes
instructions_lot = ("Si el archivo supera las 100.000 líneas, "
                   "trabaja sobre una muestra representativa de 10.000 líneas "
                   "e indícalo en tu respuesta.")

Puntos clave

  • El contenedor está aislado: red cerrada por defecto, memoria limitada, caducidad tras 20 minutos de inactividad.
  • OpenAI no publica la lista de paquetes: pide al modelo que la inventaríe.
  • Una lista blanca de dominios se abre en dos niveles (organización y luego solicitud) y expone a exfiltración: pon allí solo dominios de confianza.
  • Para encadenar pasos, reutiliza el mismo contenedor (client.containers.create, luego su ID en cada llamada) y elimínalo al final.
  • Pseudonimiza los datos sensibles antes de enviarlos y elimina los archivos subidos tras su uso.
  • El modelo gestiona los errores de ejecución e intenta autocorregirse.