Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Shell: Parancsvégrehajtás

18. lecke 20 közül Fejlesztő
Ezen az oldalon
  1. Shell: Parancsvégrehajtás
  2. Fogalom és architektúra
  3. Használati eset: Rendszerdiagnózis
  4. A végrehajtás biztosítása
  5. Megvalósítás egyéni függvényként
  6. Automatizálási munkafolyamatok
  7. Főbb megállapítások

Shell: Parancsvégrehajtás

Ez a tanfolyam leghatalmasabb eszköze, és az egyetlen, ahol egy hiba a saját erődet fordíthatja ellened. Míg a többi eszköz csak olvas, számít vagy keres, ez cselekszik a gépen. Egy rosszul megfogalmazott rendszerdiagnózis csupán diagnózis marad; egy rosszul megfogalmazott tisztító parancs azonban fájlokat töröl.

Ebben a leckében a használatot és a biztonsági intézkedéseket együtt tárgyaljuk, mert elválaszthatatlanok. Az aranyszabály: a modell soha ne hajtson végre olyan parancsot, amelyet előzetesen kifejezetten nem engedélyeztél.

Fogalom és architektúra

A Code Interpreterrel való különbség kritikus fontosságú, és egyetlen szóban összegezhető: elszigeteltség. A Code Interpreter egy eldobható, hálózatilag elszigetelt homokozóban fut, ahol a legrosszabb eset egy hibás számítás. Ezzel szemben a Shell egy általam konfigurált környezetben fut – lehet ez a helyi géped vagy egy szerver –, ahol a legrosszabb eset egy visszafordíthatatlan művelet.

Ez a szabadság a lényeg: nélküle az automatizált telepítés és karbantartás lehetetlen. Ugyanakkor tudatosan kell megválasztanod a végrehajtási hatókört. Egy dedikált, korlátozott jogosultságokkal rendelkező konténer szinte mindig jobb választás, mint a közvetlen hoszt hozzáférés.

from openai import OpenAI

client = OpenAI()

# A Shell eszközt az Agents SDK-n keresztül használjuk,
# mert ellenőrzött végrehajtási környezetet igényel
from agents import Agent, Runner

agent = Agent(
    name="devops-assistant",
    model="gpt-5.6-terra",
    instructions=(
        "Te egy DevOps asszisztens vagy. Rendszerparancsokat hajtasz végre "
        "az infrastruktúra problémáinak diagnosztizálására és megoldására. "
        "Minden parancs végrehajtása előtt magyarázd el azt."
    ),
    tools=[{"type": "shell"}]
)

Használati eset: Rendszerdiagnózis

# Az ügynök diagnosztikai parancsokat hajthat végre
agent = Agent(
    name="diagnostic",
    model="gpt-5.6-terra",
    instructions=(
        "Diagnosztizáld a rendszer állapotát megfelelő parancsok végrehajtásával. "
        "Kezdd az alapvető ellenőrzésekkel (lemez, memória, CPU), "
        "majd a tünetek alapján mélyülj el jobban."
    ),
    tools=[{"type": "shell"}]
)

# Az ügynök olyan parancsokat fog végrehajtani, mint:
# df -h          -> lemezterület
# free -m        -> memória
# top -bn1       -> CPU terhelés
# systemctl status nginx  -> szolgáltatás állapota

A végrehajtás biztosítása

Három biztonsági intézkedés működik együtt, és egyik sem elegendő önmagában. Az engedélyezési lista (allowlist) az alap: felsorolod, mi engedélyezett, nem pedig azt, mi tiltott, mert egy tiltólista (blocklist) mindig kihagyhat egy variánst – és csak egy hiba is elég. Egy időtúllépés (timeout) megakadályozza, hogy egy beragadt parancs lefagyassza a rendszert. Egy korlátozott munkakönyvtár korlátozza a kárt, ha egy legitim parancs rossz helyre mutat.

Egy negyedik, nem technikai, de a másik hármat együttvéve is felülmúló biztonsági intézkedés: kérj emberi megerősítést minden romboló vagy visszafordíthatatlan művelethez. A modell ugyanolyan magabiztossággal követ el hibákat, mint ahogy az igazat mondja.

# Minta: ellenőrzést végző wrapper függvény
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:
    """Parancs végrehajtása biztonsági ellenőrzéssel."""
    # Parancs elemzése
    parts = shlex.split(command)
    executable = parts[0]

    # Tiltások ellenőrzése
    if executable in FORBIDDEN_COMMANDS:
        return {
            "error": f"Tiltott parancs: {executable}",
            "reason": "Ez a parancs szerepel a tiltólistán"
        }

    # Jogosultságok ellenőrzése
    allowed = ALLOWED_COMMANDS.get(category, [])
    if executable not in allowed:
        return {
            "error": f"A parancs nem engedélyezett a(z) '{category}' kategóriában",
            "allowed": allowed
        }

    # Végrehajtás időtúllépéssel
    try:
        result = subprocess.run(
            parts,
            capture_output=True,
            text=True,
            timeout=30,
            cwd="/tmp"  # Korlátozott munkakönyvtár
        )
        return {
            "stdout": result.stdout,
            "stderr": result.stderr,
            "return_code": result.returncode
        }
    except subprocess.TimeoutExpired:
        return {"error": "Időtúllépés: a parancs meghaladta a 30 másodpercet"}

Megvalósítás egyéni függvényként

Ennek saját magad általi megvalósítása függvényhívással (function calling) egy előnnyel jár, amit nem szabad tartalék megoldásnak tekintened: az ellenőrzés a te kódodban él. Te döntöd el az engedélyezési listát, a naplózást és a megerősítési lépéseket, és mindent auditálhatsz. Egy ekkora kockázatú eszköz esetén előnyösebb, ha megtartod az ellenőrzést a ellenőrzőpont felett, még akkor is, ha elérhetővé válik egy natív verzió.

tools = [
    {
        "type": "function",
        "name": "execute_command",
        "description": (
            "Shell parancs végrehajtása a szerveren. "
            "Engedélyezett parancsok: rendszerdiagnosztika (df, free, top, uptime, ps), "
            "fájlolvasás (ls, cat, head, tail, grep), "
            "hálózat (curl, ping, netstat). "
            "A romboló parancsok tiltottak."
        ),
        "parameters": {
            "type": "object",
            "properties": {
                "command": {
                    "type": "string",
                    "description": "A végrehajtandó shell parancs"
                },
                "directory": {
                    "type": "string",
                    "description": "Munkakönyvtár (alapértelmezett: /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

# Teljes ciklus
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Ellenőrizd a lemezterületet és az elérhető memóriát",
    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álási munkafolyamatok

Automatizált telepítés

A telepítés a legértékesebb használati eset, feltéve, hogy tisztában vagy azzal, mit delegálsz. A modell nem találja fel az eljárást: összeláncolja az általad meghatározott lépéseket, ellenőrzi a közbenső kimeneteket, és bármilyen rendellenesség esetén megáll. Ez egy figyelmes operátor, nem pedig döntéshozó.

tools_deploy = [
    {
        "type": "function",
        "name": "execute_deploy_step",
        "description": (
            "Egy telepítési lépés végrehajtása. "
            "Lehetséges lépések: git_pull, tests, build, deploy, rollback. "
            "Minden lépést ellenőrzünk, mielőtt továbblépnénk a következőre."
        ),
        "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")

Monitorozás és riasztások

A monitorozás megfordítja ennek a leckének a többi részében látott logikát: az itt szereplő parancsok csak olvashatók, így ártalmatlanok, és az érték az értelmezésben rejlik. Egy modell, amely lemezterületet, terhelést és hibanaplókat olvas, olyan összefüggéseket fedez fel, amelyeket egy elszigetelt küszöbérték figyelmen kívül hagy – ezzel ez a legbiztonságosabb belépési pont az eszköz használatának megkezdéséhez.

def check_system_health() -> dict:
    """Rendszerállapot ellenőrzése és jelentés visszaadása."""
    checks = {}

    # Lemezterület
    r = execute_secure_command("df -h /", "diagnostic")
    checks["disk"] = r

    # Memória
    r = execute_secure_command("free -m", "diagnostic")
    checks["memory"] = r

    # Szolgáltatások
    for service in ["nginx", "postgresql", "redis"]:
        r = execute_secure_command(
            f"systemctl is-active {service}",
            "diagnostic"
        )
        checks[f"service_{service}"] = r

    return checks

# Az AI elemzi az eredményeket és műveleteket javasol
response = client.responses.create(
    model="gpt-5.6-terra",
    input=f"Elemezd ezt a rendszerállapot-jelentést és azonosítsd a problémákat:\n"
          f"{json.dumps(check_system_health(), indent=2)}",
    tools=tools
)

Főbb megállapítások

  • A Shell eszköz összeköti a modellt az infrastruktúráddal
  • Hozz létre engedélyezési és tiltólistákat a parancsokhoz
  • Használj időtúllépéseket és korlátozott munkakönyvtárakat
  • A függvényhívás lehetővé teszi a Shell egyéni eszközként való megvalósítását
  • Kombináld a Shellt más eszközökkel a teljes DevOps munkafolyamatokhoz