Ir para o conteúdo principal
Português— Escolher um idioma
Menu

Sandboxing e Limites de Segurança

Aula 11 de 20 Atualizada a 2 de novembro de 2026 Programador
Nesta página
  1. Sandboxing e Limites de Segurança
  2. Arquitetura do Sandbox
  3. O Que Está Disponível
  4. O Que Está Limitado
  5. Segurança de Dados
  6. Gestão de Erros de Execução
  7. Boas Práticas
  8. Pontos-chave

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ósito user_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