Sandboxes erstellen und verwenden

Erstellen Sie eine Sandbox in einem aktiven generativen KI-Projekt, führen Sie einen Befehl aus, und stoppen Sie die Laufzeit, wenn Sie fertig sind.

Mit der OCI-CLI oder dem SDK können Sie Sandboxes erstellen. Die Konsole bietet Projektkonfiguration, Sandbox-Details, Überwachung und Lebenszyklusaktionen.

Bevor Sie beginnen

In den Beispielen wird eine Shell verwendet, die die gezeigte Variablensyntax und die OCI-Sessionauthentifizierung unterstützt. Führen Sie oci session authenticate aus, und setzen Sie profile_name auf das von Ihnen erstellte Profil. Siehe Tokenbasierte Authentifizierung für die CLI.

Um zu prüfen, ob die CLI die Befehle enthält, führen Sie Folgendes aus:

oci generative-ai-sandbox --help

CLI verwenden

Ersetzen Sie COMPARTMENT_OCID und PROJECT_OCID durch Ihre Ressourcen-IDs.

  1. Vorbereiten eines Projekts mit aktivierten Sandboxes

    Befolgen Sie Sandbox Configuration, oder führen Sie den folgenden Befehl aus. Dieses Beispiel ermöglicht explizit den ausgehenden Netzwerkzugriff mit ALLOW_ALL. Wählen Sie die Policy aus, die für Ihre Workload erforderlich ist. Siehe Networking für Sandboxes.

    profile_name="DEFAULT"
    region="us-chicago-1"
    compartment_id="COMPARTMENT_OCID"
    
    oci --profile "$profile_name" --auth security_token --region "$region" \
      generative-ai generative-ai-project create \
      --compartment-id "$compartment_id" \
      --display-name sandbox-project \
      --sandbox-config '{"isEnabled":true,"sandboxOutboundNetworkingConfig":{"networkMode":"MANAGED","networkPolicy":{"mode":"ALLOW_ALL"}}}'
  2. Notieren Sie sich die Projekt-OCID, und warten Sie, bis das Projekt ACTIVE wird.
    project_id="PROJECT_OCID"
    
    oci --profile "$profile_name" --auth security_token --region "$region" \
      generative-ai generative-ai-project get \
      --generative-ai-project-id "$project_id"

    Prüfen Sie lifecycle-state in der Antwort. Bei benutzerdefiniertem Networking umfasst die Erstellung das Provisioning des Projektnetzwerkpfads.

  3. Erstellen Sie eine Sandbox, und warten Sie, bis sie RUNNING erreicht.
    sandbox_id=$(oci --profile "$profile_name" --auth security_token --region "$region" \
      generative-ai-sandbox sandbox create \
      --project-id "$project_id" \
      --display-name my-sandbox \
      --runtime python-3.11 \
      --shape SMALL \
      --expiration-duration PT30M \
      --wait-for-state RUNNING \
      --query 'data.id' --raw-output)
    
    printf '%s\n' "$sandbox_id"

    In diesem Beispiel wird eine 30-minütige Sandbox angefordert. Notieren Sie die zurückgegebene Sandbox-ID für spätere Vorgänge. Ausprägungen und Dauer finden Sie unter Sandbox-Laufzeiten und Ressourcenlimits.

  4. Führen Sie einen Befehl aus, um die Sandbox zu prüfen.
    oci --profile "$profile_name" --auth security_token --region "$region" \
      generative-ai-sandbox sandbox-command run-and-wait \
      --sandbox-id "$sandbox_id" \
      --command "python3 --version" \
      --timeout PT1M

    Prüfen Sie die Ausgabe und den Beendigungscode. Sie können jetzt Dateien hochladen und Befehle ausführen.

  5. Speichern Sie die erforderlichen Dateien, und stoppen Sie die Sandbox.
    oci --profile "$profile_name" --auth security_token --region "$region" \
      generative-ai-sandbox sandbox stop \
      --sandbox-id "$sandbox_id" \
      --is-force false

    Laden Sie Dateien herunter, oder erstellen Sie ein Snapshot, bevor Sie den Vorgang stoppen. Informationen zu Lebenszyklusvorgängen finden Sie unter Sandboxes verwalten.

Python-SDK verwenden

In diesem Beispiel wird ein vorhandenes aktives Projekt mit aktivierten Sandboxes und dem zuvor vorbereiteten Sessionauthentifizierungsprofil verwendet. Es erstellt eine Sandbox, wartet darauf, führt einen Befehl aus und fordert nach Abschluss einen Stopp an.

from pathlib import Path
import time
import warnings

import oci
from oci.generative_ai_sandbox import GenerativeAiSandboxClient
from oci.generative_ai_sandbox.models import (
    CreateSandboxDetails,
    RunSandboxCommandDetails,
    StopSandboxDetails,
)

profile_name = "DEFAULT"
project_id = "PROJECT_OCID"
region = "us-chicago-1"
config = oci.config.from_file(profile_name=profile_name)
key = oci.signer.load_private_key_from_file(config["key_file"])
token = Path(config["security_token_file"]).expanduser().read_text().strip()
signer = oci.auth.signers.SecurityTokenSigner(token, key)
client = GenerativeAiSandboxClient(
    config=config,
    signer=signer,
    service_endpoint=f"https://inference.generativeai.{region}.oci.oraclecloud.com",
)

created = client.create_sandbox(
    project_id,
    CreateSandboxDetails(
        display_name="my-sandbox",
        runtime="python-3.11",
        shape="SMALL",
        expiration_duration="PT30M",
    ),
).data
sandbox_id = created.id
print(sandbox_id)

state = created.lifecycle_state
try:
    # This example waits up to five minutes for creation.
    deadline = time.monotonic() + 300
    while time.monotonic() < deadline:
        sandbox = client.get_sandbox(sandbox_id).data
        state = sandbox.lifecycle_state
        if state == "RUNNING":
            break
        if state in {"FAILED", "STOPPING", "STOPPED", "DELETING", "DELETED"}:
            raise RuntimeError(f"Sandbox state: {sandbox.lifecycle_state}")
        time.sleep(2)
    else:
        raise TimeoutError("Sandbox didn't reach RUNNING within five minutes")

    result = client.run_sandbox_command_and_wait(
        sandbox_id,
        RunSandboxCommandDetails(command="python3 --version", timeout="PT1M"),
    ).data
    print(result.output.stdout)
    print(result.output.stderr)
    print(result.output.exit_code)
finally:
    # Attempt cleanup without masking an earlier error.
    if state not in {"FAILED", "STOPPING", "STOPPED", "DELETING", "DELETED"}:
        try:
            client.stop_sandbox(sandbox_id, StopSandboxDetails(is_force=False))
        except Exception as cleanup_error:
            warnings.warn(f"Check sandbox {sandbox_id}: stop failed: {cleanup_error}")