Shell: Exekvering av kommandon
På denna sida
Shell: Exekvering av kommandon
Detta är kursens kraftfullaste verktyg, och det enda där ett misstag kan vända dess kraft mot dig. Andra verktyg läser, beräknar eller söker; detta agerar på en maskin. En dåligt formulerad systemdiagnos förblir bara en diagnos; ett dåligt formulerat rensningskommando raderar filer.
Denna lektion täcker användning och säkerhetsåtgärder tillsammans eftersom de inte kan separeras. Den gyllene regeln: modellen får aldrig exekvera ett kommando som du inte uttryckligen har godkänt i förväg.
Koncept och arkitektur
Skillnaden gentemot Code Interpreter är avgörande, och den kokar ner till ett ord: isolering. Code Interpreter körs i en engångssandlåda isolerad från nätverket, där värsta tänkbara scenario är en felaktig beräkning. Shell körs i en miljö som du konfigurerar – potentiellt din lokala maskin, potentiellt en server – där värsta tänkbara scenario är en oåterkallelig operation.
Denna frihet är hela poängen: utan den är automatiserad driftsättning och underhåll omöjligt. Det kräver dock att du medvetet väljer exekveringsomfånget. En dedikerad container med begränsade rättigheter är nästan alltid ett bättre val än direkt åtkomst till värddatorn.
from openai import OpenAI
client = OpenAI()
# The Shell tool is used via the Agents SDK
# because it requires a controlled execution environment
from agents import Agent, Runner
agent = Agent(
name="devops-assistant",
model="gpt-5.6-terra",
instructions=(
"You are a DevOps assistant. You execute system commands "
"to diagnose and resolve infrastructure issues. "
"Explain each command before executing it."
),
tools=[{"type": "shell"}]
)
Användningsfall: Systemdiagnos
# The agent can execute diagnostic commands
agent = Agent(
name="diagnostic",
model="gpt-5.6-terra",
instructions=(
"Diagnose the system state by executing appropriate commands. "
"Start with basic checks (disk, memory, CPU) "
"then dig deeper based on symptoms."
),
tools=[{"type": "shell"}]
)
# The agent will execute commands like:
# df -h -> disk space
# free -m -> memory
# top -bn1 -> CPU load
# systemctl status nginx -> service status
Säkra exekveringen
Tre säkerhetsåtgärder arbetar tillsammans, och ingen är tillräcklig på egen hand. Allowlistan är grunden: du räknar upp vad som är tillåtet snarare än vad som är förbjudet, eftersom en blocklista alltid missar en variant – och det räcker med en. En timeout förhindrar att ett fastnat kommando hänger upp systemet. En begränsad arbetskatalog begränsar skadorna om ett legitimt kommando pekar på fel plats.
En fjärde åtgärd, icke-teknisk men värd de andra tre tillsammans: kräv mänsklig bekräftelse för alla destruktiva eller oåterkalleliga operationer. En modell gör misstag med samma självförtroende som när den har rätt.
# Pattern: wrapper function with validation
import subprocess
import shlex
ALLOWED_COMMANDS = {
"diagnostic": ["df", "free", "top", "uptime", "ps", "netstat", "curl", "ping"],
"deployment": ["git", "docker", "npm", "pip"],
"files": ["ls", "cat", "head", "tail", "wc", "grep", "find"],
}
FORBIDDEN_COMMANDS = ["rm", "dd", "mkfs", "shutdown", "reboot", "kill", "passwd"]
def execute_secure_command(command: str, category: str = "diagnostic") -> dict:
"""Executes a command with security validation."""
# Parse the command
parts = shlex.split(command)
executable = parts[0]
# Check prohibitions
if executable in FORBIDDEN_COMMANDS:
return {
"error": f"Forbidden command: {executable}",
"reason": "This command is on the blocklist"
}
# Check permissions
allowed = ALLOWED_COMMANDS.get(category, [])
if executable not in allowed:
return {
"error": f"Command not allowed in category '{category}'",
"allowed": allowed
}
# Execute with timeout
try:
result = subprocess.run(
parts,
capture_output=True,
text=True,
timeout=30,
cwd="/tmp" # Restricted working directory
)
return {
"stdout": result.stdout,
"stderr": result.stderr,
"return_code": result.returncode
}
except subprocess.TimeoutExpired:
return {"error": "Timeout: command exceeded 30 seconds"}
Implementera som en anpassad funktion
Att implementera detta själv via funktionsanrop erbjuder en fördel du inte bör se som en nödlösning: valideringen finns i din kod. Du bestämmer över allowlistan, loggningen och bekräftelsestegen, och du kan granska allt. För ett verktyg med denna risknivå är det att föredra att behålla kontrollen över kontrollpunkten, även när en inbyggd version blir tillgänglig.
tools = [
{
"type": "function",
"name": "execute_command",
"description": (
"Execute a shell command on the server. "
"Allowed commands: system diagnostics (df, free, top, uptime, ps), "
"file reading (ls, cat, head, tail, grep), "
"network (curl, ping, netstat). "
"Destructive commands are forbidden."
),
"parameters": {
"type": "object",
"properties": {
"command": {
"type": "string",
"description": "The shell command to execute"
},
"directory": {
"type": "string",
"description": "Working directory (default: /tmp)"
}
},
"required": ["command"],
"additionalProperties": False
},
"strict": True
}
]
import json
def handle_calls(response):
results = []
for item in response.output:
if item.type == "function_call" and item.name == "execute_command":
args = json.loads(item.arguments)
result = execute_secure_command(
args["command"],
category="diagnostic"
)
results.append({
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(result)
})
return results
# Full loop
response = client.responses.create(
model="gpt-5.6-terra",
input="Check disk space and available memory",
tools=tools
)
results = handle_calls(response)
final_response = client.responses.create(
model="gpt-5.6-terra",
input=response.output + results,
tools=tools
)
print(final_response.output_text)
Automatiserade arbetsflöden
Automatiserad driftsättning
Driftsättning är det mest värdefulla användningsfallet, förutsatt att du förstår vad du delegerar. Modellen hittar inte på proceduren: den kedjar samman steg du har definierat, verifierar mellanliggande utdata och stoppar vid varje avvikelse. Det är en uppmärksam operatör, inte en beslutsfattare.
tools_deploy = [
{
"type": "function",
"name": "execute_deploy_step",
"description": (
"Execute a deployment step. "
"Possible steps: git_pull, tests, build, deploy, rollback. "
"Each step is validated before proceeding to the next."
),
"parameters": {
"type": "object",
"properties": {
"step": {
"type": "string",
"enum": ["git_pull", "tests", "build", "deploy", "rollback"]
},
"parameters": {
"type": "object",
"properties": {
"branch": {"type": "string"},
"environment": {"type": "string", "enum": ["staging", "production"]}
}
}
},
"required": ["step"],
"additionalProperties": False
},
"strict": True
}
]
def execute_step(step: str, params: dict) -> dict:
scripts = {
"git_pull": "cd /app && git pull origin {branch}",
"tests": "cd /app && npm test",
"build": "cd /app && npm run build",
"deploy": "cd /app && ./deploy.sh {environment}",
"rollback": "cd /app && ./rollback.sh {environment}"
}
command = scripts[step].format(**params)
return execute_secure_command(command, "deployment")
Övervakning och larm
Övervakning vänder på logiken i resten av denna lektion: kommandona här är skrivskyddade, så de är ofarliga, och värdet ligger i tolkningen. En modell som läser diskutrymme, belastning och felloggar upptäcker korrelationer som en isolerad tröskelvärdeskontroll missar – vilket gör detta till den säkraste ingångspunkten för att börja använda detta verktyg.
def check_system_health() -> dict:
"""Checks system health and returns a report."""
checks = {}
# Disk space
r = execute_secure_command("df -h /", "diagnostic")
checks["disk"] = r
# Memory
r = execute_secure_command("free -m", "diagnostic")
checks["memory"] = r
# Services
for service in ["nginx", "postgresql", "redis"]:
r = execute_secure_command(
f"systemctl is-active {service}",
"diagnostic"
)
checks[f"service_{service}"] = r
return checks
# The AI analyzes the results and suggests actions
response = client.responses.create(
model="gpt-5.6-terra",
input=f"Analyze this system health report and identify issues:\n"
f"{json.dumps(check_system_health(), indent=2)}",
tools=tools
)
Viktiga punkter
- Shell-verktyget kopplar modellen till din infrastruktur
- Implementera allowlistor och blocklistor för kommandon
- Använd timeouts och begränsade arbetskataloger
- Funktionsanrop låter dig implementera Shell som ett anpassat verktyg
- Kombinera Shell med andra verktyg för kompletta DevOps-arbetsflöden