Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Shell: Εκτέλεση Εντολών

Μάθημα 18 / 20 Για developers
Σε αυτήν τη σελίδα
  1. Shell: Εκτέλεση Εντολών
  2. Έννοια και Αρχιτεκτονική
  3. Περίπτωση Χρήσης: Διάγνωση Συστήματος
  4. Ασφάλιση της Εκτέλεσης
  5. Υλοποίηση ως Προσαρμοσμένη Συνάρτηση
  6. Ροές Εργασίας Αυτοματοποίησης
  7. Βασικά σημεία

Shell: Εκτέλεση Εντολών

Αυτό είναι το πιο ισχυρό εργαλείο του μαθήματος και το μοναδικό όπου ένα λάθος μπορεί να στρέψει τη δύναμή του εναντίον σας. Άλλα εργαλεία διαβάζουν, υπολογίζουν ή αναζητούν· αυτό δρα πάνω σε ένα μηχάνημα. Μια κακώς διατυπωμένη διάγνωση συστήματος παραμένει απλώς μια διάγνωση· μια κακώς διατυπωμένη εντολή καθαρισμού διαγράφει αρχεία.

Αυτό το μάθημα καλύπτει τη χρήση και τα μέτρα ασφαλείας ταυτόχρονα, διότι δεν μπορούν να διαχωριστούν. Ο χρυσός κανόνας: το μοντέλο δεν πρέπει ποτέ να εκτελεί μια εντολή την οποία δεν έχετε ρητά εξουσιοδοτήσει εκ των προτέρων.

Έννοια και Αρχιτεκτονική

Η διαφορά από τον Code Interpreter είναι κρίσιμη και συνοψίζεται σε μία λέξη: απομόνωση. Ο Code Interpreter εκτελείται σε ένα προσωρινό sandbox απομονωμένο από το δίκτυο, όπου το χειρότερο σενάριο είναι ένας λανθασμένος υπολογισμός. Το Shell εκτελείται σε ένα περιβάλλον που διαμορφώνετε εσείς—πιθανόν στο τοπικό σας μηχάνημα, πιθανόν σε έναν διακομιστή—όπου το χειρότερο σενάριο είναι μια μη αναστρέψιμη ενέργεια.

Αυτή η ελευθερία είναι ο σκοπός: χωρίς αυτήν, η αυτοματοποιημένη ανάπτυξη και συντήρηση είναι αδύνατη. Ωστόσο, απαιτεί να επιλέξετε συνειδητά το πεδίο εκτέλεσης. Ένας αφιερωμένος container με περιορισμένα δικαιώματα είναι σχεδόν πάντα η σωστή επιλογή έναντι της άμεσης πρόσβασης στον κεντρικό υπολογιστή (host).

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

Περίπτωση Χρήσης: Διάγνωση Συστήματος

# 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

Ασφάλιση της Εκτέλεσης

Τρία μέτρα ασφαλείας λειτουργούν συνεργατικά και κανένα δεν αρκεί από μόνο του. Η λευκή λίστα (allowlist) είναι η βάση: καταγράφετε τι επιτρέπεται αντί για το τι απαγορεύεται, διότι μια μαύρη λίστα (blocklist) πάντα παραλείπει κάποια παραλλαγή—και αρκεί μόνο μία. Ένα χρονικό όριο (timeout) εμποδίζει μια εντολή που έχει κολλήσει να μπλοκάρει το σύστημα. Ένας περιορισμένος κατάλογος εργασίας περιορίζει τις ζημιές εάν μια νόμιμη εντολή δείξει σε λάθος τοποθεσία.

Ένα τέταρτο μέτρο, μη τεχνικό αλλά άξιο όσο τα άλλα τρία μαζί: απαιτείτε ανθρώπινη επιβεβαίωση για κάθε καταστροφική ή μη αναστρέψιμη ενέργεια. Ένα μοντέλο κάνει λάθη με την ίδια αυτοπεποίθηση που έχει όταν έχει δίκιο.

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

Υλοποίηση ως Προσαρμοσμένη Συνάρτηση

Η υλοποίηση αυτού από εσάς μέσω κλήσης συνάρτησης (function calling) προσφέρει ένα πλεονέκτημα που δεν πρέπει να θεωρείτε ως εναλλακτική λύση: η επικύρωση ζει στον κώδικα σας. Εσείς αποφασίζετε τη λευκή λίστα, την καταγραφή συμβάντων (logging) και τα βήματα επιβεβαίωσης, και μπορείτε να ελέγξετε τα πάντα. Για ένα εργαλείο με αυτό το επίπεδο ρίσκου, η διατήρηση του ελέγχου στο σημείο ελέγχου είναι προτιμότερη, ακόμη και όταν γίνει διαθέσιμη μια εγγενής έκδοση.

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)

Ροές Εργασίας Αυτοματοποίησης

Αυτοματοποιημένη Ανάπτυξη (Deployment)

Η ανάπτυξη είναι η πιο πολύτιμη περίπτωση χρήσης, υπό την προϋπόθεση ότι κατανοείτε τι αναθέτετε. Το μοντέλο δεν επινοεί τη διαδικασία: αλυσιδώνει βήματα που έχετε ορίσει εσείς, επαληθεύει τα ενδιάμεσα αποτελέσματα και σταματά σε οποιαδήποτε ανωμαλία. Είναι ένας προσεκτικός χειριστής, όχι ένας λήπτης αποφάσεων.

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

Παρακολούθηση και Ειδοποιήσεις

Η παρακολούθηση αντιστρέφει τη λογική του υπόλοιπου μαθήματος: οι εντολές εδώ είναι μόνο για ανάγνωση, επομένως είναι ακίνδυνες, και η αξία έγκειται στην ερμηνεία. Ένα μοντέλο που διαβάζει τον χώρο δίσκου, το φορτίο και τα αρχεία καταγραφής σφαλμάτων εντοπίζει συσχετίσεις που ένα μεμονωμένο όριο παραλείπει—καθιστώντας το το ασφαλέστερο σημείο εκκίνησης για να ξεκινήσετε με αυτό το εργαλείο.

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
)

Βασικά σημεία

  • Το εργαλείο Shell συνδέει το μοντέλο με τις υποδομές σας
  • Υλοποιήστε λευκές και μαύρες λίστες για εντολές
  • Χρησιμοποιήστε χρονικά όρια και περιορισμένους καταλόγους εργασίας
  • Η κλήση συναρτήσεων σας επιτρέπει να υλοποιήσετε το Shell ως προσαρμοσμένο εργαλείο
  • Συνδυάστε το Shell με άλλα εργαλεία για πλήρεις ροές εργασίας DevOps