0Pricing
AI Agents · Lekcja

Sandboxy agentów oparte na Dockerze

Uruchamianie jednorazowych kontenerów do wykonywania kodu wygenerowanego przez agenta.

Sandboxy agentów oparte na Dockerze to bezpłatna lekcja AI Agents na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej AI Agents, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs AI Agents zawiera 4 lekcji w sumie.

Dlaczego agenci potrzebują piaskownic

Gdy agent wykonuje kod napisany przez LLM, kod ten jest niezaufany. Może próbować odczytywać poufne pliki, nawiązywać połączenia wychodzące albo zużywać nieograniczone zasoby.

Piaskownica izoluje wykonywanie kodu, dzięki czemu skutki są ograniczone niezależnie od działania kodu.

Docker jako warstwa piaskownicy

Kontenery Docker zapewniają lekką izolację na poziomie systemu operacyjnego. Każdy fragment kodu działa w nowym kontenerze z jasno określonymi limitami zasobów i ograniczeniami sieciowymi.

Python SDK docker pozwala programowo uruchamiać i usuwać kontenery bezpośrednio z poziomu agenta.

import docker

client = docker.from_env()
print(client.version()['Version'])

Podstawowe uruchamianie kontenera

client.containers.run() uruchamia kontener, wykonuje polecenie i zwraca dane wyjściowe w postaci bajtów. Ustawienie auto_remove=True usuwa kontener po zakończeniu jego działania.

import docker

client = docker.from_env()

output = client.containers.run(
    'python:3.12-slim',
    'python -c "print(2 + 2)"',
    auto_remove=True
)

print(output.decode())  # '4'

Limity pamięci i CPU

Bez limitów złośliwy skrypt może wyczerpać pamięć hosta. Należy przekazać mem_limit i nano_cpus, aby ograniczyć wykorzystanie zasobów.

Jeśli proces przekroczy wartość mem_limit, kontener zostanie zakończony z powodu braku pamięci (OOM), a wyjątek zostanie zgłoszony.

output = client.containers.run(
    'python:3.12-slim',
    'python -c "x = [0]*10**8"',   # tries to allocate ~800 MB
    mem_limit='256m',
    nano_cpus=1_000_000_000,        # 1 CPU
    auto_remove=True
)
# Raises docker.errors.ContainerError if OOM-killed

Wyłączanie sieci

Ustawienie network_disabled=True uniemożliwia kontenerowi wykonywanie połączeń sieciowych wychodzących i przychodzących — nie powiodą się nawet zapytania DNS. Zapobiega to eksfiltracji danych i połączeniom zwrotnym z serwerami command-and-control.

output = client.containers.run(
    'python:3.12-slim',
    'python -c "import urllib.request; urllib.request.urlopen(\"http://example.com\")"',
    network_disabled=True,
    auto_remove=True
)
# Raises ContainerError: network unreachable

Limit czasu wykonania

Nieskończona pętla w piaskownicy zablokowałaby agenta na zawsze. Należy przekazać parametr timeout (w sekundach) do containers.run(), aby Docker zakończył działanie kontenera po upływie wyznaczonego czasu.

import docker
from docker.errors import ContainerError

client = docker.from_env()

try:
    output = client.containers.run(
        'python:3.12-slim',
        'python -c "while True: pass"',
        mem_limit='256m',
        network_disabled=True,
        auto_remove=True,
        timeout=30
    )
except Exception as e:
    print(f'Sandbox timeout or error: {e}')

Pełna funkcja pomocnicza piaskownicy

Umieszczenie wszystkich ustawień w funkcji wielokrotnego użytku ułatwia wywoływanie jej z narzędzi agenta. Należy zwracać zarówno stdout, jak i flagę stanu, aby agent mógł odpowiednio zareagować na błędy.

import docker

client = docker.from_env()

def run_in_sandbox(code: str, timeout: int = 30) -> dict:
    cmd = f'python -c "{code.replace(chr(34), chr(39))}"'
    try:
        out = client.containers.run(
            'python:3.12-slim',
            cmd,
            mem_limit='256m',
            nano_cpus=500_000_000,
            network_disabled=True,
            auto_remove=True,
            timeout=timeout
        )
        return {'success': True, 'output': out.decode()}
    except Exception as e:
        return {'success': False, 'error': str(e)}

Montowanie tymczasowego obszaru roboczego

Jeśli kod musi odczytywać pliki wejściowe lub zapisywać pliki wyjściowe, należy zamontować tymczasowy katalog hosta w kontenerze. Należy użyć volumes z trybem 'rw' wyłącznie dla obszaru roboczego.

import tempfile, os

with tempfile.TemporaryDirectory() as tmpdir:
    # Write input data
    with open(os.path.join(tmpdir, 'data.txt'), 'w') as f:
        f.write('hello sandbox')

    output = client.containers.run(
        'python:3.12-slim',
        'python -c "print(open(\"/workspace/data.txt\").read())"',
        volumes={tmpdir: {'bind': '/workspace', 'mode': 'rw'}},
        mem_limit='256m',
        network_disabled=True,
        auto_remove=True
    )
    print(output.decode())

System plików tylko do odczytu

Ustawienie read_only=True powoduje zamontowanie głównego systemu plików kontenera w trybie tylko do odczytu. Kod może zapisywać wyłącznie w jawnie zamontowanych woluminach. Zapobiega to zapisom w katalogach /etc, /usr i innych wrażliwych ścieżkach wewnątrz obrazu.

import tempfile

with tempfile.TemporaryDirectory() as tmpdir:
    output = client.containers.run(
        'python:3.12-slim',
        'python -c "open(\"/output/result.txt\",\"w\").write(str(1+1))"',
        volumes={tmpdir: {'bind': '/output', 'mode': 'rw'}},
        read_only=True,
        mem_limit='256m',
        network_disabled=True,
        auto_remove=True
    )
    print(open(f'{tmpdir}/result.txt').read())  # '2'

Integracja piaskownicy z narzędziem agenta

Należy zarejestrować moduł uruchamiający piaskownicę jako narzędzie, które może wywoływać LLM. Agent generuje kod, narzędzie wykonuje go w izolacji, a wynik trafia do kolejnego etapu rozumowania.

tools = [
    {
        'type': 'function',
        'function': {
            'name': 'execute_python',
            'description': 'Run a Python snippet in an isolated Docker sandbox.',
            'parameters': {
                'type': 'object',
                'properties': {
                    'code': {'type': 'string', 'description': 'Python code to execute.'}
                },
                'required': ['code']
            }
        }
    }
]

def handle_tool_call(name, args):
    if name == 'execute_python':
        return run_in_sandbox(args['code'])

Obsługa błędów i sprzątanie

Kontenery mogą nie uruchomić się, jeśli demon Docker nie działa lub obraz nie jest zapisany w pamięci podręcznej. Należy zawsze obsługiwać wyjątek docker.errors.DockerException i zapewnić usunięcie kontenerów nawet w przypadku wyjątków.

from docker.errors import DockerException, ImageNotFound

def safe_run(code: str) -> dict:
    try:
        return run_in_sandbox(code)
    except ImageNotFound:
        # Pull the image first
        client.images.pull('python:3.12-slim')
        return run_in_sandbox(code)
    except DockerException as e:
        return {'success': False, 'error': f'Docker unavailable: {e}'}
    except Exception as e:
        return {'success': False, 'error': str(e)}

Które ustawienie piaskownicy jest najważniejsze, aby zapobiec eksfiltracji danych?

Piaskownica agenta musi uniemożliwiać wykonywanemu kodowi wysyłanie skradzionych danych na zewnętrzny serwer. Który parametr Docker bezpośrednio blokuje wychodzący ruch sieciowy?

Podsumowanie piaskownic Docker

Piaskownice oparte na Dockerze zapewniają agentom bezpieczne środowisko wykonywania kodu, łącząc limity pamięci i CPU, izolację sieci, limity czasu wykonania oraz systemy plików tylko do odczytu.

Należy umieścić te ustawienia w pomocniczej funkcji wielokrotnego użytku i udostępnić ją jako narzędzie agenta, aby umożliwić LLM bezpieczne uruchamianie wygenerowanego kodu bez ryzyka dla systemu hosta.

Często zadawane pytania

Czy lekcja „Sandboxy agentów oparte na Dockerze” jest bezpłatna?

Tak — pełny tekst „Sandboxy agentów oparte na Dockerze” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu AI Agents, przejdź na CoddyKit PRO. Kurs AI Agents zawiera 4 lekcji w sumie.

Co nauczysz się w „Sandboxy agentów oparte na Dockerze”?

Uruchamianie jednorazowych kontenerów do wykonywania kodu wygenerowanego przez agenta. Ćwiczysz AI Agents z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć AI Agents?

Nie wymagamy żadnego doświadczenia. AI Agents w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.

Ile czasu zajmuje lekcja „Sandboxy agentów oparte na Dockerze”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji AI Agents?

Tak. Każda lekcja AI Agents zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Sandboxy agentów oparte na Dockerze
  2. Izolacja maszyn wirtualnych dla agentów wykonujących kod o wysokim poziomie bezpieczeństwa
  3. E2B i chmurowe usługi sandboxów
  4. Zasady bezpieczeństwa wykonywania kodu
← Powrót do AI Agents