Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Shell: Exekvering av kommandon

Lektion 18 av 20 Utvecklare
På denna sida
  1. Shell: Exekvering av kommandon
  2. Koncept och arkitektur
  3. Användningsfall: Systemdiagnos
  4. Säkra exekveringen
  5. Implementera som en anpassad funktion
  6. Automatiserade arbetsflöden
  7. Viktiga punkter

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