0Pricing
AI Agents · Lektion

Docker-basierte Agent-Sandboxes

Temporäre Container für die Ausführung von von Agenten generiertem Code starten.

Docker-basierte Agent-Sandboxes ist eine kostenlose AI Agents-Lektion auf CoddyKit. Dies ist Lektion 1 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des AI Agents-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Warum Agenten Sandboxes benötigen

Wenn ein Agent von einem LLM geschriebenen Code ausführt, ist dieser Code nicht vertrauenswürdig. Er könnte versuchen, sensible Dateien zu lesen, ausgehende Verbindungen herzustellen oder unbegrenzt Ressourcen zu verbrauchen.

Eine Sandbox isoliert die Codeausführung, sodass der Schaden unabhängig vom Verhalten des Codes begrenzt bleibt.

Docker als Sandbox-Schicht

Docker-Container bieten eine leichtgewichtige Isolation auf Betriebssystemebene. Jedes Codefragment wird in einem neuen Container mit expliziten Ressourcenbegrenzungen und Netzwerkeinschränkungen ausgeführt.

Mit dem docker-Python-SDK können Sie Container programmgesteuert innerhalb Ihres Agenten starten und wieder löschen.

import docker

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

Grundlegendes Starten eines Containers

client.containers.run() startet einen Container, führt einen Befehl aus und gibt die Ausgabe als Bytes zurück. Wenn Sie auto_remove=True setzen, wird der Container nach dem Beenden automatisch entfernt.

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'

Speicher- und CPU-Limits

Ohne Limits kann ein außer Kontrolle geratenes Skript den Hauptspeicher des Hosts vollständig aufbrauchen. Übergeben Sie mem_limit und nano_cpus, um die Ressourcennutzung zu begrenzen.

Wenn der Prozess mem_limit überschreitet, wird der Container wegen Speichermangels beendet und eine Ausnahme ausgelöst.

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

Netzwerk deaktivieren

Durch das Setzen von network_disabled=True wird verhindert, dass der Container ausgehende oder eingehende Netzwerkverbindungen herstellt – selbst DNS-Abfragen schlagen fehl. Dadurch werden Datenabfluss und Rückverbindungen zu Command-and-Control-Servern verhindert.

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

Ausführungs-Timeout

Eine Endlosschleife innerhalb der Sandbox würde Ihren Agenten für immer blockieren. Übergeben Sie ein timeout in Sekunden an containers.run(), damit Docker den Container nach Ablauf der Frist beendet.

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}')

Vollständige Hilfsfunktion für die Sandbox

Wenn Sie alle Einstellungen in eine wiederverwendbare Funktion kapseln, lässt sie sich einfach aus Agent-Tools aufrufen. Geben Sie sowohl stdout als auch ein Statuskennzeichen zurück, damit der Agent auf Fehler reagieren kann.

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)}

Temporären Arbeitsbereich einbinden

Wenn der Code Eingabedateien lesen oder Ausgabedateien schreiben muss, binden Sie ein temporäres Host-Verzeichnis in den Container ein. Verwenden Sie volumes mit dem Modus 'rw' für den Arbeitsbereich und binden Sie keine weiteren Verzeichnisse ein.

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())

Schreibgeschütztes Dateisystem

Setzen Sie read_only=True, um das Root-Dateisystem des Containers schreibgeschützt einzubinden. Der Code kann nur in ausdrücklich eingebundene Volumes schreiben. Dadurch werden Schreibzugriffe auf /etc, /usr und andere sensible Pfade innerhalb des Images verhindert.

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'

Sandbox in ein Agent-Tool integrieren

Registrieren Sie den Sandbox-Runner als Tool, das das LLM aufrufen kann. Der Agent erzeugt Code, das Tool führt ihn isoliert aus und die Ausgabe wird an den nächsten Denkschritt zurückgegeben.

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'])

Fehlerbehandlung und Bereinigung

Container können nicht gestartet werden, wenn der Docker-Daemon nicht läuft oder das Image nicht lokal zwischengespeichert ist. Behandeln Sie immer docker.errors.DockerException und stellen Sie sicher, dass Container auch bei Ausnahmen bereinigt werden.

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)}

Welche Sandbox-Einstellung ist am wichtigsten, um Datenabfluss zu verhindern?

Eine Agent-Sandbox muss verhindern, dass der ausgeführte Code gestohlene Daten an einen externen Server sendet. Welcher Docker-Parameter blockiert den ausgehenden Netzwerkzugriff direkt?

Zusammenfassung zur Docker-Sandbox

Docker-basierte Sandboxes bieten Agenten eine sichere Ausführungsumgebung, indem sie Speicher- und CPU-Limits, Netzwerkisolation, Ausführungs-Timeouts und schreibgeschützte Dateisysteme kombinieren.

Kapseln Sie diese Einstellungen in einer wiederverwendbaren Hilfsfunktion und stellen Sie sie als Agent-Tool bereit. So kann das LLM generierten Code sicher ausführen, ohne das Hostsystem zu gefährden.

Häufig gestellte Fragen

Ist die Lektion „Docker-basierte Agent-Sandboxes“ kostenlos?

Ja — der vollständige Text von „Docker-basierte Agent-Sandboxes“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des AI Agents-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der AI Agents-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Docker-basierte Agent-Sandboxes“?

Temporäre Container für die Ausführung von von Agenten generiertem Code starten. Du übst AI Agents mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um AI Agents zu starten?

Keine Vorkenntnisse erforderlich. AI Agents auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 1 von 4.

Wie lange dauert die Lektion „Docker-basierte Agent-Sandboxes“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser AI Agents-Lektion Code schreiben und ausführen?

Ja. Jede AI Agents-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Docker-basierte Agent-Sandboxes
  2. VM-Isolierung für hochsichere Code-Agenten
  3. E2B- und Cloud-Sandbox-Dienste
  4. Sicherheitsrichtlinien für die Codeausführung
← Zurück zu AI Agents