Documentation sur Oracle Cloud Infrastructure

Créer et utiliser un modèle d'environnement restreint

Créez un bac à sable dans un projet d'intelligence artificielle générative actif, exécutez une commande et arrêtez l'exécution lorsque vous avez terminé.

Utilisez l'interface de ligne de commande ou la trousse SDK OCI pour créer des bacs à sable. La console fournit la configuration du projet, les détails du bac à sable, la surveillance et les actions de cycle de vie.

Avant de commencer

Les exemples utilisent un interpréteur de commandes qui prend en charge la syntaxe de variable affichée et l'authentification de session OCI. Exécutez oci session authenticate, puis réglez profile_name au profil que vous avez créé. Voir Authentification basée sur un jeton pour l'interface de ligne de commande.

Pour vérifier que votre interface de ligne de commande inclut les commandes, exécutez :

oci generative-ai-sandbox --help

Utilisation de l'interface de ligne de commande

Remplacez COMPARTMENT_OCID et PROJECT_OCID par vos identificateurs de ressource.

  1. Préparer un projet avec des bacs à sable activés.

    Suivez Configuration du bac à sable ou exécutez la commande suivante. Cet exemple autorise explicitement l'accès au réseau sortant avec ALLOW_ALL. Sélectionnez la politique requise par votre charge de travail. Voir Réseau pour les bacs à sable.

    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. Enregistrez l'OCID du projet et attendez que le projet devienne 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"

    Vérifiez lifecycle-state dans la réponse. Pour le réseau personnalisé, la création inclut le provisionnement du chemin réseau du projet.

  3. Créez un bac à sable et attendez qu'il atteigne 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"

    Cet exemple demande un bac à sable de 30 minutes. Enregistrez l'ID bac à sable retourné pour les opérations ultérieures. Voir Exécutions de bac à sable et limites de ressources pour connaître les formes et les durées.

  4. Exécutez une commande pour vérifier le bac à sable. 
    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

    Vérifiez le code de sortie et de sortie. Vous pouvez maintenant charger des fichiers et exécuter des commandes.

  5. Lorsque vous avez terminé, enregistrez les fichiers requis et arrêtez le bac à sable. 
    oci --profile "$profile_name" --auth security_token --region "$region" \
  generative-ai-sandbox sandbox stop \
  --sandbox-id "$sandbox_id" \
  --is-force false

    Téléchargez des fichiers ou créez un instantané avant de l'arrêter. Voir Gestion des bacs à sable pour les opérations de cycle de vie.

Utilisation de la trousse SDK Python

Cet exemple utilise un projet actif existant avec bacs à sable activés et le profil d'authentification de session préparé précédemment. Il crée un bac à sable, l'attend, exécute une commande et demande un arrêt une fois terminé.

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