Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Shell: Komandu izpilde

Nodarbība 18 no 20 Programmētājs
Šajā lapā
  1. Shell: Komandu izpilde
  2. Jēdziens un arhitektūra
  3. Lietošanas gadījums: Sistēmas diagnostika
  4. Izpildes drošināšana
  5. Implementēšana kā pielāgota funkcija
  6. Automatizācijas darbplūsmas
  7. Galvenās atziņas

Shell: Komandu izpilde

Šis ir visspēcīgākais rīks šajā kursā un vienīgais, kur kļūda var vērst tā spēku pret tevi. Citi rīki lasa, aprēķina vai meklē; šis darbojas ar mašīnu. Slikti formulēta sistēmas diagnostika paliek tikai diagnostika; slikti formulēta tīrīšanas komanda dzēš failus.

Šajā nodarbībā lietojums un drošības pasākumi tiek aplūkoti kopā, jo tos nevar atdalīt. Zelta likums: modelim nekad nedrīkst ļaut izpildīt komandu, ko iepriekš nav tieši apstiprinājis.

Jēdziens un arhitektūra

Atšķirība no Code Interpreter ir kritiska, un tā slēpjas vienā vārdā: izolācija. Code Interpreter darbojas iznīcināmā, no tīkla izolētā smilškastē, kur sliktākais scenārijs ir nepareizs aprēķins. Shell darbojas vidē, ko konfigurē tu – potenciāli tavā lokālajā mašīnā, potenciāli serverī – kur sliktākais scenārijs ir neatgriezeniska operācija.

Šī brīvība ir galvenais mērķis: bez tās automatizēta izvēršana un uzturēšana nav iespējama. Tomēr tas prasa, lai tu apzināti izvēlētos izpildes darbības jomu. Dedicēts konteiners ar ierobežotām privilēģijām gandrīz vienmēr ir pareizā izvēle salīdzinājumā ar tiešu piekļuvi saimniekdatoram.

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

Lietošanas gadījums: Sistēmas diagnostika

# 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

Izpildes drošināšana

Trīs drošības pasākumi darbojas kopā, un neviens no tiem atsevišķi nav pietiekams. Atļauto saraksts (allowlist) ir pamats: tu uzskaiti, kas ir atļauts, nevis kas ir aizliegts, jo aizliegto saraksts (blocklist) vienmēr palaidīs garām kādu variantu – un pietiek tikai ar vienu. Noildze (timeout) novērš sistēmas iestrēgšanu, ja komanda iesprūst. Ierobežota darba direktorija ierobežo zaudējumus, ja leģitīma komanda norāda uz nepareizu atrašanās vietu.

Ceturtais drošības pasākums ir netehnisks, bet vērts tikpat daudz cik pārējie trīs kopā: piepras cilvēka apstiprinājumu jebkurai destruktīvai vai neatgriezeniskai operācijai. Modelis pieļauj kļūdas ar tādu pašu pārliecību, ar kādu tas ir taisnībā.

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

Implementēšana kā pielāgota funkcija

Šī rīka pašrocīga implementēšana, izmantojot funkciju izsaukumus, piedāvā priekšrocību, ko nevajadzētu uzskatīt par rezerves variantu: validācija dzīvo tavo kodā. Tu nosaki atļauto sarakstu, žurnālēšanu un apstiprināšanas soļus, un vari auditēt visu. Rīkam ar tik augstu riska līmeni ir vēlams saglabāt kontroli pār kontrolpunktu, pat ja kļūst pieejama natīvā versija.

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)

Automatizācijas darbplūsmas

Automatizēta izvēršana

Izvēršana ir vērtīgākais lietošanas gadījums, ja vien saproti, ko tieši deleģē. Modelis neizgudro procedūru: tas savieno kopā soļus, kurus esi definējis tu, pārbauda starpposma rezultātus un apstājas pie jebkuras anomālijas. Tas ir uzmanīgs operators, nevis lēmumu pieņēmējs.

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

Uzraudzība un brīdinājumi

Uzraudzība apvērš šīs nodarbības pārējās daļas loģiku: šeit komandas ir tikai lasāmas, tāpēc tās ir nekaitīgas, un vērtība slēpjas interpretācijā. Modelis, kas lasa diska vietu, slodzi un kļūdu žurnālus, pamana korelacijas, ko izolēts slieksnis nepamanītu – tas padara to par drošāko ieejas punktu, lai sāktu strādāt ar šo rīku.

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
)

Galvenās atziņas

  • Shell rīks savieno modeli ar tavu infrastruktūru
  • Implementē atļauto un aizliegto komandu sarakstus
  • Izmanto noildzes un ierobežotas darba direktorijas
  • Funkciju izsaukumi ļauj implementēt Shell kā pielāgotu rīku
  • Apvieno Shell ar citiem rīkiem, lai izveidotu pilnvērtīgas DevOps darbplūsmas