Documentação do Oracle Cloud Infrastructure

Criando e Usando um Sandbox

Crie um sandbox em um projeto ativo de IA Generativa, execute um comando e interrompa o runtime quando terminar.

Use a CLI ou o SDK do OCI para criar sandboxes. A Console fornece configuração de projeto, detalhes de sandbox, monitoramento e ações de ciclo de vida.

Antes de Começar

Os exemplos usam um shell que suporta a sintaxe de variável mostrada e autenticação de sessão do OCI. Execute oci session authenticate e, em seguida, defina profile_name para o perfil criado. Consulte Autenticação baseada em token para a CLI.

Para verificar se a CLI inclui os comandos, execute:

oci generative-ai-sandbox --help

Usando a CLI

Substitua COMPARTMENT_OCID e PROJECT_OCID pelos seus identificadores de recursos.

  1. Prepare um projeto com sandboxes ativados.

    Siga Configuração da Sandbox ou execute o comando a seguir. Este exemplo permite explicitamente o acesso à rede de saída com ALLOW_ALL. Selecione a política exigida pela sua carga de trabalho. Consulte 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. Registre o OCID do projeto e aguarde o projeto se tornar 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"

    Verifique lifecycle-state na resposta. Para a rede personalizada, a criação inclui o provisionamento do caminho da rede do projeto.

  3. Crie um sandbox e aguarde até que ele atinja 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"

    Este exemplo solicita uma sandbox de 30 minutos. Registre o ID de sandbox retornado para operações posteriores. Consulte Runtimes e Limites de Recursos do Sandbox para obter formas e durações.

  4. Execute um comando para verificar a 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 o código de saída e saída. Agora você pode fazer upload de arquivos e executar comandos.

  5. Quando terminar, salve os arquivos necessários e interrompa o sandbox. 
    oci --profile "$profile_name" --auth security_token --region "$region" \
  generative-ai-sandbox sandbox stop \
  --sandbox-id "$sandbox_id" \
  --is-force false

    Faça download de arquivos ou crie um instantâneo antes de interromper. Consulte Gerenciando Sandboxes para operações de ciclo de vida.

Usando o Python SDK

Este exemplo usa um projeto ativo existente com sandboxes ativados e o perfil de autenticação de sessão preparado anteriormente. Ele cria um sandbox, aguarda por ele, executa um comando e solicita uma interrupção quando terminar.

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