Pereiti prie pagrindinio turinio
Lietuvių— Pasirinkite kalbą
Meniu

Shell: vykdymas

Paskaita 18 iš 20 Kūrėjas
Šiame puslapyje
  1. Shell: vykdymas
  2. Koncepcija ir architektūra
  3. Naudojimo atvejis: sistemos diagnostika
  4. Vykdymo saugumas
  5. Įgyvendinimas kaip pasirinktinė funkcija
  6. Automatizavimo darbo eigos
  7. Svarbiausi punktai

Shell: vykdymas

Tai galingiausias šio kurso įrankis ir vienintelis, kurio klaida gali nukreipti jo galią prieš tave. Kiti įrankiai skaito, skaičiuoja arba ieško; šis veikia mašinoje. Netiksliai suformuluota sistemos diagnozė lieka tik diagnoze; netiksliai suformuluota valymo komanda ištrina failus.

Šioje pamokoje naudojimas ir apsaugos priemonės nagrinėjami kartu, nes jų atskirti negalima. Auksinė taisyklė: modelis niekada neturi vykdyti komandos, kurios tu iš anksto aiškiai neleidai.

Koncepcija ir architektūra

Skirtumas nuo „Code Interpreter“ yra esminis, ir jis sumažinamas iki vieno žodžio: izoliacija. „Code Interpreter“ veikia laikinoje, nuo tinklo izoliuotoje smėlio dėžėje, kur blogiausiu atveju gaunamas neteisingas skaičiavimas. Shell veikia aplinkoje, kurią konfigūruoji tu – tai gali būti tavo vietinė mašina arba serveris, – kur blogiausiu atveju įvyksta negrįžtama operacija.

Ši laisvė ir yra esmė: be jos automatizuotas diegimas ir priežiūra neįmanomi. Tačiau tai reikalauja sąmoningai pasirinkti vykdymo sritį. Specializuotas konteineris su ribotomis teisėmis beveik visada yra geresnis pasirinkimas nei tiesioginė prieiga prie pagrindinio kompiuterio.

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

Naudojimo atvejis: sistemos 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

Vykdymo saugumas

Trys apsaugos priemonės veikia kartu, ir nė viena iš jų nėra pakankama atskirai. Leidimų sąrašas (allowlist) yra pagrindas: tu išvardiji, kas leidžiama, o ne kas draudžiama, nes draudimų sąraše (blocklist) visada praleidžiamas koks nors variantas – ir užtenka vieno. Laiko limitas neleidžia užstrigusiai komandai pakabinti sistemai. Ribotas darbo katalogas apriboja žalą, jei legali komanda nukreipta į neteisingą vietą.

Ketvirta apsaugos priemonė, netechninė, bet verta kitų trijų kartu sudėjus: reikalauk žmogaus patvirtinimo bet kuriai destruktyviai ar negrįžtamai operacijai. Modelis klysta su tokiu pačiu užtikrintumu, kaip ir būdamas teisus.

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

Įgyvendinimas kaip pasirinktinė funkcija

Įgyvendinant tai savarankiškai naudojant funkcijų kvietimą, gauni pranašumą, kurio neturėtum laikyti atsarginiu variantu: validacija gyvena tavo kode. Tu nusprendi leidimų sąrašą, registravimą ir patvirtinimo žingsnius, ir gali audituoti viską. Įrankiui, keliančiam tokią riziką, kontrolės taško išlaikymas yra pageidautinas, net jei atsiranda natyvi 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)

Automatizavimo darbo eigos

Automatizuotas diegimas

Diegimas yra vertingiausias naudojimo atvejis, jei supranti, ką deleguoji. Modelis neišgalvoja procedūros: jis sujungia tavo apibrėžtus žingsnius, patikrina tarpinius rezultatus ir sustoja pastebėjęs bet kokią anomaliją. Tai dėmesingas operatorius, o ne sprendimų priėmėjas.

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

Stebėsena ir įspėjimai

Stebėsena apverčia šios pamokos likusios dalies logiką: čia naudojamos komandos yra tik skaitymo, todėl jos nekenksmingos, o vertė slypi interpretacijoje. Modelis, skaitantis disko vietą, apkrovą ir klaidų žurnalus, pastebi koreliacijas, kurių praleidžia izoliuota slenkstinė vertė – tai daro stebėseną saugiausiu įėjimo tašku pradedant naudoti šį įrankį.

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
)

Svarbiausi punktai

  • Shell įrankis sujungia modelį su tavo infrastruktūra
  • Įgyvendink leidimų ir draudimų sąrašus komandoms
  • Naudok laiko limitus ir ribotus darbo katalogus
  • Funkcijų kvietimas leidžia įgyvendinti Shell kaip pasirinktinį įrankį
  • Derink Shell su kitais įrankiais, kad sukurtum pilnas DevOps darbo eigas