Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Shell: Izvršavanje naredbi

Lekcija 18 od 20 Programer
Na ovoj stranici
  1. Shell: Izvršavanje naredbi
  2. Koncept i arhitektura
  3. Slučaj upotrebe: Dijagnostika sustava
  4. Osiguravanje izvršavanja
  5. Implementacija kao prilagođene funkcije
  6. Radni tijekovi automatizacije
  7. Ključne točke

Shell: Izvršavanje naredbi

Ovo je najmoćniji alat u ovom tečaju i jedini u kojem greška može okrenuti njegovu snagu protiv tebe. Ostali alati čitaju, računaju ili pretražuju; ovaj djeluje na stroju. Loše formulirana dijagnoza sustava ostaje samo dijagnoza; loše formulirana naredba za čišćenje briše datoteke.

Ova lekcija pokriva korištenje i zaštitne mjere zajedno jer se one ne mogu razdvojiti. Zlatno pravilo: model nikada ne smije izvršiti naredbu koju nisi izričito unaprijed odobrio.

Koncept i arhitektura

Razlika u odnosu na Code Interpreter je ključna, a svodi se na jednu riječ: izolacija. Code Interpreter radi u privremenom, mrežno izoliranom sandboxu gdje je najgori scenarij pogrešan izračun. Shell radi u okruženju koje ti konfiguriraš – potencijalno tvojem lokalnom stroju, potencijalno poslužitelju – gdje je najgori scenarij nepovratna operacija.

Ta sloboda je poanta: bez nje su automatizirano uvođenje i održavanje nemogući. Međutim, to zahtijeva da svjesno odabereš opseg izvršavanja. Namjenski kontejner s ograničenim privilegijama gotovo je uvijek ispravan izbor u odnosu na izravan pristup domaćinu.

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

Slučaj upotrebe: Dijagnostika sustava

# 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

Osiguravanje izvršavanja

Tri zaštitne mjere rade zajedno, a nijedna sama po sebi nije dovoljna. Popis dopuštenih (allowlist) temelj je: nabrajaš što je dopušteno, a ne što je zabranjeno, jer popis blokiranih (blocklist) uvijek propusti neku varijantu – a dovoljna je samo jedna. Vremensko ograničenje (timeout) sprječava da zaglavljena naredba objesi sustav. Ograničeni radni direktorij ograničava štetu ako legitimna naredba pokazuje na pogrešnu lokaciju.

Četvrta zaštita, netehnička, ali vrijedna koliko i ostale tri zajedno: zahtijevaj ljudsku potvrdu za svaku destruktivnu ili nepovratnu operaciju. Model griješi s istom sigurnošću kao i kada je u pravu.

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

Implementacija kao prilagođene funkcije

Samostalna implementacija putem poziva funkcija (function calling) nudi prednost koju ne bi smio smatrati rezervnom opcijom: validacija živi u tvom kodu. Ti odlučuješ o popisu dopuštenih, zapisivanju događaja (logging) i koracima potvrde, te možeš revidirati sve. Za alat s ovom razinom rizika, zadržavanje kontrole nad kontrolnom točkom poželjnije je, čak i kada postane dostupna izvorna verzija.

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)

Radni tijekovi automatizacije

Automatizirano uvođenje (Deployment)

Uvođenje je najvredniji slučaj upotrebe, pod uvjetom da razumiješ što delegiraš. Model ne izmišlja postupak: on povezuje korake koje si definirao, provjerava međurezultate i zaustavlja se pri svakoj anomaliji. To je pažljiv operater, a ne donositelj odluka.

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

Nadzor i upozorenja

Nadzor preokreće logiku ostatka ove lekcije: naredbe ovdje su samo za čitanje, stoga su bezopasne, a vrijednost leži u tumačenju. Model koji čita zauzetost diska, opterećenje i zapisnike pogrešaka uočava korelacije koje izolirani prag propušta – što ovo čini najsigurnijom ulaznom točkom za početak rada s ovim alatom.

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
)

Ključne točke

  • Alat Shell povezuje model s tvojom infrastrukturom
  • Implementiraj popise dopuštenih i zabranjenih naredbi
  • Koristi vremenska ograničenja i ograničene radne direktorije
  • Pozivi funkcija omogućuju ti implementaciju Shella kao prilagođenog alata
  • Kombiniraj Shell s drugim alatima za kompletne DevOps radne tijekove