Documentación de Oracle Cloud Infrastructure

Creación y Uso de un Sandbox

Cree un sandbox en un proyecto de IA generativa activo, ejecute un comando y detenga el tiempo de ejecución cuando haya terminado.

Utilice la CLI o el SDK de OCI para crear sandboxes. La consola proporciona la configuración del proyecto, los detalles del sandbox, la supervisión y las acciones del ciclo de vida.

Antes de empezar

Los ejemplos utilizan un shell que soporta la sintaxis de variable mostrada y la autenticación de sesión de OCI. Ejecute oci session authenticate y, a continuación, defina profile_name en el perfil que ha creado. Consulte Autenticación basada en tokens para la CLI.

Para comprobar que la CLI incluye los comandos, ejecute:

oci generative-ai-sandbox --help

Uso de la CLI

Sustituya COMPARTMENT_OCID y PROJECT_OCID por sus identificadores de recursos.

  1. Prepare un proyecto con sandboxes activados.

    Siga la configuración de sandbox o ejecute el siguiente comando. Este ejemplo permite explícitamente el acceso de red saliente con ALLOW_ALL. Seleccione la política que necesita la carga de trabajo. Consulte Redes para 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. Registre el OCID del proyecto y espere a que el proyecto se convierta en 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"

    Marque lifecycle-state en la respuesta. Para redes personalizadas, la creación incluye el aprovisionamiento de la ruta de red del proyecto.

  3. Cree un sandbox y espere a que llegue a 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"

    En este ejemplo se solicita un sandbox de 30 minutos. Registre el ID de entorno de prueba devuelto para operaciones posteriores. Consulte Tiempos de ejecución de sandbox y límites de recursos para obtener información sobre unidades y duraciones.

  4. Ejecute un comando para verificar el 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

    Revise el código de salida y salida. Ahora puede cargar archivos y ejecutar comandos.

  5. Cuando haya terminado, guarde los archivos necesarios y detenga el sandbox. 
    oci --profile "$profile_name" --auth security_token --region "$region" \
  generative-ai-sandbox sandbox stop \
  --sandbox-id "$sandbox_id" \
  --is-force false

    Descargue archivos o cree una instantánea antes de detenerse. Consulte Gestión de sandboxes para conocer las operaciones de ciclo de vida.

Uso del SDK de Python

En este ejemplo, se utiliza un proyecto activo existente con sandboxes activados y el perfil de autenticación de sesión preparado anteriormente. Crea un sandbox, lo espera, ejecuta un comando y solicita una parada cuando finaliza.

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