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

Vorschau

Diese Funktion unterliegt den „Bedingungen für Pre-GA-Angebote“ im Abschnitt „Allgemeine Dienstbedingungen“ der dienstspezifischen Nutzungsbedingungen. Pre-GA‑Funktionen stehen in der vorliegenden Form zur Verfügung und bieten möglicherweise nur eingeschränkten Support. Weitere Informationen finden Sie unter den Beschreibungen der Startphase.

Wenn Ihre Agenten sich bei externen Tools wie Google Maps oder Weather APIs authentifizieren sollen, 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 fest im Code Ihres Agenten codieren oder manuell verwalten.

API-Schlüssel-Workflow

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 Connector API.

   Rollen, die zum Aktivieren von APIs erforderlich sind

   Zum Aktivieren von APIs benötigen Sie die IAM-Rolle „Service Usage-Administrator“ (roles/serviceusage.serviceUsageAdmin), die die Berechtigung serviceusage.services.enable enthält. Informationen zum Zuweisen von Rollen.

   API aktivieren

3. Erstellen und stellen Sie einen Agenten bereit.

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

5. Prüfen Sie, ob Sie die erforderlichen Rollen haben, um diese Aufgabe auszuführen.

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:

• Zum Erstellen von Authentifizierungsanbietern:
  • IAM Connector-Administrator (roles/iamconnectors.admin)
  • IAM Connector-Bearbeiter (roles/iamconnectors.editor)
• Zum Verwenden von Authentifizierungsanbietern:
  • IAM Connector-Nutzer (roles/iamconnectors.user)
  • Standardzugriff für Agenten (roles/aiplatform.agentDefaultAccess)
  • Agent Context-Bearbeiter (roles/aiplatform.agentContextEditor)
  • Vertex AI-Nutzer (roles/aiplatform.user)
  • Service Usage-Nutzer (roles/serviceusage.serviceUsageConsumer)

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, die erforderlich sind:

Erforderliche Berechtigungen

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

• Zum Erstellen von Authentifizierungsanbietern: iamconnectors.connectors.create
• Zum Verwenden von Authentifizierungsanbietern:
  • iamconnectors.connectors.retrieveCredentials
  • aiplatform.endpoints.predict
  • aiplatform.sessions.create

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

API-Schlüssel-Authentifizierungsanbieter erstellen

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

Verwenden Sie die Google Cloud console oder die Google Cloud CLI, um einen API-Schlüssel-Authentifizierungsanbieter zu erstellen.

Console

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

   Zu Agent Registry

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

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

   Der Name darf nur Kleinbuchstaben, Zahlen oder Bindestriche enthalten, 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.

   Dadurch wird der Agentenidentität automatisch die Rolle Connector-Nutzer (roles/iamconnectors.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.

Google Cloud CLI

1. Erstellen Sie den Authentifizierungsanbieter:

   gcloud alpha agent-identity connectors create AUTH_PROVIDER_NAME \
       --location="LOCATION" \
       --api-key="API_KEY"

2. Wenn Sie der Agentenidentität die Berechtigung zur Verwendung von Authentifizierungsanbietern erteilen möchten, aktualisieren Sie die IAM-Zulassungsrichtlinie für das Projekt oder den jeweiligen Authentifizierungsanbieter und weisen Sie dem Agenten-Prinzipal die Rolle Connector-Nutzer (roles/iamconnectors.user) zu.

   Die Agentenidentität basiert auf dem Industriestandard SPIFFE -ID-Format. In IAM-Zulassungsrichtlinien werden Agentenidentitäten mit Hauptkonto-IDs bezeichnet.

   auf Projektebene (gcloud)

   Wenn Sie die Rolle auf Projektebene zuweisen, kann der Agent jeden Authentifizierungsanbieter in diesem Projekt verwenden.

   • Führen Sie den folgenden Befehl aus, um einem einzelnen Agenten Zugriff auf Auth-Anbieter in einem Projekt zu gewähren:

     gcloud projects add-iam-policy-binding PROJECT_ID \
         --role='roles/iamconnectors.user' \
         --member="principal://agents.global.org-ORGANIZATION_ID.system.id.goog/resources/aiplatform/projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/ENGINE_ID"

   • Führen Sie den folgenden Befehl aus, um allen Agenten in einem Projekt Zugriff auf Authentifizierungsanbieter zu gewähren:

     gcloud projects add-iam-policy-binding PROJECT_ID \
         --role='roles/iamconnectors.user' \
         --member="principalSet://agents.global.org-ORGANIZATION_ID.system.id.goog/attribute.platformContainer/aiplatform/projects/PROJECT_NUMBER"

   Connector-Ebene (curl)

   Verwenden Sie die setIamPolicy API, um einem einzelnen Agenten Zugriff auf einen bestimmten Authentifizierungsanbieter zu gewähren. Dieser Befehl überschreibt alle vorhandenen Zulassungsrichtlinien für die Ressource.

   curl -X POST \
       -H "Authorization: Bearer $(gcloud auth print-access-token)" \
       -H "Content-Type: application/json" \
       -d '{
     "policy": {
       "bindings": [
         {
           "role": "roles/iamconnectors.user",
           "members": ["principal://agents.global.org-ORGANIZATION_ID.system.id.goog/resources/aiplatform/projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/ENGINE_ID"]
         }
       ]
     }
   }' \
       "https://iamconnectors.googleapis.com/v1alpha/projects/PROJECT_ID/locations/LOCATION/connectors/AUTH_PROVIDER_NAME:setIamPolicy"

   Ersetzen Sie Folgendes:

   • PROJECT_ID: Ihre Google Cloud Projekt-ID
   • AUTH_PROVIDER_NAME: Der Name des Authentifizierungsanbieters
   • ORGANIZATION_ID: Ihre Google Cloud Organisations-ID
   • PROJECT_NUMBER: Ihre Google Cloud Projektnummer
   • LOCATION: Der Standort für Ihren Agenten (z. B. us-central1)
   • ENGINE_ID: Die ID Ihrer Reasoning Engine

Im Agentencode authentifizieren

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

ADK

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

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 the Google Cloud auth provider so the CredentialManager can use it.
CredentialManager.register_auth_provider(GcpAuthProvider())

# Create the Google Cloud auth provider scheme using the auth provider's full resource name.
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/connectors/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 = LlmAgent(
    name="YOUR_AGENT_NAME",
    model="gemini-2.0-flash",
    instruction="YOUR_AGENT_INSTRUCTIONS",
    tools=[toolset],
)

ADK

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

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())

# Create Auth Config
spotify_auth_config = AuthConfig(
    auth_scheme=GcpAuthProviderScheme(
        name="projects/PROJECT_ID/locations/LOCATION/connectors/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 = LlmAgent(
    name="YOUR_AGENT_NAME",
    model="YOUR_MODEL_NAME",
    instruction="YOUR_AGENT_INSTRUCTIONS",
    tools=[spotify_search_track_tool],
)

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

vertex_app = agent_engines.AdkApp(app_name=app)

ADK

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

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())

# Create Google Cloud auth provider scheme by providing Auth Provider full resource name
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/connectors/AUTH_PROVIDER_NAME"
)

# 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="YOUR_AGENT_NAME",
    model="YOUR_MODEL_NAME",
    instruction="YOUR_AGENT_INSTRUCTIONS",
    tools=[toolset],
)

  

Agent bereitstellen

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

Wenn Sie in der Agent Runtime bereitstellen, verwenden Sie das Flag 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]"],
    },
)

Nächste Schritte

• Agentenidentität – Übersicht
• Mit dreibeinigem OAuth und dem Authentifizierungsmanager authentifizieren
• Mit zweibeinigem OAuth und dem Authentifizierungsmanager authentifizieren
• Authentifizierungsanbieter für die Agentenidentität verwalten
• Fehlerbehebung beim Authentifizierungsmanager für die Agentenidentität