Mit einem API-Schlüssel und dem Auth-Manager authentifizieren

Damit sich Ihre Agenten bei externen Tools wie Google Maps oder Wetter-APIs authentifizieren können, konfigurieren Sie die ausgehende Authentifizierung mit API-Schlüssel-Authentifizierungsanbietern im Agent Identity-Authentifizierungsmanager.

API-Schlüssel-Authentifizierungsanbieter verwalten Ihre kryptografischen Schlüssel für Sie. Dadurch müssen Sie Schlüssel nicht mehr im Code Ihres Agenten hartcodieren oder manuell verwalten.

Workflow für API-Schlüssel

API-Schlüssel-Authentifizierungsanbieter verwenden die Identität des Agenten und erfordern keine Nutzereinwilligung. Google ergreift Maßnahmen, um den API-Schlüssel während der Speicherung zu schützen. Wenn Sie das Agent Development Kit (ADK) verwenden, wird der API-Schlüssel automatisch abgerufen und in die Header des Toolaufrufs eingefügt.

Hinweis

  1. Prüfen Sie, ob Sie die richtige Authentifizierungsmethode ausgewählt haben.

  2. Aktivieren Sie die Agent Identity API, falls sie noch nicht aktiviert ist.

    Erforderliche Rollen zum Aktivieren von APIs

    Zum Aktivieren von APIs benötigen Sie die Berechtigung serviceusage.services.enable. Wenn Sie das Projekt erstellt haben, haben Sie diese Berechtigung wahrscheinlich bereits über die Inhaberrolle (roles/owner). Andernfalls können Sie diese Berechtigung über die Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin) erhalten. Informationen zum Zuweisen von Rollen

    API aktivieren

  3. KI-Agenten erstellen und bereitstellen

  4. Rufen Sie einen API-Schlüssel vom Drittanbieterdienst ab, zu dem Sie eine Verbindung herstellen möchten.

  5. Prüfen Sie, ob Sie die Rollen haben, die für diese Aufgabe erforderlich sind.

Erforderliche Rollen

Bitten Sie Ihren Administrator, Ihnen die folgenden IAM-Rollen für das Projekt zuzuweisen, um die Berechtigungen zu erhalten, die Sie zum Erstellen und Verwenden eines API-Schlüssel-Authentifizierungsanbieters benötigen:

Weitere Informationen zum Zuweisen von Rollen finden Sie unter Zugriff auf Projekte, Ordner und Organisationen verwalten.

Diese vordefinierten Rollen enthalten die Berechtigungen, die zum Erstellen und Verwenden eines API-Schlüssel-Authentifizierungsanbieters erforderlich sind. Maximieren Sie den Abschnitt Erforderliche Berechtigungen, um die notwendigen Berechtigungen anzuzeigen:

Erforderliche Berechtigungen

Die folgenden Berechtigungen sind erforderlich, um einen API-Schlüssel-Authentifizierungsanbieter zu erstellen und zu verwenden:

  • So erstellen Sie Authentifizierungsanbieter: agentidentity.authProviders.create
  • So verwenden Sie Authentifizierungsanbieter:
    • agentidentity.authProviders.retrieveCredentials
    • aiplatform.endpoints.predict
    • aiplatform.sessions.create

Sie können diese Berechtigungen auch mit benutzerdefinierten Rollen oder anderen vordefinierten Rollen erhalten.

API-Schlüssel vom Drittanbieterdienst abrufen

Bevor Sie einen Authentifizierungsanbieter erstellen, müssen Sie einen API-Schlüssel vom Drittanbieterdienst abrufen, mit dem Ihr Agent eine Verbindung herstellen soll.

Wenn Sie eine Verbindung zu einem Drittanbieterdienst außerhalb von Google Cloudherstellen, rufen Sie den API-Schlüssel aus dem Entwicklerportal dieses Dienstes ab und überspringen Sie die Schritte in diesem Abschnitt.

Wenn Sie eine Verbindung zu Google Cloud -Diensten wie Cloud Translation oder Google Maps herstellen, können Sie einen API-Schlüssel generieren und konfigurieren. Gehen Sie dazu so vor:

  1. Aktivieren Sie in der Google Cloud Console die erforderlichen API-Dienste für Ihr Projekt:

    1. Rufen Sie in der Google Cloud Console die Seite APIs und Dienste > Bibliothek auf.

      Rufen Sie „APIs und Dienste“ > „Bibliothek“ auf.

    2. Suchen Sie nach den APIs, die Ihr Agent verwendet, z. B. die Cloud Translation API oder die Google Maps Weather API, und aktivieren Sie sie.
    3. Kopieren Sie den generierten API-Schlüsselstring.

  2. Konfigurieren Sie Ihren API-Schlüssel:

    1. Rufen Sie in der Google Cloud Console die Seite APIs und Dienste > Anmeldedaten auf.

      Zu „APIs & Dienste“ > „Anmeldedaten“

    2. Klicken Sie auf Anmeldedaten erstellen > API-Schlüssel.
    3. Gehen Sie im Dialogfeld API-Schlüssel erstellen so vor:
      1. Geben Sie einen eindeutigen Namen für den API-Schlüssel ein.
      2. Wenn Sie den Schlüssel auf die von Ihnen aktivierten APIs beschränken möchten, wählen Sie diese APIs in der Liste API-Einschränkungen auswählen aus.
      3. Optional: Wählen Sie im Abschnitt Schlüssel einschränken, um Sicherheitsrisiken zu reduzieren einen Anwendungstyp aus, um den Zugriff einzuschränken.
      4. Klicken Sie auf Erstellen.

  3. Validieren Sie Ihren API-Schlüssel, indem Sie eine Testanfrage an den Dienstendpunkt senden.

    • Führen Sie den folgenden Befehl aus, um einen Cloud Translation API-Schlüssel zu prüfen:

      curl -X POST \
  -H "Content-Type: application/json" \
  -H "X-goog-api-key: YOUR_API_KEY" \
  -d '{"q": "Hello world", "target": "es"}' \
  "https://translation.googleapis.com/language/translate/v2"

      Ersetzen Sie YOUR_API_KEY durch den von Ihnen generierten API-Schlüssel.

    • Führen Sie den folgenden Befehl aus, um einen Google Maps Weather API-Schlüssel zu überprüfen:

      curl -X GET \
  "https://weather.googleapis.com/v1/currentConditions:lookup?key=YOUR_API_KEY&location.latitude=37.4220&location.longitude=-122.0841"

      Ersetzen Sie YOUR_API_KEY durch den von Ihnen generierten API-Schlüssel.

    Wenn der API-Schlüssel gültig und richtig konfiguriert ist, gibt der Dienst die angeforderten Daten zurück.

Authentifizierungsanbieter für API-Schlüssel erstellen

Erstellen Sie einen Authentifizierungsanbieter, um die Konfiguration und die Anmeldedaten für Drittanbieteranwendungen zu definieren.

Verwenden Sie zum Erstellen eines API-Schlüssel-Authentifizierungsanbieters die Google Cloud Console, die Google Cloud CLI oder die REST API.

Console

  1. Rufen Sie in der Google Cloud Console die Seite Agent Registry auf.

    Zur Agent Registry

  2. Klicken Sie auf den Namen des KI-Agenten, für den Sie einen Authentifizierungsanbieter erstellen möchten.
  3. Klicken Sie auf Identität.
  4. Klicken Sie im Bereich Authentifizierungsanbieter auf Authentifizierungsanbieter hinzufügen.

  5. Geben Sie im Bereich Authentifizierungsanbieter hinzufügen einen Namen und eine Beschreibung ein.

    Der Name darf nur Kleinbuchstaben, Ziffern oder Bindestriche enthalten, darf nicht mit einem Bindestrich enden und muss mit einem Kleinbuchstaben beginnen.

  6. Wählen Sie in der Liste OAuth-Typ die Option API-Schlüssel aus.
  7. Klicken Sie auf Erstellen und fortfahren.
  8. Klicken Sie auf Zugriff gewähren, um der Agentenidentität die Berechtigung zur Verwendung des Authentifizierungsanbieters zu erteilen.

    Bei diesem Vorgang wird der Agentenidentität automatisch die Rolle Agent Identity User (roles/agentidentity.user) für die Authentifizierungsanbieterressource zugewiesen.

  9. Geben Sie im Abschnitt Anmeldedaten des Authentifizierungsanbieters den API-Schlüssel ein.
  10. Klicken Sie auf Anbieterkonfiguration hinzufügen.

Der neu erstellte Authentifizierungsanbieter wird in der Liste Authentifizierungsanbieter angezeigt.

gcloud-CLI

  1. Erstellen Sie den Authentifizierungsanbieter:

    gcloud agent-identity auth-providers create AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --api-key="API_KEY"
  2. Prüfen Sie, ob Ihr Authentifizierungsanbieter in der Liste aufgeführt ist und den Status ENABLED hat: 
    gcloud agent-identity auth-providers list \
   --project="PROJECT_ID" \
   --location="LOCATION"

  3. Gewähren Sie Zugriffsberechtigungen, damit Ihr Agent und Ihre lokale Entwicklungsumgebung Anmeldedaten vom Authentifizierungsanbieter abrufen können. Damit Ihr bereitgestellter Agent und Ihr persönliches Nutzerkonto auf den Authentifizierungsanbieter zugreifen können, weisen Sie der Authentifizierungsanbieter-Ressource die Rolle Agent Identity User (roles/agentidentity.user) zu:

    1. Gewähren Sie Zugriff auf die SPIFFE-ID (Agentenidentität) des bereitgestellten KI-Agenten:

      gcloud agent-identity auth-providers 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. Gewähren Sie Ihrem persönlichen Nutzerkonto Zugriff für die lokale Entwicklung und Tests (adk web):

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

Ersetzen Sie Folgendes:

  • PROJECT_ID: Ihre Google Cloud Projekt-ID
  • LOCATION: Der Standort, an dem Ihr Authentifizierungsanbieter und Ihr Agent bereitgestellt werden (z. B. us-west1).
  • AUTH_PROVIDER_NAME: Der Name Ihres Authentifizierungsanbieters (z. B. maps-api-key-authprovider).
  • API_KEY: Der API-Schlüssel, den Sie über den Drittanbieterdienst generiert haben.
  • ORGANIZATION_ID: Ihre Organisations-ID von Google Cloud .
  • PROJECT_NUMBER: Ihre Google Cloud -Projektnummer.
  • ENGINE_ID: Die ID des bereitgestellten Reasoning-Engine-Agenten.
  • USER_EMAIL: Die E-Mail-Adresse Ihres persönlichen Nutzerkontos.

REST

  1. Erstellen Sie den Authentifizierungsanbieter:

    Mit der Methode authProviders.create der Agent Identity API wird ein API-Schlüssel-Authentifizierungsanbieter in einem Projekt und an einem Standort erstellt.

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • PROJECT_ID: Ihre Google Cloud -Projekt-ID. Projekt-IDs sind alphanumerische Strings, wie my-project.
    • LOCATION: Der Standort, an dem Ihr Authentifizierungsanbieter und Ihr Agent bereitgestellt werden (z. B. us-west1).
    • AUTH_PROVIDER_NAME: Der Name Ihres Authentifizierungsanbieters (z. B. maps-api-key-authprovider). Der Name darf nur Kleinbuchstaben, Ziffern oder Bindestriche enthalten, darf nicht mit einem Bindestrich enden und muss mit einem Kleinbuchstaben beginnen.
    • API_KEY: Der API-Schlüssel, den Sie über den Drittanbieterdienst generiert haben.

    HTTP-Methode und URL: 

    POST https://agentidentity.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/authProviders?authProviderId=AUTH_PROVIDER_NAME

    JSON-Text anfordern:

    {
  "authProviderTypeParams": {
    "apiKey": {
      "apiKey": "API_KEY"
    }
  }
}

    Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

    Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

    {
  "name": "projects/my-project/locations/us-west1/authProviders/maps-api-key-authprovider",
  "createTime": "2026-04-03T21:15:41.367155Z",
  "updateTime": "2026-04-03T21:15:41.367155Z",
  "authProviderTypeParams": {
    "apiKey": {}
  },
  "state": "ENABLED"
}

  2. Damit Ihr bereitgestellter Agent und Ihr persönliches Nutzerkonto Anmeldedaten vom Authentifizierungsanbieter abrufen können, weisen Sie der Authentifizierungsanbieter-Ressource die Rolle Agent Identity User (roles/agentidentity.user) zu:

    Mit der Methode authProviders.setIamPolicy der Agent Identity API wird die Zulassungsrichtlinie für die Authentifizierungsanbieter-Ressource festgelegt.

    Ersetzen Sie diese Werte in den folgenden Anfragedaten:

    • PROJECT_ID: Ihre Google Cloud -Projekt-ID. Projekt-IDs sind alphanumerische Strings, wie my-project.
    • LOCATION: Der Standort, an dem Ihr Authentifizierungsanbieter und Ihr Agent bereitgestellt werden (z. B. us-west1).
    • AUTH_PROVIDER_NAME: Der Name Ihres Authentifizierungsanbieters.
    • ORGANIZATION_ID: Ihre Organisations-ID von Google Cloud.
    • PROJECT_NUMBER: Die numerische Google Cloud -Projektnummer des Projekts, in dem Ihr Agent bereitgestellt wird (z. B. 987654321098).
    • ENGINE_ID: Die ID des bereitgestellten Reasoning Engine-Agenten.
    • USER_EMAIL: Die E-Mail-Adresse Ihres persönlichen Nutzerkontos.

    HTTP-Methode und URL: 

    POST https://agentidentity.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME:setIamPolicy

    JSON-Text anfordern:

    {
  "policy": {
    "bindings": [
      {
        "role": "roles/agentidentity.user",
        "members": [
          "principal://agents.global.org-ORGANIZATION_ID.system.id.goog/resources/aiplatform/projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/ENGINE_ID",
          "user:USER_EMAIL"
        ]
      }
    ]
  }
}

    Wenn Sie die Anfrage senden möchten, maximieren Sie eine der folgenden Optionen:

    Sie sollten eine JSON-Antwort ähnlich wie diese erhalten:

    {
  "version": 1,
  "etag": "BwYKmjvelug=",
  "bindings": [
    {
      "role": "roles/agentidentity.user",
      "members": [
        "principal://agents.global.org-123456789012.system.id.goog/resources/aiplatform/projects/987654321098/locations/us-west1/reasoningEngines/112233445566778899",
        "user:alex@example.com"
      ]
    }
  ]
}

Im Agentencode authentifizieren

Sie können das ADK verwenden, um Ihren KI-Agenten zu authentifizieren.

ADK

Verweisen Sie im Code Ihres KI-Agenten mit dem MCP-Toolset im ADK auf den Authentifizierungsanbieter.

from google.adk.agents import Agent
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())

# Create Google Cloud 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"
)

# 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 = Agent(
    name="AGENT_NAME",
    model="gemini-2.5-flash",
    instruction="AGENT_INSTRUCTIONS",
    tools=[toolset],
)

Beispiel: Verbindung zum Google Maps-MCP herstellen

Das folgende Beispiel zeigt eine agent.py-Konfiguration, die einen Agenten mit einem Google Maps-MCP-Server verbindet:

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

os.environ["GOOGLE_CLOUD_PROJECT"] = "PROJECT_ID"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"
os.environ["GOOGLE_API_USE_CLIENT_CERTIFICATE"] = "false"

# Register Google Cloud auth provider for Agent Identity Credentials service
CredentialManager.register_auth_provider(GcpAuthProvider())

maps_auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME"
)

maps_tools = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url="https://mapstools.googleapis.com/mcp"),
    auth_scheme=maps_auth_scheme,
    errlog=None,
)

root_agent = Agent(
    name="root_agent",
    model=Gemini(model="gemini-2.5-flash"),
    instruction=(
        "You are a helpful AI assistant designed to provide accurate and useful "
        "information. You can also use your Google Maps tools to look up "
        "locations and directions."
    ),
    tools=[maps_tools],
)

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

ADK

Verweisen Sie im Code Ihres KI-Agenten mit einem authentifizierten Funktionstool im ADK auf den Authentifizierungsanbieter.

import httpx
from google.adk.agents import Agent
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())

# Create Auth Config
# Note: If using the legacy V1 API, the resource name uses 'connectors'
# instead of 'authProviders': projects/.../connectors/...
spotify_auth_config = AuthConfig(
    auth_scheme=GcpAuthProviderScheme(
        name="projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME"
    )
)

# 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 = Agent(
    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)

Beispiel: Verbindung zur Google Maps Weather API herstellen

Das folgende Beispiel zeigt eine agent.py-Konfiguration, die einen KI-Agenten über ein authentifiziertes Funktionstool mit der Google Maps Weather API verbindet:

import os
import httpx
from google.adk.agents import Agent
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.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider, GcpAuthProviderScheme
from google.adk.models import Gemini
from google.adk.tools.authenticated_function_tool import AuthenticatedFunctionTool

os.environ["GOOGLE_CLOUD_PROJECT"] = "PROJECT_ID"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"
os.environ["GOOGLE_API_USE_CLIENT_CERTIFICATE"] = "false"

# Register Google Cloud auth provider for Agent Identity Credentials service
CredentialManager.register_auth_provider(GcpAuthProvider())

weather_auth_config = AuthConfig(
    auth_scheme=GcpAuthProviderScheme(
        name="projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME"
    )
)

async def get_weather(credential: AuthCredential, latitude: float, longitude: float) -> str | dict:
    """Gets current weather conditions for a location."""
    api_key = None
    if http := credential.http:
        if http.additional_headers and "X-GOOG-API-KEY" in http.additional_headers:
            api_key = http.additional_headers["X-GOOG-API-KEY"]
        elif http.credentials and http.credentials.token:
            api_key = http.credentials.token

    if not api_key:
        return "Error: No API key available from the auth provider."

    params = {"location.latitude": latitude, "location.longitude": longitude, "key": api_key}
    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://weather.googleapis.com/v1/currentConditions:lookup",
            params=params,
        )
        if response.status_code != 200:
            return f"Error from Weather API: {response.status_code} - {response.text}"
        return response.json()

get_weather_tool = AuthenticatedFunctionTool(
    func=get_weather, auth_config=weather_auth_config
)

root_agent = Agent(
    name="root_agent",
    model=Gemini(model="gemini-2.5-flash"),
    instruction=(
        "You are a helpful AI assistant. You will use your weather tool to "
        "look up current conditions."
    ),
    tools=[get_weather_tool],
)

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

ADK

Verweisen Sie im Code Ihres KI-Agenten mit dem MCP-Toolset „Agent Registry“ im ADK auf den Authentifizierungsanbieter.

Sie erstellen kein Authentifizierungsschema für diesen Ablauf. In der ausgehenden Bindung des MCP-Servers ist bereits festgelegt, welcher Authentifizierungsanbieter verwendet werden soll.

from google.adk.agents import Agent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider
from google.adk.integrations.agent_registry import AgentRegistry

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

# Set Agent Registry. LOCATION must be the same region as the auth provider.
registry = AgentRegistry(project_id="PROJECT_ID", location="LOCATION")

# The auth provider is resolved from the MCP server's outbound binding.
toolset = registry.get_mcp_toolset(
    mcp_server_name=(
        "projects/PROJECT_ID/locations/"
        "LOCATION/mcpServers/"
        "agentregistry-00000000-0000-0000-0000-000000000000"
    ),
)

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

Agent bereitstellen

Wenn Sie Ihren KI-Agenten in Google Cloudbereitstellen, muss die Agentenidentität aktiviert sein.

Agent CLI

Wenn Sie das Agent Development Kit (ADK) und die Agent CLI verwenden, gehen Sie so vor, um Ihren KI-Agenten mit aktivierter Agent Identity bereitzustellen:

  1. Erstellen Sie im Ordner Ihrer Agent-Anwendung eine Konfigurationsdatei mit dem Namen .agent_engine_config.json, um die Agent-Identität zu aktivieren:

    echo '{ "identity_type": "AGENT_IDENTITY" }' > AGENT_NAME/.agent_engine_config.json

  2. Stellen Sie Ihren Agenten in der Agent Runtime auf der Gemini Enterprise Agent Platform bereit:

    uv run adk deploy agent_engine AGENT_NAME \
    --project="PROJECT_ID" \
    --region="LOCATION"

    Ersetzen Sie Folgendes:

    • AGENT_NAME: Der Name des Ordners Ihrer Agent-Anwendung (z. B. maps_agent).
    • PROJECT_ID: Ihre Projekt-ID in Google Cloud.
    • LOCATION: Die unterstützte Region, in der Sie den Agent bereitstellen möchten (z. B. us-west1).

Python SDK

Wenn Sie die Bereitstellung programmatisch mit dem Vertex AI Python SDK durchführen, verwenden Sie das Flag identity_type=AGENT_IDENTITY:

import vertexai
from vertexai import types
from vertexai.agent_engines import AdkApp
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider

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

# Register the auth provider in set_up() so that it runs in the deployed
# container. Use the proper wrapper class for your Agent Framework (for example, AdkApp).
class AuthenticatedAdkApp(AdkApp):
    def set_up(self):
        CredentialManager.register_auth_provider(GcpAuthProvider())
        super().set_up()

app = AuthenticatedAdkApp(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,mcp]>=2.7.1",
        ],
    },
)

Ersetzen Sie Folgendes:

  • PROJECT_ID: Ihre Google Cloud -Projekt-ID.
  • LOCATION: Die unterstützte Region, in der Sie den Agent bereitstellen möchten (z. B. us-west1).

Nächste Schritte