Démarrage rapide pour l'utilisation d'un ordinateur

Cette page explique comment effectuer des appels d'API directs pour créer et utiliser un environnement de bac à sable Computer Use. Dans ce guide de démarrage rapide, vous effectuez les tâches suivantes :

• Créez une instance Agent Platform pour accéder au bac à sable.
• Créez un bac à sable Computer Use.
• Générez un jeton d'accès pour le bac à sable.
• Envoyez une requête pour vérifier l'état.
• Nettoyez les ressources.

Avant de commencer

Configurez votre projet et votre environnement.

Configurer votre projet

1. In the Cloud de Confiance console, on the project selector page, select or create a Cloud de Confiance project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.

   Go to project selector

2. Verify that billing is enabled for your Cloud de Confiance project.

3. Enable the Gemini Enterprise Agent Platform API, if it is not already enabled.

   Roles required to enable APIs

   To enable APIs, you need the serviceusage.services.enable permission. If you created the project, then you likely already have this permission through the Owner role (roles/owner). Otherwise, you can get this permission through the Service Usage Admin role (roles/serviceusage.serviceUsageAdmin). Learn how to grant roles.

   Enable the API

Obtenir les rôles requis

Pour utiliser le bac à sable et générer des jetons, vous avez besoin des rôles suivants :

• Utilisateur Agent Platform (roles/aiplatform.user) sur le projet.
• Créateur de jetons du compte de service (roles/iam.serviceAccountTokenCreator) sur le compte de service utilisé pour la génération de jetons.
• Le compte de service utilisé pour la génération de jetons doit également disposer du rôle Utilisateur Agent Platform (roles/aiplatform.user) sur le projet.

Installer les bibliothèques

Installez le SDK Agent Platform :

pip install google-cloud-agentplatform>=2.0.1

Créer une instance Agent Platform

Pour utiliser le bac à sable, commencez par créer une instance Agent Platform.

import agentplatform
client = agentplatform.Client(
    project='PROJECT_ID',
    location='LOCATION',
    http_options={
        "api_version": "v1beta1",
    }
)
remote_agent = client.runtimes.create()
remote_agent_name = remote_agent.api_resource.name

Remplacez les éléments suivants :

• PROJECT_ID: ID de votre Cloud de Confiance projet.
• LOCATION : région de votre instance (par exemple, us-central1).

Pour chiffrer les données de votre bac à sable à l'aide de clés de chiffrement gérées par le client (CMEK), vous devez configurer CMEK lorsque vous créez votre instance Agent Platform. Pour en savoir plus, consultez Configurer des clés de chiffrement gérées par le client (CMEK).

Créer un modèle pour Computer Use

Créez un modèle de bac à sable que vous utiliserez lorsque vous créerez un bac à sable Computer Use.

# Create a default Computer Use sandbox template
templates_client = client.sandboxes.templates
tmplt_operation = templates_client.create(
    name=remote_agent_name,
    display_name='DISPLAY_NAME',
    config={
        "default_container_environment": {
            "default_container_category": "DEFAULT_CONTAINER_CATEGORY_COMPUTER_USE",
        },
        "egress_control_config": {
            "internet_access": True,
        },
    },
)
template_name = tmplt_operation.response.name
print(f"Created template: {template_name}")

Créer un bac à sable Computer Use

Créez un environnement de bac à sable à partir du modèle.

# Create a sandbox environment referencing the template.
# To customize the lifetime, set `ttl` to a duration string in seconds (for example, "3600s" for 1 hour).
create_operation = client.sandboxes.create(
    name=remote_agent_name,
    config={
        "sandbox_environment_template": template_name,
        "display_name": 'DISPLAY_NAME',
        "ttl": "3600s",  # Optional. Overrides the default 2-hour sandbox lifetime.
    }
)
sandbox = create_operation.response
print(f"Created sandbox environment: {sandbox.name}")
print(f"Sandbox will expire at: {sandbox.expire_time}")

Générer un jeton d'accès

Pour interagir avec le bac à sable, générez un jeton d'accès JSON Web Token (JWT) à l'aide d'un compte de service.

service_account_email = "SERVICE_ACCOUNT_EMAIL"
access_token = client.sandboxes.generate_access_token(
    service_account_email=service_account_email,
)

Remplacez SERVICE_ACCOUNT_EMAIL par l'adresse e-mail du compte de service disposant du rôle Créateur de jetons du compte de service.

Envoyer une requête au bac à sable

Envoyez une requête HTTP GET au serveur d'API du bac à sable pour vérifier son état.

response = client.sandboxes.send_command(
    http_method="GET",
    access_token=access_token,
    sandbox_environment=sandbox
)
print(f"Sandbox response: {response.body}")

Envoyez une requête HTTP POST pour accéder à une page spécifique.

data = {"command": "Page.navigate", "params": {"url": "https://example.com"}}

response = client.sandboxes.send_command(
    http_method="POST",
    path="cdp",
    access_token=access_token,
    request_dict=data,
    sandbox_environment=sandbox
)

Le tableau suivant répertorie les méthodes et chemins supplémentaires que vous pouvez envoyer à votre bac à sable :

Pour en savoir plus sur les commandes et le format CDP compatibles, consultez le site CDP.

Libérer de l'espace

Pour éviter que des frais ne vous soient facturés, supprimez les ressources créées dans ce guide de démarrage rapide.

client.sandboxes.delete(name=sandbox.name)
remote_agent.delete()

Étape suivante

• Présentation des bacs à sable Computer Use
• Configurer VPC Service Controls
• Configurer des clés de chiffrement gérées par le client (CMEK)