Премини към основното съдържание
Български— Изберете език
Меню

Изолирана среда (Sandboxing) и ограничения за сигурност

Урок 11 от 20 Обновен 2 ноември 2026 г. Програмист
На тази страница
  1. Изолирана среда (Sandboxing) и ограничения за сигурност
  2. Архитектура на изолираната среда
  3. Какво е налично
  4. Какво е ограничено
  5. Сигурност на данните
  6. Обработка на грешки при изпълнение
  7. Най-добри практики
  8. Ключови изводи

Обновено на 2 ноември 2026 г. въз основа на документацията на OpenAI: инструментът Code Interpreter вече изисква параметър container (добавен към всички примери). Мрежата на контейнера, затворена по подразбиране, вече може да се отваря към списък с разрешени домейни. Правилата за жизнения цикъл на контейнера (памет, изтичане на срока, повторно използване) следват официалното ръководство. Файловете, прикачени към съобщение, се качват с цел user_data, както се препоръчва от OpenAI за входни данни на модела. Източници: Code Interpreter · Container Network Access · Containers API · Files API.

Изолирана среда (Sandboxing) и ограничения за сигурност

Ограниченията на изолираната среда не са бъгове, които трябва да заобикаляте: те са свойствата, които правят изпълнението на генериран код приемливо. Среда, изолирана от мрежата, с кратък живот и ограничения на ресурсите, не може да изнесе вашите данни, да остави състояние да лежи наоколо за неопределено време или да консумира ресурси без ограничение.

Познаването на тези ограничения предварително ви спестява дебъгване на невъзможното. Трите повтарящи се въпроса – защо pip install се проваля, защо файлът ми изчезна между обажданията, защо обработката ми се срива при голям файл – всички имат отговори по-долу и никой от тях не е бъг.

Архитектура на изолираната среда

Code Interpreter изпълнява код в контейнер, изолирана виртуална машина, хоствана от OpenAI, със следните свойства:

  • Мрежата е затворена по подразбиране: няма изходящи заявки, освен за изрично отворен списък с разрешени домейни (вижте по-долу)
  • Кратък живот: контейнерът изтича след 20 минути неактивност и всичко вътре в него се изтрива
  • Ограничена памет: 1 GB по подразбиране, или 4, 16, или 64 GB при заявка (memory_limit), като всяко ниво има своя цена
from openai import OpenAI

client = OpenAI()

# Без списък с разрешени, изтеглянето ще се провали: няма мрежов достъп
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"}}]
)

# Моделът ще обясни, че мрежовият достъп е недостъпен
print(response.output_text)

Какво е налично

Предварително инсталирани библиотеки

OpenAI не публикува официален списък с пакети за контейнера и той се променя с времето. Проучване, публикувано от разработчик във форума на OpenAI през ноември 2025 г. наброи 389 пакета, включително очакваните библиотеки за анализ: pandas, numpy, scipy и statsmodels за данни; matplotlib, seaborn и plotly за визуализация; Pillow за изображения; sympy за символна математика; openpyxl за Excel. Вместо да предполагате, накарайте модела да ги инвентаризира в началото на проекта:

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)

Версиите са също толкова важни, колкото и имената: същото проучване показа pandas 1.5.3, което предшества pandas 2.0. Ако обработката ви зависи от скорошна функция, проверете дали съществува, преди да градите върху нея.

Файлова система

Кодът чете и пише файлове вътре в контейнера. Файловете, които моделът създава, се цитират в неговия отговор и се изтеглят с помощта на функциите fichiers_generes и telecharger от Урок 10:

# Моделът може да създава файлове вътре в контейнера
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)

Какво е ограничено

Мрежов достъп

По подразбиране контейнерът няма изходящ достъп: няма pip install, няма API обаждания, няма изтегляния. Това е най-структурното ограничение и то е умишлено: генерираният код не може да изпраща нищо никъде. Това, от което обработката ви се нуждае, трябва да присъства в контейнера или да бъде качено от вас – и ако данните са онлайн, инструментът за уеб търсене често ще ги извлече вместо това.

# Без списък с разрешени (случай по подразбиране), невъзможно е:
# - requests.get(), urllib.request
# - socket, http.client
# - pip install (няма изтегляния)
# - Достъп до външни API
# - Изпращане на имейли

Отварянето на достъп съществува, но се решава на две нива. Администратор първо дефинира списъка с разрешени за организацията в таблото за управление; всяка заявка след това декларира network_policy, което може само да го ограничи допълнително – заявка, искаща домейн, отсъстващ от списъка на организацията, се проваля.

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"],
            },
        },
    }],
)

Отварянето на домейни има цена и OpenAI го заявява ясно: това е врата за изнасяне на данни чрез инжектиране на подкани (prompt injection). Разрешавайте само надеждни домейни, които нападател не може да използва за получаване на данни – и внимавайте със споделения хостинг, където всеки може да пусне сървър, който ще регистрира вашите заявки.

Постоянство между обаждания

Липсата на постоянство изненадва повечето при верижни обаждания: DataFrame, зареден в първото обаждане, вече не съществува във второто. Точното правило зависи от режима auto: той създава нов контейнер, освен ако контекстът на модела вече не съдържа обаждане на Code Interpreter, чийто контейнер все още е активен – тогава той използва този. Две независими обаждания следователно работят всеки в своя собствен контейнер, докато обаждане, верижно свързано с предишното (с `previous_response_id’), намира своето, ако не е изтекло. В рамките на едно обаждане множество изпълнения на код споделят една и съща сесия.

# Първо обаждане: създава файл
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"}}]
)

# Второ обаждане, независимо от първото: нов контейнер
response2 = client.responses.create(
    model="gpt-5.6-terra",
    input="Read the file created previously",
    tools=[{"type": "code_interpreter", "container": {"type": "auto"}}]
)
# -> Грешка: файлът не е намерен

За да запазите резултатите между обажданията, без да зависите от контекста, накарайте ги да работят в един и същ контейнер. Създайте го изрично с Containers API и предайте неговия ID на всяко обаждане: файловете, произведени от една стъпка, остават налични за следващата. По подразбиране той изтича след 20 минути неактивност и данните му след това се губят безвъзвратно: изтеглете това, което искате да запазите, и след това го изтрийте сами.

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)

    # След изтегляне на полезни файлове (Урок 10)
    client.containers.delete(conteneur.id)
    return resultats

Не връщайте генерирани файлове като input_file: техните ID (cfile_…) се отнасят до файлове в контейнера, а не до файлове от Files API.

Памет и тежка обработка

Документацията не публикува максимална продължителност на изпълнение; конкретното ограничение е паметта на контейнера, избрана при създаването и валидна за целия му живот. За голям файл изберете подходящо ниво и накарайте работата да се раздели. Отвъд това – обучение на модели, масивни изчисления – трябва да използвате собствената си инфраструктура, като контейнерът остава инструментът за интерактивен анализ.

# Шаблон за тежка обработка: повече памет, разделена работа
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."
)

Сигурност на данните

Чувствителни данни

Данните, копирани в контейнера, се изтриват, когато той изтече или бъде изтрит. Това не е случаят с файл, качен чрез Files API: той остава там, докато не го изтриете, освен ако не зададете изтичане на срока (expires_after, между един час и тридесет дни). И разсъжденията за съответствие не спират дотук: вашите данни са напуснали вашата инфраструктура, за да бъдат обработени от трета страна. Псевдонимизирането преди изпращане струва няколко реда и намалява това, което напуска – защото ID на клиент, което никога не напуска, не може да представлява никакъв проблем.

Ключиран хеш (HMAC) дава стабилни псевдоними от едно изпращане до следващото, които никой не може да свърже с оригиналните стойности без ключа. Според GDPR резултатът остава псевдонимизирани лични данни, а не анонимни: ключът трябва да остане при вас.

import hashlib
import hmac
import os

import pandas as pd

CLE = os.environ["CLE_PSEUDONYMISATION"].encode()  # secret kept outside code


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

Генериран код

Изолацията защитава вашата система, а не правилността на резултата: кодът се изпълнява в OpenAI, в контейнер за еднократна употреба, и никога не докосва вашите машини. Рискът се измества към това, което правите с неговите изходи. Ако извлечете кода, за да го изпълните на ваша страна, прегледайте го като код на трета страна. И ако контейнерът има списък с разрешени, имайте предвид, че злонамерен файл може да съдържа инструкции, които подтикват модела да изпрати данни до тези домейни.

Обработка на грешки при изпълнение

Кодът може да се провали в изолираната среда. Моделът обикновено се опитва да поправи:

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."
)

# Моделът изпълнява кода, открива LinAlgError,
# след това обяснява, че матрицата е сингулярна и предлага
# псевдообратната матрица на Moore-Penrose

Най-добри практики

# 1. Бъдете конкретни в инструкциите си
# Лошо:
input_vague = "Analyze this data"

# Добро:
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. Искайте коментиран код
instructions = "Comment each step of the code. Display intermediate results."

# 3. Обработвайте големи файлове
instructions_lot = ("If the file exceeds 100,000 lines, "
                   "work on a representative sample of 10,000 lines "
                   "and indicate this in your response.")

Ключови изводи

  • Контейнерът е изолиран: мрежата е затворена по подразбиране, паметта е ограничена, изтичане на срока след 20 минути неактивност
  • OpenAI не публикува списъка с пакети: накарайте модела да ги инвентаризира
  • Списък с разрешени домейни се отваря на две нива (организация, след това заявка) и излага на риск от изнасяне на данни: поставете там само надеждни домейни
  • За да верижно свържете стъпки, използвайте повторно един и същ контейнер (client.containers.create, след това неговия ID при всяко обаждане) и го изтрийте в края
  • Псевдонимизирайте чувствителните данни преди изпращане и изтривайте качените файлове след употреба
  • Моделът обработва грешки при изпълнение и се опитва да се самокоригира