S'authentifier à l'aide d'OAuth en trois étapes avec le gestionnaire d'authentification

Pour accorder à votre agent l'accès à des outils et services externes (tâches Jira ou dépôts GitHub, par exemple) au nom d'un utilisateur final spécifique, configurez un fournisseur d'authentification OAuth en trois étapes dans le gestionnaire d'authentification des identités d'agent.

En gérant les identifiants et les jetons, les fournisseurs d'authentification OAuth en trois étapes éliminent le besoin de code personnalisé pour gérer les flux d'authentification.

Workflow OAuth en trois étapes

Les fournisseurs d'authentification OAuth à trois acteurs nécessitent le consentement de l'utilisateur, car l'agent accède aux ressources au nom de l'utilisateur.

  1. Invite et redirection : l'interface de chat invite l'utilisateur à se connecter, puis le redirige vers la page de consentement de l'application tierce.
  2. Consentement et stockage : une fois que l'utilisateur a accordé l'autorisation, le gestionnaire d'authentification Agent Identity stocke les jetons OAuth obtenus dans un coffre-fort d'identifiants géré par Google.
  3. Injection : lorsque vous utilisez Agent Development Kit (ADK), l'agent récupère automatiquement le jeton auprès du fournisseur d'authentification et l'injecte dans les en-têtes d'appel d'outil.

Avant de commencer

  1. Vérifiez que vous avez choisi la bonne méthode d'authentification.

  2. Activez l'API Agent Identity.

    Rôles requis pour activer les API

    Pour activer les API, vous avez besoin du rôle IAM Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin), qui contient l'autorisation serviceusage.services.enable. Découvrez comment attribuer des rôles.

    Activer l'API

  3. Créez et déployez un agent.
  4. Assurez-vous de disposer d'une application frontend pour gérer les invites de connexion des utilisateurs et la redirection vers les pages de consentement tierces.
  5. Vérifiez que vous disposez des rôles requis pour effectuer cette tâche.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer et utiliser un fournisseur d'authentification à trois identifiants, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour créer et utiliser un fournisseur d'authentification à trois niveaux. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer et utiliser un fournisseur d'authentification à trois niveaux :

  • Pour créer des fournisseurs d'authentification : agentidentity.authProviders.create
  • Pour utiliser les fournisseurs d'authentification :
    • agentidentity.authProviders.retrieveCredentials
    • aiplatform.endpoints.predict
    • aiplatform.sessions.create

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un fournisseur d'authentification à trois niveaux

Créez un fournisseur d'authentification pour définir la configuration et les identifiants des applications tierces.

Pour créer un fournisseur d'authentification à trois niveaux, utilisez la gcloud CLI :

  1. Configurez votre application cliente OAuth pour enregistrer votre client et obtenir un ID client et un code secret du client. Spécifiez l'URI de redirection à l'aide du modèle de cette section.

  2. Créez le fournisseur d'authentification à l'aide de vos identifiants client :

    gcloud alpha agent-identity authProviders create AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --three-legged-oauth-client-id="CLIENT_ID" \
    --three-legged-oauth-client-secret="CLIENT_SECRET" \
    --three-legged-oauth-authorization-url="AUTHORIZATION_URL" \
    --three-legged-oauth-token-url="TOKEN_URL"
  3. Vérifiez que votre fournisseur d'authentification apparaît dans la liste et que son état est ENABLED : 
    gcloud alpha agent-identity authProviders list \
   --project="PROJECT_ID" \
   --location="LOCATION"

  4. Accordez des autorisations d'accès pour permettre à votre agent et à votre environnement de développement local de récupérer les identifiants auprès du fournisseur d'authentification. Pour autoriser votre agent déployé et votre compte utilisateur personnel à accéder au fournisseur d'authentification, accordez le rôle Utilisateur de l'identité de l'agent (roles/agentidentity.user) sur la ressource du fournisseur d'authentification :

    1. Accordez l'accès à l'ID SPIFFE de votre agent déployé (identité de l'agent) :

      gcloud alpha agent-identity authProviders add-iam-policy-binding AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --role="roles/agentidentity.user" \
    --member="principal://agents.global.org-ORGANIZATION_ID.system.id.goog/resources/aiplatform/projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/ENGINE_ID"

    2. Accordez l'accès à votre compte utilisateur personnel pour le développement et les tests en local (adk web) :

      gcloud alpha agent-identity authProviders add-iam-policy-binding AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --role="roles/agentidentity.user" \
    --member="user:USER_EMAIL"

Remplacez les éléments suivants :

  • PROJECT_ID : ID de votre projet Google Cloud .
  • LOCATION : emplacement où votre fournisseur d'authentification et votre agent sont déployés (par exemple, us-west1).
  • AUTH_PROVIDER_NAME : nom de votre fournisseur d'authentification (par exemple, bigquery-mcp-3lo-authprovider).
  • AUTHORIZATION_URL : URL du serveur d'autorisation (par exemple, https://accounts.google.com/o/oauth2/v2/auth).
  • TOKEN_URL : URL du serveur de jetons (par exemple, https://oauth2.googleapis.com/token).
  • CLIENT_ID : ID client OAuth que vous avez généré à partir du service tiers.
  • CLIENT_SECRET : code secret du client OAuth que vous avez généré à partir du service tiers.
  • ORGANIZATION_ID : ID de votre organisation Google Cloud .
  • PROJECT_NUMBER : numéro de votre projet Google Cloud .
  • ENGINE_ID : ID de votre agent de moteur de raisonnement déployé.
  • USER_EMAIL : adresse e-mail de votre compte utilisateur personnel.

Configurer votre application cliente OAuth

Avant d'enregistrer vos identifiants de client OAuth, obtenez un ID client et un code secret du client auprès du serveur d'autorisation tiers (par exemple, Google, GitHub ou Jira).

Si vous vous connectez à un service tiers en dehors deGoogle Cloud, obtenez les identifiants du client OAuth à partir du portail des développeurs de ce service et ignorez les étapes de cette section.

Enregistrer l'URI de redirection

Lorsque vous configurez vos identifiants client OAuth, vous devez enregistrer l'URI de redirection de rappel dédié du fournisseur d'authentification.

  1. Créez l'URI de redirection à l'aide du modèle suivant :

    https://agentidentitycredentials.googleapis.com/v1alpha/projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME/oauthcallback

    Remplacez les éléments suivants :

    • PROJECT_ID : ID de votre projet Google Cloud .
    • LOCATION : région dans laquelle votre fournisseur d'authentification sera déployé (par exemple, us-west1).
    • AUTH_PROVIDER_NAME : nom de votre fournisseur d'authentification.

    Par exemple : https://agentidentitycredentials.googleapis.com/v1alpha/projects/my-project/locations/us-west1/authProviders/bigquery-mcp-3lo-authprovider/oauthcallback

  2. Si vous vous connectez à des services Google Cloud (comme BigQuery), vous pouvez configurer l'écran de consentement et créer des identifiants de client OAuth dans la console Google Cloud  :

    1. Configurez l'écran de consentement OAuth :

      1. Dans la console Google Cloud , accédez à la page API et services > Écran de consentement OAuth.

        Accédez à API et services > Écran de consentement OAuth.

      2. Dans la section Informations sur l'application, saisissez le nom d'une application (par exemple, "Application BigQuery Manager") et une adresse e-mail d'assistance.
      3. Dans la section Audience, sélectionnez Interne ou Externe.
      4. Saisissez vos coordonnées pour recevoir des notifications.
      5. Lisez et acceptez le Règlement sur les données utilisateur dans les services d'API Google.
      6. Cliquez sur Terminer.

    2. Créez vos identifiants client OAuth :

      1. Dans la console Google Cloud , accédez à la page API et services > Écran de consentement OAuth >Clients.

        Accédez à API et services > Écran de consentement OAuth >Clients.

      2. Cliquez sur Créer des identifiants> ID client OAuth.
      3. Sélectionnez l'option Application Web dans la liste.
      4. Saisissez un nom reconnaissable pour votre client OAuth.
      5. Dans la section URI de redirection autorisés, cliquez sur Ajouter un URI et saisissez l'URI de redirection que vous avez créé.
      6. Cliquez sur Créer. Dans la boîte de dialogue Client OAuth créé, copiez les valeurs ID client et Code secret du client générées.

S'authentifier dans le code de votre agent

Pour authentifier votre agent, vous pouvez utiliser l'ADK ou appeler directement l'API Agent Identity.

ADK

Faites référence au fournisseur d'authentification dans le code de votre agent à l'aide de l'ensemble d'outils MCP dans l'ADK.

from google.adk.agents.llm_agent import LlmAgent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider, GcpAuthProviderScheme
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.auth.auth_tool import AuthConfig

# Register Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is granted.
CONTINUE_URI = "https://YOUR_FRONTEND_URL/validateUserId"

# Create auth provider scheme
# Note: If using the legacy V1 API, the resource name uses 'connectors'
# instead of 'authProviders': projects/.../connectors/...
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME",
    continue_uri=CONTINUE_URI
)

# Configure an MCP tool with the authentication scheme.
toolset = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url="https://YOUR_MCP_SERVER_URL"),
    auth_scheme=auth_scheme,
)

# Initialize the agent with the authenticated tools.
agent = LlmAgent(
    name="AGENT_NAME",
    model="gemini-2.5-flash",
    instruction="AGENT_INSTRUCTIONS",
    tools=[toolset],
)

Exemple : Se connecter à BigQuery MCP

L'exemple suivant montre une configuration agent.py qui connecte un agent au serveur MCP BigQuery :

import os
from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider, GcpAuthProviderScheme
from google.adk.models import Gemini
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
import google.auth
from google.genai import types

_, project_id = google.auth.default()
os.environ["GOOGLE_CLOUD_PROJECT"] = "PROJECT_ID"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"

bigquery_mcp_auth_provider_id = "AUTH_PROVIDER_NAME"
bigquery_mcp_endpoint = os.environ.get(
    "BIGQUERY_MCP_ENDPOINT", "https://bigquery.googleapis.com/mcp"
)

# Register Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# URI to redirect user to after consent is granted.
CONTINUE_URI = "http://127.0.0.1:8501/validateUserId"

bigquery_mcp_auth_scheme = GcpAuthProviderScheme(
    name=f"projects/{project_id}/locations/LOCATION/authProviders/{bigquery_mcp_auth_provider_id}",
    scopes=["https://www.googleapis.com/auth/bigquery"],
    continue_uri=CONTINUE_URI,
)

bigquery_mcp_tools = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url=bigquery_mcp_endpoint),
    auth_scheme=bigquery_mcp_auth_scheme,
    errlog=None,
)

root_agent = Agent(
    name="root_agent",
    model=Gemini(
        model="gemini-2.5-flash",
        retry_options=types.HttpRetryOptions(attempts=3),
    ),
    instruction=(
        "You are a helpful AI assistant designed to provide accurate and useful"
        " information. You can also use your BigQuery MCP tools to look up"
        " BigQuery data."
    ),
    tools=[bigquery_mcp_tools],
)

app = App(
    root_agent=root_agent,
    name="AGENT_NAME",
)

ADK

Référencez le fournisseur d'authentification dans le code de votre agent à l'aide d'un outil de fonction authentifié dans l'ADK.

import httpx
from google.adk.agents.llm_agent import LlmAgent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider
from google.adk.integrations.agent_identity import GcpAuthProviderScheme
from google.adk.apps import App
from google.adk.auth.auth_credential import AuthCredential
from google.adk.auth.auth_tool import AuthConfig
from google.adk.tools.authenticated_function_tool import AuthenticatedFunctionTool
from vertexai import agent_engines

# First, register Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is completed.
CONTINUE_URI = "WEB_APP_VALIDATE_USER_URI"

# Create Auth Config
spotify_auth_config = AuthConfig(
    auth_scheme=GcpAuthProviderScheme(
        name="projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME",
        continue_uri=CONTINUE_URI
    )
)

# Use the Auth Config in Authenticated Function Tool
spotify_search_track_tool = AuthenticatedFunctionTool(
    func=spotify_search_track, auth_config=spotify_auth_config
)

# Sample function tool
async def spotify_search_track(credential: AuthCredential, query: str) -> str | list:
    token = None
    if credential.http and credential.http.credentials:
        token = credential.http.credentials.token

    if not token:
        return "Error: No authentication token available."

    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.spotify.com/v1/search",
            headers={"Authorization": f"Bearer {token}"},
            params={"q": query, "type": "track", "limit": 1},
        )
        # Add your own logic here

agent = LlmAgent(
    name="AGENT_NAME",
    model="gemini-2.5-flash",
    instruction="AGENT_INSTRUCTIONS",
    tools=[spotify_search_track_tool],
)

app = App(
    name="APP_NAME",
    root_agent=agent,
)

vertex_app = agent_engines.AdkApp(app_name=app)

ADK

Référencez le fournisseur d'authentification dans le code de votre agent à l'aide de l'ensemble d'outils MCP du registre d'agents dans l'ADK.

from google.adk.agents.llm_agent import LlmAgent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider
from google.adk.integrations.agent_identity import GcpAuthProviderScheme
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.auth.auth_tool import AuthConfig
from google.adk.integrations.agent_registry import AgentRegistry

# First, register Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is completed.
CONTINUE_URI="WEB_APP_VALIDATE_USER_URI"

# Create Google Cloud auth provider scheme
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME",
    continue_uri=CONTINUE_URI
)

# Set Agent Registry
registry = AgentRegistry(project_id="PROJECT_ID", location="global")

toolset = registry.get_mcp_toolset(
    mcp_server_name=(
        "projects/PROJECT_ID/locations/"
        "global/mcpServers/"
        "agentregistry-00000000-0000-0000-0000-000000000000"
    ),
    auth_scheme=auth_scheme,
)

# Example MCP tool
toolset = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url="MCP_URL"),
    auth_scheme=auth_scheme,
)

agent = LlmAgent(
    name="AGENT_NAME",
    model="MODEL_NAME",
    instruction="AGENT_INSTRUCTIONS",
    tools=[toolset],
)

Appeler l'API directement

Si vous n'utilisez pas l'ADK, votre agent doit appeler l'API agentidentitycredentials.retrieveCredentials pour obtenir le jeton.

Comme il s'agit d'un flux OAuth en plusieurs étapes, votre agent doit gérer le cycle de vie de l'opération :

  1. Demande initiale : l'agent appelle retrieveCredentials.
  2. Consentement requis : si l'utilisateur n'a pas donné son consentement, l'API renvoie une réponse contenant le résultat uri_consent_required. Il contiendra authorization_uri et consent_nonce.
  3. Redirection du frontend : votre application doit rediriger l'utilisateur vers authorization_uri.
  4. Finalisation : une fois que l'utilisateur a donné son consentement, appelez FinalizeCredentials à l'aide de consent_nonce pour finaliser le flux et obtenir le jeton.

Mettre à jour votre application côté client

Pour gérer la connexion et la redirection des utilisateurs pour OAuth à trois niveaux, votre application côté client doit implémenter les étapes suivantes pour gérer le consentement de l'utilisateur et reprendre la conversation :

Exemple de serveur d'UI

Vous pouvez télécharger et exécuter un serveur d'interface utilisateur complet qui utilise uvicorn. Avant de commencer, assurez-vous de disposer d'un compte GitHub et d'avoir installé pip.

Pour configurer et exécuter l'exemple de serveur d'UI, procédez comme suit :

  1. Clonez le dépôt GitHub adk-python :

    git clone https://github.com/google/adk-python.git

  2. Accédez au dépôt et activez un environnement virtuel Python :

    cd adk-python
python3 -m venv .venv
source .venv/bin/activate

  3. Accédez au répertoire client de l'exemple d'UI :

    cd contributing/samples/integrations/gcp_auth/client

  4. Installez les dépendances du client :

    pip install -r requirements.txt

  5. Avant de démarrer le serveur, définissez la variable d'environnement AGENT_PROJECT_DIR pour spécifier le répertoire dans lequel se trouve le code de votre agent. Sinon, l'application recherche par défaut les agents dans le dossier parent du répertoire client.

    Lancez l'exemple de serveur d'UI à l'aide de uvicorn. Assurez-vous que le port correspond à l'URI de redirection configuré dans votre client OAuth :

    export AGENT_PROJECT_DIR="/path/to/your/agent_project"
uvicorn main:app --port 8501 --reload

  6. Ouvrez http://localhost:8501 dans votre navigateur. (Remarque : Vous devez utiliser localhost et non 127.0.0.1, car l'URL de redirection OAuth nécessite spécifiquement le nom d'hôte localhost.) Spécifiez vos paramètres, cliquez sur Enregistrer et appliquer les paramètres, puis interagissez avec votre agent.

Application d'UI personnalisée

Pour implémenter ces fonctionnalités directement dans une application d'UI personnalisée, procédez comme suit :

Gérer le déclencheur d'autorisation

Lorsqu'un agent a besoin du consentement de l'utilisateur, il renvoie un appel de fonction adk_request_credential. Votre application doit intercepter cet appel pour lancer une boîte de dialogue d'autorisation de l'utilisateur ou une redirection.

Gérez le contexte de la session en enregistrant le consent_nonce fourni par le fournisseur d'authentification. Ce nonce est nécessaire pour valider l'utilisateur lors de l'étape de validation. Enregistrez les valeurs auth_config et auth_request_function_call_id dans la session pour faciliter la reprise du flux une fois que l'utilisateur a donné son consentement.

if (fc := get_auth_request_function_call(event_data)):
    print("--> Authentication required by agent.")
    try:
        auth_config = get_auth_config(fc)
        auth_uri, consent_nonce = handle_adk_request_credential(
            auth_config, AUTH_PROVIDER_NAME, request.user_id
        )
        if auth_uri:
            event_data['popup_auth_uri'] = auth_uri
            fc_id = (
                fc.get('id') if isinstance(fc, dict)
                else getattr(fc, 'id', None)
            )
            event_data['auth_request_function_call_id'] = fc_id
            event_data['auth_config'] = auth_config.model_dump()

            # Store session state
            if session_id:
                consent_sessions[session_id] = {
                    "user_id": request.user_id,
                    "consent_nonce": consent_nonce
                }
    except Exception as e:
        print(f"Error handling adk_request_credential: {e}")
        # Optionally, add logic to inform the user about the error.

def handle_adk_request_credential(auth_config, auth_provider_name, user_id):
    ec = auth_config.exchanged_auth_credential
    if ec and ec.oauth2:
        oauth2 = ec.oauth2
        return oauth2.auth_uri, oauth2.nonce
    return None, None

Implémenter un point de terminaison de validation des utilisateurs

Implémentez un point de terminaison de validation sur votre serveur Web (le même URI que celui fourni en tant que continue_uri lors de la configuration). Ce point de terminaison doit effectuer les opérations suivantes :

  1. Recevez user_id_validation_state, auth_provider_name et uuid en tant que paramètres de requête.
  2. Récupérez les valeurs user_id et consent_nonce à partir du stockage de session. Si plusieurs flux d'autorisation s'exécutent simultanément, utilisez uuid pour faire correspondre la bonne session.
  3. Appelez l'API FinalizeCredentials du fournisseur d'authentification avec ces paramètres.
  4. Fermez la fenêtre d'autorisation une fois que vous avez reçu une réponse positive.
Exemple : point de terminaison de validation FastAPI (main.py)

L'exemple suivant montre un point de terminaison de validation FastAPI complet qui gère le rappel OAuth et finalise les identifiants utilisateur :

@app.api_route("/validateUserId", methods=["GET"])
async def validate_user(request: Request):
    auth_provider_name = request.query_params.get("auth_provider_name")
    session_id = request.cookies.get("session_id")
    session = consent_sessions.get(session_id, {})

    payload = {
        "userId": session.get("user_id"),
        "userIdValidationState": request.query_params.get(
            "user_id_validation_state"
        ),
        "consentNonce": session.get("consent_nonce"),
    }

    base_url = "https://agentidentitycredentials.googleapis.com/v1alpha"
    finalize_url = f"{base_url}/{auth_provider_name}/credentials:finalize"

    try:
        async with httpx.AsyncClient(timeout=30.0) as client:
            resp = await client.post(finalize_url, json=payload)
            resp.raise_for_status()
    except httpx.HTTPError as e:
        err_text = e.response.text if hasattr(e, "response") else str(e)
        status = e.response.status_code if hasattr(e, "response") else 500
        return HTMLResponse(err_text, status_code=status)

    return HTMLResponse("""
        <script>
            window.close();
        </script>
        <p>Success. You can close this window.</p>
    """)

Reprendre la conversation avec l'agent

Une fois que l'utilisateur a donné son consentement et que la fenêtre d'autorisation s'est fermée, récupérez les valeurs auth_config et auth_request_function_call_id à partir de vos données de session. Pour poursuivre la conversation, incluez ces informations dans une nouvelle demande à l'agent en tant que function_response.

if (request.is_auth_resume and session.auth_request_function_call_id
    and session.auth_config):
    auth_content = types.Content(
        role='user',
        parts=[
            types.Part(
                function_response=types.FunctionResponse(
                    id=session.auth_request_function_call_id,
                    name='adk_request_credential',
                    response=session.auth_config
                )
            )
        ],
    )
    # Send message to agent
    async for event in agent.async_stream_query(
        user_id=request.user_id,
        message=auth_content,
        session_id=session_id,
    ):
        # ...

Déployer l'agent

Lorsque vous déployez votre agent sur Google Cloud, assurez-vous que l'identité de l'agent est activée.

Si vous déployez sur Agent Runtime sur Gemini Enterprise Agent Platform, utilisez l'indicateur identity_type=AGENT_IDENTITY :

import vertexai
from vertexai import types
from vertexai.agent_engines import AdkApp

# Initialize the Vertex AI client with v1beta1 API for Agent Identity support
client = vertexai.Client(
    project="PROJECT_ID",
    location="LOCATION",
    http_options=dict(api_version="v1beta1")
)

# Use the proper wrapper class for your Agent Framework (e.g., AdkApp)
app = AdkApp(agent=agent)

# Deploy the agent with Agent Identity enabled
remote_app = client.agent_engines.create(
    agent=app,
    config={
        "identity_type": types.IdentityType.AGENT_IDENTITY,
        "requirements": [
            "google-cloud-aiplatform[agent_engines,adk]",
            "google-adk[agent-identity]"
        ],
    },
)

Étapes suivantes