Documentazione dell'infrastruttura Oracle Cloud

Creazione e uso di una sandbox

Creare una sandbox in un progetto di intelligenza artificiale generativa attivo, eseguire un comando e interrompere il runtime al termine.

Utilizzare l'interfaccia CLI o l'SDK OCI per creare sandbox. La console fornisce la configurazione del progetto, i dettagli della sandbox, il monitoraggio e le azioni del ciclo di vita.

Informazioni preliminari

Gli esempi utilizzano una shell che supporta la sintassi della variabile mostrata e l'autenticazione della sessione OCI. Eseguire oci session authenticate, quindi impostare profile_name sul profilo creato. Vedere Token-based Authentication for the CLI.

Per verificare che l'interfaccia CLI includa i comandi, eseguire le operazioni riportate di seguito.

oci generative-ai-sandbox --help

Uso dell'interfaccia CLI

Sostituire COMPARTMENT_OCID e PROJECT_OCID con gli identificativi delle risorse esistenti.

  1. Preparare un progetto con sandbox abilitate.

    Attenersi alla procedura Configurazione sandbox o eseguire il comando seguente. Questo esempio consente in modo esplicito l'accesso di rete in uscita con ALLOW_ALL. Selezionare il criterio richiesto dal carico di lavoro. Vedere Networking for 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. Registrare l'OCID del progetto e attendere che il progetto diventi ACTIVE. 
    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"

    Controllare lifecycle-state nella risposta. Per il networking personalizzato, la creazione include il provisioning del percorso di rete del progetto.

  3. Creare una sandbox e attendere che raggiunga RUNNING. 
    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 questo esempio viene richiesta una sandbox di 30 minuti. Registrare l'ID sandbox restituito per le operazioni successive. Per informazioni su forme e durate, vedere Esempi di sandbox e limiti di risorsa.

  4. Eseguire un comando per verificare la sandbox. 
    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

    Esaminare il codice di output e di uscita. Ora è possibile caricare i file ed eseguire i comandi.

  5. Al termine, salvare i file richiesti e arrestare la sandbox. 
    oci --profile "$profile_name" --auth security_token --region "$region" \
  generative-ai-sandbox sandbox stop \
  --sandbox-id "$sandbox_id" \
  --is-force false

    Scaricare file o creare uno snapshot prima di arrestarlo. Per informazioni sulle operazioni del ciclo di vita, vedere Gestione delle sandbox.

Utilizzo dell'SDK Python

In questo esempio viene utilizzato un progetto attivo esistente con sandbox abilitate e il profilo di autenticazione della sessione preparato in precedenza. Crea una sandbox, la attende, esegue un comando e richiede un arresto al termine.

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