Docker-baserade agent-sandlådor
Starta tillfälliga containrar för körning av kod som genererats av agenten.
Docker-baserade agent-sandlådor är en gratis lektion i AI-agenter på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för AI-agenter, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i AI-agenter innehåller totalt 4 lektioner.
Varför behöver agenter sandlådor?
När en agent kör kod som har skrivits av en LLM är koden ej betrodd. Den kan försöka läsa känsliga filer, upprätta utgående anslutningar eller förbruka obegränsade resurser.
En sandbox isolerar kodkörningen så att skadan begränsas oavsett vad koden gör.
Docker som sandlådelager
Docker-containrar tillhandahåller lättviktig isolering på operativsystemnivå. Varje kodavsnitt körs i en ny container med uttryckliga resursgränser och nätverksbegränsningar.
Docks Python-SDK docker låter dig starta och förstöra containrar programmatiskt inifrån agenten.
import docker
client = docker.from_env()
print(client.version()['Version'])Grundläggande körning av container
client.containers.run() startar en container, kör ett kommando och returnerar utdata som byte. Om auto_remove=True anges tas containern bort när den har avslutats.
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'Minnes- och CPU-begränsningar
Utan begränsningar kan ett okontrollerat skript tömma värdminnet. Ange mem_limit och nano_cpus för att begränsa resursanvändningen.
Om processen överskrider mem_limit dödas containern av OOM-killern och ett undantag kastas.
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-killedInaktivera nätverket
Om network_disabled=True anges förhindras containern från att göra utgående eller inkommande nätverksanrop — även DNS-sökningar misslyckas. Detta stoppar dataexfiltrering och anslutningar till kommando- och kontrollservrar.
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 unreachableTidsgräns för körning
En oändlig loop inuti sandlådan skulle blockera agenten för alltid. Ange en timeout (i sekunder) till containers.run() så att Docker dödar containern efter tidsgränsen.
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}')Fullständig hjälpfunktion för sandlådan
Om alla inställningar omsluts i en återanvändbar funktion blir den enkel att anropa från agentverktyg. Returnera både stdout och en statusflagga så att agenten kan hantera fel.
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)}Montera en tillfällig arbetsyta
Om koden behöver läsa indatafiler eller skriva utdatafiler monterar du en tillfällig värdkatalog i containern. Använd volumes med läget 'rw' för arbetsytan och montera inget annat.
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())Skrivskyddat filsystem
Ange read_only=True för att montera containerns rotfilsystem som skrivskyddat. Koden kan endast skriva till uttryckligen monterade volymer. Detta förhindrar skrivningar till /etc, /usr eller andra känsliga sökvägar i avbildningen.
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'Integrera sandlådan i ett agentverktyg
Registrera sandlådekörningen som ett verktyg som LLM:en kan anropa. Agenten genererar kod, verktyget kör den isolerat och resultatet skickas tillbaka till nästa resonemangssteg.
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'])Felhantering och städning
Containrar kan misslyckas med att starta om Docker-demonen inte körs eller om avbildningen inte finns i cachen. Hantera alltid docker.errors.DockerException och se till att containrar städas bort även vid undantag.
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)}Vilken sandlådeinställning är viktigast för att förhindra dataexfiltrering?
En agentsandlåda måste förhindra att den körda koden skickar stulen data till en extern server. Vilken Docker-parameter blockerar utgående nätverksåtkomst direkt?
Sammanfattning av Docker-sandlådor
Docker-baserade sandlådor ger agenter en säker körmiljö genom att kombinera minnes- och CPU-begränsningar, nätverksisolering, tidsgränser för körning och skrivskyddade filsystem.
Omslut dessa inställningar i en återanvändbar hjälpfunktion och exponera den som ett agentverktyg, så att LLM:en kan köra genererad kod säkert utan risk för värdsystemet.
Lär dig AI-agenter med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 60
- Lektioner
- 239
Vanliga frågor
Är lektionen ”Docker-baserade agent-sandlådor” gratis?
Ja – hela texten till ”Docker-baserade agent-sandlådor” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i AI-agenter, kan Ni uppgradera till CoddyKit PRO. Kursen i AI-agenter innehåller totalt 4 lektioner.
Vad lär jag mig i ”Docker-baserade agent-sandlådor”?
Starta tillfälliga containrar för körning av kod som genererats av agenten. Ni övar på AI-agenter med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig AI-agenter?
Du behöver inga förkunskaper. Utbildningen i AI-agenter på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Docker-baserade agent-sandlådor”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här AI-agenter-lektionen?
Ja. Varje AI-agenter-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Docker-baserade agent-sandlådor
- VM-isolering för kodagenter med höga säkerhetskrav
- E2B och molnbaserade sandlådekörningstjänster
- Säkerhetsprinciper för kodkörning