Sandboxing e Limites de Segurança
Nesta página
Atualizado em 2 de novembro de 2026 com base na documentação da OpenAI: a ferramenta Code Interpreter requer agora um parâmetro
container(adicionado a todos os exemplos). A rede do contentor, fechada por predefinição, pode agora ser aberta para uma lista de domínios permitidos (allowlist). As regras de ciclo de vida do contentor (memória, expiração, reutilização) seguem o guia oficial. Os ficheiros anexados a uma mensagem são carregados com o propósitouser_data, conforme recomendado pela OpenAI para entradas do modelo. Fontes: Code Interpreter · Container Network Access · Containers API · Files API.
Sandboxing e Limites de Segurança
Os limites do sandbox não são erros para contornar: são as propriedades que tornam aceitável a execução de código gerado. Um ambiente isolado da rede, com um tempo de vida curto e limites de recursos, não pode exfiltrar os seus dados, deixar estado acumulado indefinidamente ou consumir recursos sem limite.
Conhecer estes limites antecipadamente poupa-o de depurar o impossível. As três perguntas recorrentes — por que falha o pip install, por que o meu ficheiro desapareceu entre chamadas, por que o meu processamento falha num ficheiro grande — têm todas resposta abaixo, e nenhuma se trata de um erro.
Arquitetura do Sandbox
O Code Interpreter executa código num contentor, uma máquina virtual isolada alojada pela OpenAI, com as seguintes propriedades:
- Rede fechada por predefinição: sem pedidos de saída, exceto para uma lista de domínios permitidos explicitamente aberta (ver abaixo)
- Tempo de vida curto: o contentor expira após 20 minutos de inatividade, e tudo o que lá estiver é então apagado
- Memória limitada: 1 GB por predefinição, ou 4, 16 ou 64 GB mediante pedido (
memory_limit), tendo cada nível o seu próprio preço
from openai import OpenAI
client = OpenAI()
# Sem uma lista de domínios permitidos, o download falhará: sem acesso à rede
response = client.responses.create(
model="gpt-5.6-terra",
input="Download the content of https://example.com using requests",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# O modelo explicará que o acesso à rede não está disponível
print(response.output_text)
O Que Está Disponível
Bibliotecas Pré-instaladas
A OpenAI não publica uma lista oficial de pacotes do contentor, e esta muda ao longo do tempo. Um estudo publicado por um programador no fórum da OpenAI em novembro de 2025 contou 389 pacotes, incluindo as bibliotecas esperadas para análise: pandas, numpy, scipy e statsmodels para dados; matplotlib, seaborn e plotly para visualização; Pillow para imagens; sympy para matemática simbólica; openpyxl para Excel. Em vez de assumir, peça ao modelo que faça o inventário no início de um projeto:
response = client.responses.create(
model="gpt-5.6-terra",
input="List the installed Python packages with their versions, "
"then display the Python version.",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
print(response.output_text)
As versões importam tanto quanto os nomes: o mesmo estudo mostrou o pandas 1.5.3, que é anterior ao pandas 2.0. Se o seu processamento depender de uma função recente, verifique se ela existe antes de construir sobre ela.
Sistema de Ficheiros
O código lê e escreve ficheiros dentro do contentor. Os ficheiros que o modelo cria são citados na sua resposta e descarregados usando as funções fichiers_generes e telecharger da Lição 10:
# O modelo pode criar ficheiros dentro do contentor
response = client.responses.create(
model="gpt-5.6-terra",
input="Create a CSV file with 100 lines of test data "
"(name, age, city, salary) and return it.",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
for ann in fichiers_generes(response):
telecharger(client, ann, ann.filename)
O Que Está Limitado
Acesso à Rede
Por predefinição, o contentor não tem acesso de saída: sem pip install, sem chamadas a API, sem downloads. Este é o limite mais estrutural, e é intencional: o código gerado não pode enviar nada para lado nenhum. O que o seu processamento necessita deve estar presente no contentor ou ser carregado por si — e se os dados estiverem online, a ferramenta de pesquisa na web irá muitas vezes buscá-los em seu lugar.
# Sem uma lista de domínios permitidos (caso predefinido), impossível:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (sem downloads)
# - Acesso a APIs externas
# - Envio de e-mails
Abrir o acesso existe, mas é decidido a dois níveis. Um administrador define primeiro a lista de domínios permitidos da organização no painel; cada pedido declara depois uma network_policy que só a pode restringir ainda mais — um pedido que solicite um domínio ausente da lista da organização falha.
response = client.responses.create(
model="gpt-5.6-terra",
input="Update pandas with pip, then display the installed version.",
tools=[{
"type": "code_interpreter",
"container": {
"type": "auto",
"network_policy": {
"type": "allowlist",
"allowed_domains": ["pypi.org", "files.pythonhosted.org"],
},
},
}],
)
Abrir domínios tem um custo, e a OpenAI afirma-o claramente: é uma porta para exfiltração de dados via injeção de prompts. Autorize apenas domínios confiáveis que um atacante não possa usar para receber dados — e cuidado com a hospedagem partilhada, onde qualquer pessoa pode colocar um servidor que registará os seus pedidos.
Persistência Entre Chamadas
A falta de persistência surpreende a maioria ao encadear chamadas: o DataFrame carregado na primeira chamada já não existe na segunda. A regra exata depende do modo auto: este cria um novo contentor, a menos que o contexto do modelo já contenha uma chamada ao Code Interpreter cujo contentor ainda esteja ativo — nesse caso, reutiliza esse mesmo. Duas chamadas independentes trabalham, portanto, cada uma no seu próprio contentor, enquanto uma chamada encadeada à anterior (com previous_response_id) encontra o seu próprio se este não tiver expirado. Numa única chamada, múltiplas execuções de código partilham a mesma sessão.
# Primeira chamada: cria um ficheiro
response1 = client.responses.create(
model="gpt-5.6-terra",
input="Create a variable x = 42 and save it to a file",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# Segunda chamada, independente da primeira: novo contentor
response2 = client.responses.create(
model="gpt-5.6-terra",
input="Read the file created previously",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Erro: ficheiro não encontrado
Para manter resultados entre chamadas sem depender do contexto, faça-os funcionar no mesmo contentor. Crie-o explicitamente com a API de Contentores e passe o seu ID a cada chamada: os ficheiros produzidos por um passo permanecem disponíveis para o seguinte. Por predefinição, expira após 20 minutos de inatividade e os seus dados são então perdidos permanentemente: descarregue o que quiser manter e apague-o você mesmo.
def pipeline_avec_persistance(etapes: list[str]) -> list:
"""Executes successive steps in the same container."""
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)
# After downloading useful files (Lesson 10)
client.containers.delete(conteneur.id)
return resultats
Não devolva ficheiros gerados como input_file: os seus IDs (cfile_…) referem-se a ficheiros do contentor, não a ficheiros da API de Ficheiros.
Memória e Processamento Pesado
A documentação não publica uma duração máxima de execução; o limite concreto é a memória do contentor, escolhida na criação e válida durante toda a sua vida. Para um ficheiro grande, escolha um nível apropriado e faça o trabalho ser dividido. Para além disso — treino de modelos, computação massiva — precisa de usar a sua própria infraestrutura, permanecendo o contentor a ferramenta para análise interativa.
# Padrão para processamento pesado: mais memória, trabalho 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": (
"Process this 500,000-line CSV file in batches of 50,000. "
"For each batch, calculate statistics and accumulate results."
)},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto", "memory_limit": "4g"}}],
instructions="If processing risks being long, split it into steps "
"and display progress."
)
Segurança de Dados
Dados Sensíveis
Os dados copiados para o contentor são apagados quando este expira ou é eliminado. Não é o caso de um ficheiro carregado via API de Ficheiros: este permanece lá até que o elimine, a menos que defina uma expiração (expires_after, entre uma hora e trinta dias). E o raciocínio de conformidade não para aí: os seus dados saíram da sua infraestrutura para serem processados por um terceiro. Pseudonimizar antes de enviar custa algumas linhas e reduz o que sai — porque um ID de cliente que nunca sai não pode causar qualquer problema.
Um hash com chave (HMAC) fornece pseudónimos estáveis de um envio para o outro, que ninguém pode ligar aos valores originais sem a chave. Sob o RGPD, o resultado permanece sendo dados pessoais pseudonimizados, não anónimos: a chave deve permanecer consigo.
import hashlib
import hmac
import os
import pandas as pd
CLE = os.environ["CLE_PSEUDONYMISATION"].encode() # segredo mantido fora do 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]):
"""Pseudonymizes data before sending to 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)
# Send with automatic expiration after one hour
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": "Analyze trends in this data"},
{"type": "input_file", "file_id": fichier.id}
]
}],
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
client.files.delete(fichier.id) # without waiting for expiration
return response.output_text
Código Gerado
O isolamento protege o seu sistema, não a correção do resultado: o código é executado na OpenAI, num contentor descartável, e nunca toca nas suas máquinas. O risco desloca-se para o que faz com as suas saídas. Se recuperar o código para o executar do seu lado, reveja-o como código de terceiros. E se o contentor tiver uma lista de domínios permitidos, tenha em mente que um ficheiro malicioso pode conter instruções que empurram o modelo a enviar dados para esses domínios.
Gestão de Erros de Execução
O código pode falhar no sandbox. O modelo geralmente tenta corrigir:
response = client.responses.create(
model="gpt-5.6-terra",
input="Calculate the inverse matrix of a singular matrix [[1,2],[2,4]]",
tools=[{"type": "code_interpreter", "container": {"type": "auto"}}],
instructions="If the code produces an error, explain why "
"and propose an alternative."
)
# O modelo executa o código, deteta o LinAlgError,
# depois explica que a matriz é singular e propõe
# a pseudoinversa de Moore-Penrose
Boas Práticas
# 1. Seja específico nas suas instruções
# Mau:
input_vague = "Analyze this data"
# Bom:
input_precis = ("Load this CSV with pandas. "
"Calculate the mean, median, and standard deviation of the 'amount' column. "
"Identify values greater than 3 standard deviations. "
"Generate a boxplot.")
# 2. Solicite código comentado
instructions = "Comment each step of the code. Display intermediate results."
# 3. Lidar com ficheiros grandes
instructions_lot = ("If the file exceeds 100,000 lines, "
"work on a representative sample of 10,000 lines "
"and indicate this in your response.")
Pontos-chave
- O contentor está isolado: rede fechada por predefinição, memória limitada, expiração após 20 minutos de inatividade
- A OpenAI não publica a lista de pacotes: peça ao modelo que faça o inventário
- Uma lista de domínios permitidos abre-se a dois níveis (organização, depois pedido) e expõe à exfiltração: coloque lá apenas domínios confiáveis
- Para encadear passos, reutilize o mesmo contentor (
client.containers.create, depois o seu ID em cada chamada) e elimine-o no final - Pseudonimize dados sensíveis antes de enviar e elimine os ficheiros carregados após o uso
- O modelo gere erros de execução e tenta autocorrigir-se