Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Shell: Udførelse af kommandoer

Lektion 18 af 20 Udvikler
På denne side
  1. Shell: Udførelse af kommandoer
  2. Koncept og arkitektur
  3. Use case: Systemdiagnose
  4. Sikring af udførelse
  5. Implementering som en brugerdefineret funktion
  6. Automatiseringsworkflows
  7. Vigtige pointer

Shell: Udførelse af kommandoer

Dette er kursets mest kraftfulde værktøj, og det eneste, hvor en fejl kan vende dets styrke mod dig. Andre værktøjer læser, beregner eller søger; dette handler på en maskine. En dårligt formuleret systemdiagnose forbliver blot en diagnose; en dårligt formuleret oprydningskommando sletter filer.

Denne lektion dækker både brug og sikkerhedsforanstaltninger, da de ikke kan adskilles. Den gyldne regel: Modellen må aldrig udføre en kommando, du ikke eksplicit har godkendt på forhånd.

Koncept og arkitektur

Forskellen fra Code Interpreter er afgørende, og det hele koges ned til ét ord: isolering. Code Interpreter kører i en engangs, netværksisoleret sandbox, hvor worst-case-scenariet er en forkert beregning. Shell kører i et miljø, du konfigurerer – potentielt din lokale maskine, potentielt en server – hvor worst-case-scenariet er en irreversibel operation.

Denne frihed er hele pointen: uden den er automatiseret udrulning og vedligeholdelse umulig. Det kræver dog, at du bevidst vælger udførelsesomfanget. En dedikeret container med begrænsede rettigheder er næsten altid det rigtige valg frem for direkte adgang til værten.

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

Use case: Systemdiagnose

# 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

Sikring af udførelse

Tre sikkerhedsforanstaltninger arbejder sammen, og ingen er tilstrækkelig alene. Allowlisten er fundamentet: Du oplister, hvad der er tilladt, frem for hvad der er forbudt, fordi en blocklist altid vil overse en variant – og det kræver kun én. En timeout forhindrer, at en hængende kommando låser systemet. En begrænset arbejdsmappe begrænser skaden, hvis en legitim kommando peger på det forkerte sted.

En fjerde foranstaltning, ikke-teknisk, men lige så værdifuld som de tre andre tilsammen: Kræv menneskelig bekræftelse for enhver destruktiv eller irreversibel operation. En model laver fejl med samme selvsikkerhed, som når den har ret.

# 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"}

Implementering som en brugerdefineret funktion

At implementere dette selv via funktionskald giver en fordel, du ikke bør betragte som en nødløsning: Valideringen lever i din kode. Du beslutter allowlisten, logningen og bekræftelsestrinnene, og du kan revidere alt. For et værktøj med dette risikoniveau er det at beholde kontrollen over kontrolpunktet at foretrække, selv når en native version bliver tilgængelig.

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)

Automatiseringsworkflows

Automatiseret udrulning

Udrulning er det mest værdifulde use case, forudsat at du forstår, hvad du delegerer. Modellen opfinder ikke proceduren: Den kæder trin sammen, du har defineret, verificerer mellemresultater og stopper ved enhver anomali. Det er en opmærksom operatør, ikke en beslutningstager.

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

Overvågning og alarmer

Overvågning vender logikken i resten af denne lektion på hovedet: Kommandoerne her er skrivebeskyttede, så de er ufarlige, og værdien ligger i fortolkningen. En model, der læser diskplads, belastning og fejllogs, spotter korrelationer, som en isoleret tærskelværdi overser – hvilket gør dette til det sikreste udgangspunkt for at komme i gang med dette værktøj.

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
)

Vigtige pointer

  • Shell-værktøjet forbinder modellen med din infrastruktur
  • Implementer allowlister og blocklister for kommandoer
  • Brug timeouts og begrænsede arbejdsmapper
  • Funktionskald lader dig implementere Shell som et brugerdefineret værktøj
  • Kombiner Shell med andre værktøjer til komplette DevOps-workflows