Agent und Agent Gateway mit VPC Service Controls bereitstellen

1. Einführung

In diesem Codelab erfahren Sie, wie Sie eine Google Cloud-Umgebung konfigurieren, um einen Agent und ein Agent Gateway mit VPC Service Controls-Perimetern einzurichten. Sie richten einen VPC Service Controls-Perimeter ein, konfigurieren das Netzwerk und DNS, stellen ein Agent Gateway mit IAP-Anforderungsautorisierung (Identity-Aware Proxy) bereit und testen den Agent sicher.

Umfang

In diesem Codelab erstellen Sie eine sichere Google Cloud-Architektur für die Gemini Enterprise Agent Platform und das Agent Gateway, die Folgendes bietet:

• Verwendet VPC Service Controls, um Projektdaten vor unautorisierter Daten-Exfiltration zu schützen.
• Konfiguriert privaten Google-Zugriff, Private Service Connect (PSC) und private Cloud DNS-Zonen für privates API-Routing.
• Stellt ein Agent Gateway mit zentralisierter Traffic-Proxyierung, Regeln für ausgehenden Traffic und Protokollkonfiguration bereit.
• Erzwingt Autorisierungsrichtlinien für Identity-Aware Proxy (IAP)-Anfragen.
• Stellt einen Agent Engine-Agenten über eine private Verbindung bereit und testet ihn sicher.

Lerninhalte

• Erforderliche Google Cloud APIs für die Agent Platform und Sicherheit aktivieren
• VPC Service Controls-Perimeter und Regeln für eingehenden Zugriff konfigurieren
• So richten Sie private Netzwerkverbindungen und Einträge für privates DNS ein.
• Agent Gateway- und Agent-Verbindungsvorlagen erstellen
• So konfigurieren Sie Erweiterungen und Richtlinien für die Autorisierung von IAP-Anfragen.
• Einen Agent Engine-Agenten sicher bereitstellen und testen

Voraussetzungen

• Die Google Cloud CLI ist installiert und auf die aktuelle Version aktualisiert.
• Python 3 ist auf Ihrer Workstation installiert.
• Git ist auf Ihrer Workstation installiert.
• Eine aktive Google Cloud-Organisation und Berechtigungen für das Rechnungskonto.

2. Vorbereitung

In diesem Abschnitt werden die grundlegenden Anforderungen an Befehlszeilentools und die erforderliche Umgebungskonfiguration beschrieben, die vor dem Ausführen von Einrichtungs-Scripts erforderlich sind.

1. Prüfen Sie, ob die Google Cloud CLI installiert und auf die aktuelle Version aktualisiert ist. Authentifizieren Sie sich dann mit Ihrem Google-Konto. Aktualisieren Sie Ihre Google Cloud CLI-Komponenten, damit Sie die neuesten Funktionen für Network Services und VPC Service Controls nutzen können.

gcloud components update
gcloud auth login
gcloud config set account USER_EMAIL

2. Prüfen Sie, ob Python 3 installiert ist, um das benutzerdefinierte Agent-Framework zu konfigurieren und bereitzustellen. Eine Anleitung finden Sie unter Python-Module installieren:

python3 --version

3. Achten Sie darauf, dass Git installiert ist, um das Beispiel-Repository mit Einrichtungscode und Konfigurationsvorlagen zu klonen. Eine Anleitung finden Sie unter Git installieren.

3. Google Cloud-Projekt konfigurieren

Wenn Sie ein isoliertes Projekt in Ihrer Organisation erstellen, bleiben alle in diesem Codelab verwendeten Ressourcen, Netzwerke und Berechtigungen gekapselt und verwaltbar. Weitere Informationen zum Erstellen und Verwalten von Projekten

Initialisieren Sie ein neues Google Cloud-Projekt in Ihrer Organisation, um die Ressourcen für diese Einrichtung zu hosten. Sie können auch Ihr eigenes Projekt verwenden:

export PROJ_ID="YOUR_PROJECT_ID"
gcloud projects create ${PROJ_ID} --organization=YOUR_ORG_ID

gcloud config set project $PROJ_ID

gcloud auth application-default set-quota-project $PROJ_ID

Standardanmeldedaten für Anwendungen durch Anmeldung abrufen:

gcloud auth application-default login

Konfiguration überprüfen:

gcloud config list

Abrechnung aktivieren

Verknüpfen Sie ein aktives Rechnungskonto mit dem neu erstellten Projekt, um die Nutzung des Dienstes zu ermöglichen.

Die Aktivierung der Abrechnung ist eine Voraussetzung für die Nutzung von API-Kontingenten und die Bereitstellung von Google Cloud-Infrastruktur wie Agent Gateways, Virtual Private Clouds und Rechenknoten. Weitere Informationen zu Abrechnungskonfigurationen finden Sie in der Dokumentation zu Google Cloud Billing.

gcloud billing accounts list
# Copy the billing account to assign to your GCP project
gcloud billing projects link $PROJ_ID --billing-account=BILLING_ACCOUNT_ID

4. Dienste aktivieren

Aktivieren Sie alle erforderlichen Google Cloud APIs für Agent-, Agent Gateway-, Netzwerk-, Sicherheits- und Observability-Funktionen.

Durch die API-Aktivierung werden Backend-Cloud-Dienste für Ressourcenverwaltung, Observability und Netzwerkfunktionen bereitgestellt, die für eine sichere Agent-Verbindung erforderlich sind. Weitere Informationen finden Sie in der Dokumentation zur Service Usage API.

gcloud services enable \
  agentregistry.googleapis.com \
  aiplatform.googleapis.com \
  apphub.googleapis.com \
  apptopology.googleapis.com \
  cloudapiregistry.googleapis.com \
  cloudtrace.googleapis.com \
  compute.googleapis.com \
  dataform.googleapis.com \
  iam.googleapis.com \
  iap.googleapis.com \
  logging.googleapis.com \
  modelarmor.googleapis.com \
  monitoring.googleapis.com \
  networksecurity.googleapis.com \
  networkservices.googleapis.com \
  notebooks.googleapis.com \
  observability.googleapis.com \
  securitycenter.googleapis.com

gcloud services enable \
  saasservicemgmt.googleapis.com \
  storage.googleapis.com \
  telemetry.googleapis.com \
  texttospeech.googleapis.com \
  run.googleapis.com \
  artifactregistry.googleapis.com \
  cloudbuild.googleapis.com \
  dns.googleapis.com \
  accesscontextmanager.googleapis.com \
  discoveryengine.googleapis.com \
  agentidentity.googleapis.com \
  agentidentitycredentials.googleapis.com

5. Umgebungsvariablen exportieren

Definieren Sie wiederverwendbare Umgebungsvariablen für Region, Projekt-ID, Projektnummer, Organisations-ID und Nutzeridentität. Durch das Festlegen von Shell-Variablen werden Ressourcenkonfigurationsbefehle in allen Schritten standardisiert. So werden Fehler bei der manuellen Ersetzung während der Scriptausführung minimiert.

export REGION="us-central1"
export PROJ_ID=$(gcloud config list --format="value(core.project)")
export PROJ_NO=$(gcloud projects describe ${PROJ_ID} --format="value(projectNumber)")
export ORG_ID=$(gcloud projects get-ancestors ${PROJ_ID} --format="value(id)" | tail -n 1)
export USER_IDENTITY=$(gcloud config get-value account)

6. VPC Service Controls-Perimeter erstellen

Erstellen Sie einen VPC Service Controls-Perimeter, um Ihre Projektressourcen zu isolieren und Daten-Exfiltration zu verhindern. Weitere Informationen finden Sie unter VPC Service Controls.

Zugriffsrichtlinie abrufen

Rufen Sie die Access Context Manager-Richtlinien-ID ab, die mit Ihrer Organisation verknüpft ist. Access Context Manager-Richtlinien definieren die Organisationsgrenze, an die VPC Service Controls-Perimeter angehängt und erzwungen werden.

gcloud access-context-manager policies list --organization=$ORG_ID

Zugriffsrichtlinie exportieren

Legen Sie die Zugriffsrichtlinie in Ihrer gcloud CLI-Konfiguration fest und rufen Sie die Liste der unterstützten eingeschränkten Dienste ab. Wenn Sie alle unterstützten Dienste erfassen, können Sie einen eingeschränkten Perimetersatz erstellen, der unautorisierten Zugriff auf Google Cloud API-Endpunkte verhindert.

export ACCESS_POLICY=ACCESS_POLICY_ID

gcloud config set access_context_manager/policy $ACCESS_POLICY
SUPPORTED_SERVICES=$(gcloud access-context-manager supported-services list --format="value(name)" | paste -sd, -)

Perimeter erstellen

Definieren Sie den Namen des Dienstperimeters und erzwingen Sie Einschränkungen für unterstützte Google Cloud-Dienste im Projekt. Der Perimeter fungiert als Grenze um die Projektressourcen und schränkt den direkten eingehenden und ausgehenden Traffic ein, sofern er nicht ausdrücklich durch Regeln für eingehenden und ausgehenden Traffic zugelassen wird.

export PERIMETER_NAME="perimeter_${PROJ_NO}"

gcloud access-context-manager perimeters create accessPolicies/${ACCESS_POLICY}/servicePerimeters/${PERIMETER_NAME} \
--title="${PERIMETER_NAME}" \
--perimeter-type=regular \
--resources=projects/${PROJ_NO} \
--restricted-services=${SUPPORTED_SERVICES}

Richtlinie für eingehenden Traffic erstellen

Richtlinien für eingehenden Traffic definieren explizite Bedingungen, z. B. bestimmte Nutzeridentitäten oder Zugriffsebenen, unter denen Traffic außerhalb des Perimeters entsteht und eingeschränkte Ressourcen innerhalb des Perimeters erreichen darf.

Erstellen Sie eine YAML-Datei, die expliziten Zugriff für Ihre Nutzeridentität für alle Dienste ermöglicht:

cat > ingress-policy.yaml << EOF
- ingressFrom:
    identities:
      - user:${USER_IDENTITY}
    sources:
      - accessLevel: '*'
  ingressTo:
    operations:
      - serviceName: '*'
    resources:
      - '*'
EOF

Warnung:Die vorhergehende Konfiguration erlaubt einen Platzhalter (*) für alle Vorgänge und Ressourcen, um dieses Codelab zu vereinfachen. In einer Produktionsumgebung müssen Sie diese Richtlinie auf die spezifischen Dienste beschränken, die Sie verwenden möchten, um die Perimetersicherheit aufrechtzuerhalten.

gcloud access-context-manager perimeters update $PERIMETER_NAME --set-ingress-policies="ingress-policy.yaml"

In diesem Codelab wird Ihre Umgebung so konfiguriert, dass Zugriffsverweigerungen durch VPC Service Controls standardmäßig vermieden werden. Um Sie bei der Fehlerbehebung während des Tests zu unterstützen, bietet VPC Service Controls jedoch detaillierte Ablehnungslogs und Tools für Richtlinieninformationen.

Fehlerbehebung bei Ablehnungen von VPC Service Controls

Beachten Sie während des Tests die folgenden Tipps zur Fehlerbehebung:

1. Aktivieren Sie das Dashboard für Verstöße, um die neuesten Verstöße in Ihrer Umgebung zu verfolgen.
2. Überwachen Sie Cloud-Audit-Logs auf Logs zu Zugriffsverweigerungen (403) von VPC Service Controls.
3. Verstöße mithilfe der eindeutigen ID oder des Tokens im Analysetool für Verstöße diagnostizieren
4. Video zur Fehlerbehebung bei VPC Service Controls

7. Netzwerk einrichten

Hinweis:In dieser Anleitung wird das Standardnetzwerk im Projekt verwendet. Wenn Sie eine benutzerdefinierte VPC verwenden, muss ein Subnetz für Ihre Region erstellt werden.

VPC-Netzwerkeinstellungen für die Unterstützung der privaten Kommunikation mit Google APIs und ‑Diensten konfigurieren Eine korrekte Netzwerkkonfiguration sorgt dafür, dass der Netzwerkverkehr zwischen Agents, Gateways und Google Cloud APIs in privaten internen Netzwerken verbleibt. Detaillierte Netzwerkmuster finden Sie in der Google Cloud-VPC-Dokumentation.

Privaten Google-Zugriff aktivieren

Aktivieren Sie den privaten Google-Zugriff im Standardsubnetz, damit VM-Instanzen und interne Arbeitslasten über interne IP-Adressen anstelle von öffentlichen IP-Adressen auf Google APIs zugreifen können.

export NETWORK_NAME="default"
export SUBNET_NAME="default"

gcloud compute networks subnets update $SUBNET_NAME --region=$REGION --enable-private-ip-google-access

PSC-Netzwerkanhang erstellen

Erstellen Sie einen Private Service Connect-Netzwerkanhang (PSC) für die Agent Gateway-Verbindung. Netzwerk-Anhänge bieten Private Service Connect (PSC)-Schnittstellen, die eine sichere, VPC-übergreifende Kommunikation zwischen dem Agent Gateway-Dienst und Ihrem internen Subnetz ermöglichen.

gcloud compute network-attachments create psc-agw-${REGION} \
  --region=${REGION} \
  --subnets=${SUBNET_NAME} \
  --connection-preference=ACCEPT_AUTOMATIC

Bestätigen

Rufen Sie den Self-Link-Ressourcen-URI des neu erstellten Netzwerkanhangs ab und prüfen Sie ihn. Durch die Validierung des Ressourcen-URI wird sichergestellt, dass die Netzwerkverbindung erfolgreich instanziiert wurde und in Verbindungsvorlagen darauf verwiesen werden kann.

export PSC_NA_URI=$(gcloud compute network-attachments describe psc-agw-${REGION} \
  --region=${REGION} \
  --format="value(selfLink.scope(v1))")
echo ${PSC_NA_URI}

Private Cloud DNS-Zone erstellen

Konfigurieren Sie eine private Cloud DNS-Zone, um googleapis.com-Traffic über private IP-Bereiche weiterzuleiten. Private DNS-Zonen überschreiben öffentliche Domain-Lookups für googleapis.com und leiten den gesamten ausgehenden Traffic an private interne virtuelle IP-Adressen (VIPs) in Ihrem VPC-Netzwerk weiter. Weitere Informationen finden Sie unter Private Cloud DNS-Zonen.

export ZONE_NAME="gapis"

gcloud dns managed-zones create ${ZONE_NAME} \
--visibility=private \
--networks=https://www.googleapis.com/compute/v1/projects/${PROJ_ID}/global/networks/${NETWORK_NAME} \
  --description="Privately reach Google APIs" \
  --dns-name=googleapis.com

gcloud dns record-sets transaction start --zone=${ZONE_NAME}

Wählen Sie eine der folgenden Domainoptionen für das private Routing aus (führen Sie nur die Befehle unter Option 1 oder Option 2 aus, bevor Sie die Transaktion ausführen). Weitere Informationen finden Sie unter Konfigurationsoptionen für den privaten Google-Zugriff:

Option 1: Private VIP [Empfohlen]

gcloud dns record-sets transaction add --name="*.googleapis.com." \
    --type=CNAME private.googleapis.com. \
    --zone=${ZONE_NAME} \
    --ttl=300

gcloud dns record-sets transaction add --name=private.googleapis.com. \
    --type=A 199.36.153.8 199.36.153.9 199.36.153.10 199.36.153.11 \
    --zone=${ZONE_NAME} \
    --ttl=300

Option 2: Eingeschränkter VIP

gcloud dns record-sets transaction add --name="*.googleapis.com." \
    --type=CNAME restricted.googleapis.com. \
    --zone=${ZONE_NAME} \
    --ttl=300

gcloud dns record-sets transaction add --name=restricted.googleapis.com. \
    --type=A 199.36.153.4 199.36.153.5 199.36.153.6 199.36.153.7 \
    --zone=${ZONE_NAME} \
    --ttl=300

DNS-Transaktionen durchführen:

gcloud dns record-sets transaction execute --zone=${ZONE_NAME}

8. KI‑Agenten-Gateway erstellen

Stellen Sie das Agent Gateway bereit und definieren Sie die Verbindungsvorlagen und Routingregeln. Agent Gateway dient als zentralisierter Proxy für die Verwaltung von Agent-Traffic, Egress-Richtlinien, Protokollverarbeitung und sicherer Dienstermittlung. Architekturreferenzen finden Sie in der Übersicht über das Agent Gateway.

export AGW_NAME="gateway-${USER_IDENTITY}"
export AGW_CONNECTIVITY_TEMPLATE="agw-connectivity-template-${USER_IDENTITY}"

Vorlage für die Agent-Verbindung erstellen

In Konnektivitätsvorlagen werden die Netzwerkkonfiguration, die Routingrichtlinien für ausgehenden Traffic, die DNS-Peering-Einstellungen und die URIs für Netzwerkanhänge angegeben, die das Gateway zum Verarbeiten ausgehender Anfragen benötigt.

cat > ${AGW_CONNECTIVITY_TEMPLATE}.yaml << EOF
name: projects/${PROJ_NO}/locations/${REGION}/agentConnectivityTemplates/${AGW_CONNECTIVITY_TEMPLATE}
accessPath: AGENT_TO_ANYWHERE
deploymentModel: CENTRALIZED
egressNetworkConfig:
  networkAttachment: ${PSC_NA_URI}
  dnsPeeringConfig:
    domain: googleapis.com.
    targetNetwork: projects/${PROJ_ID}/global/networks/${NETWORK_NAME}
  vpcEgress: ALL_TRAFFIC
EOF

gcloud network-services agent-connectivity-templates import ${AGW_CONNECTIVITY_TEMPLATE} \
    --source="${AGW_CONNECTIVITY_TEMPLATE}.yaml" \
    --location=${REGION}

KI‑Agenten-Gateway erstellen

cat > ${AGW_NAME}-config.yaml << EOF
name: ${AGW_NAME}
protocols:
  - MCP
googleManaged:
  governedAccessPath: AGENT_TO_ANYWHERE
agentConnectivityTemplate: projects/${PROJ_NO}/locations/${REGION}/agentConnectivityTemplates/${AGW_CONNECTIVITY_TEMPLATE}
registries:
  - //agentregistry.googleapis.com/projects/${PROJ_NO}/locations/global
EOF

gcloud network-services agent-gateways import ${AGW_NAME} \
    --source="${AGW_NAME}-config.yaml" \
    --location=${REGION}

Erstellung bestätigen

Prüfen Sie, ob die Agent Gateway-Ressource erfolgreich bereitgestellt und konfiguriert wurde. Wenn Sie das bereitgestellte Agent-Gateway beschreiben, bestätigen Sie, dass der Betriebsstatus aktiv ist, und prüfen, ob die zugehörigen Verbindungsvorlagen und ‑registrierungen korrekt angehängt sind.

gcloud network-services agent-gateways describe ${AGW_NAME} \
  --location=${REGION}

9. Autorisierung über IAP erstellen

Konfigurieren Sie Autorisierungsrichtlinien für Identity-Aware Proxy-Anfragen (IAP) und Dienst-Extensions, um Anmeldedaten für Anfragen zu überprüfen, bevor Sie Zugriff auf das Agent Gateway gewähren. Weitere Informationen finden Sie in der IAP-Dokumentation.

export AUTHZ_EXT="iap-authz-extension-${USER_IDENTITY}"
export AUTHZ_POLICY="iap-authz-policy-${USER_IDENTITY}"

Autorisierungserweiterung erstellen

Hinweis:Bei diesem Schritt wird eine Erweiterung mit der IAP-Richtlinie V2 erstellt, die steuert, wie Autorisierungsrichtlinien ausgewertet werden. Die IAP-Richtlinie 2 bietet mehr Flexibilität beim Schreiben von Zugriffsrichtlinien für Agents. Weitere Informationen finden Sie in der Dokumentation zu Agent-Richtlinien.

Warnung:Der Einfachheit halber wird in diesem Codelab die Zugriffsrichtlinie direkt im erzwungenen Status bereitgestellt. In einer Produktionsumgebung sollten Sie Zugriffsrichtlinien zuerst im Probelaufmodus bereitstellen.

cat > ${AUTHZ_EXT}.yaml << EOF
name: ${AUTHZ_EXT}
service: iap.googleapis.com
failOpen: false
timeout: 1s
metadata:
  iapPolicyVersion: "V2"
EOF

gcloud service-extensions authz-extensions import ${AUTHZ_EXT} \
    --source=${AUTHZ_EXT}.yaml \
    --location=${REGION}

AuthZ-Richtlinie erstellen und an das Agent Gateway binden

cat > ${AUTHZ_POLICY}.yaml << EOF
name: ${AUTHZ_POLICY}
target:
  resources:
    - "projects/${PROJ_ID}/locations/${REGION}/agentGateways/${AGW_NAME}"
policyProfile: REQUEST_AUTHZ
action: CUSTOM
customProvider:
  authzExtension:
    resources:
      - "projects/${PROJ_ID}/locations/${REGION}/authzExtensions/${AUTHZ_EXT}"
EOF

gcloud network-security authz-policies import ${AUTHZ_POLICY} \
    --source=${AUTHZ_POLICY}.yaml \
    --location=${REGION}

In diesem Codelab wird sichergestellt, dass Sie standardmäßig keinen IAP-Zugriff verweigert bekommen. Um Ihre Tests zu unterstützen, bietet das Agent Gateway jedoch detaillierte Informationen zu Zugriffsverweigerungen.

Fehlerbehebung und Überwachung von Ablehnungen der IAP-Autorisierung

1. So aktivieren Sie Loganalysen für den Standard-Logging-Bucket:

gcloud logging buckets update _Default --location=global --enable-analytics --async

2. Öffnen Sie das Agent Gateway Observability-Dashboard:
3. Rufen Sie in der Google Cloud Console die Seite Agent Gateway auf.
4. Klicken Sie auf den Namen Ihres Gateways (z. B. „gateway-xyz“).
5. Klicken Sie auf den Tab Beobachtbarkeit.
6. Sehen Sie sich die Dashboards „Autorisierungsfehler“ und „403-Ablehnungen“ an.

10. Agent Engine-Agent erstellen

Staging-Bucket erstellen

Erstellen Sie einen Cloud Storage-Bucket in Ihrer Zielregion, um temporäre Staging-Artefakte, Abhängigkeiten und Bereitstellungskonfigurationen während der Laufzeitinitialisierung zu speichern.

#Staging bucket name needs to be globally unique
export STAGING_BUCKET="agent-temp-bucket-${PROJ_NO}-${USER_IDENTITY}"
gcloud storage buckets create gs://${STAGING_BUCKET} --location=${REGION}

Virtuelle Python-Umgebung aktivieren

python3 -m venv .venv
source .venv/bin/activate

Code des KI‑Agenten herunterladen

git clone https://github.com/gpratikab/gcp-vpcsc-agent.git
cd gcp-vpcsc-agent

Abhängigkeiten installieren

python3 -m pip install --upgrade -r requirements.txt

IAM-Rollen dem Dienst-Agent der Agent Platform zuweisen

gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="serviceAccount:service-${PROJ_NO}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
  --role="roles/agentgateway.serviceAgent"
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="serviceAccount:service-${PROJ_NO}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
  --role="roles/ml.serviceAgent"
gcloud projects add-iam-policy-binding ${PROJ_ID} \
  --member="serviceAccount:service-${PROJ_NO}@gcp-sa-aiplatform.iam.gserviceaccount.com" \
  --role="roles/networkservices.viewer"

KI-Agent bereitstellen

Hinweis:Dieser Beispiel-ADK-Agent (Agent Development Kit) wird in Vertex AI Agent Engine bereitgestellt und greift auf Cloud Storage- und Agent Registry Model Context Protocol (MCP)-Endpunkte zu. Details zum Agent-Code finden Sie in der Datei „README.md“ im Repository.

python3 deploy_gcp_agent.py create

Exportieren Sie die Agent-Identität, die in der Ausgabe des vorherigen Befehls ausgegeben wurde, als Umgebungsvariable:

#Paste identity of your Agent, it will be printed as the output of the previous command
export AGENT_IDENTITY="principal://PRINCIPAL_ID"
echo $AGENT_IDENTITY

11. Ausgehenden Traffic von KI-Agenten über Gateway zulassen

Erlauben Sie dem neu erstellten Agent, ausgehenden Traffic an googleapis.com zu senden.

Hinweis:Sie können Endpunkte selektiv auf die Zulassungsliste setzen, indem Sie die Agent Gateway-Beobachtbarkeit verwenden. Der Einfachheit halber wird in diesem Codelab der Zugriff auf alle APIs gewährt.

Durch das Konfigurieren expliziter IAM-Regeln für ausgehenden Traffic erhält der Agent die Berechtigung, API-Aufrufe über das Agent Gateway und den IAP-Proxy an externe Google Cloud-Dienste weiterzuleiten.

IAM-Richtlinie erstellen

cat > agent-access-rules.json << EOF
{
  "conditions": {
    "iap.googleapis.com": {
      "description": "Allow access to agent",
      "expression": "(destination.agent_registry.location == 'global') || (destination.unregistered.host.endsWith('googleapis.com'))",
      "title": "agenttogapis"
    }
  },
  "description": "agenttogapis",
  "effect": "ALLOW",
  "excludedPrincipals": [],
  "operation": {
    "excludedPermissions": [],
    "permissions": [
      "iap.googleapis.com/resources.egressViaIAP"
    ]
  },
  "principals": [
    "${AGENT_IDENTITY}"
  ]
}
EOF

Zugriffsrichtlinie aktualisieren

So prüfen Sie, ob Sie bereits eine Zugriffsrichtlinie haben:

gcloud iam access-policies list --project=${PROJ_ID} --location=global

Name der Zugriffsrichtlinie festlegen:

export IAM_ACCESS_POLICY="agent-access-policy"

So erstellst du eine neue Richtlinie:

gcloud iam access-policies create ${IAM_ACCESS_POLICY} \
  --details-rules=agent-access-rules.json \
  --project=${PROJ_ID} \
  --location=global

Alternativ können Sie eine vorhandene Richtlinie aktualisieren:

gcloud iam access-policies update ${IAM_ACCESS_POLICY} \
  --add-details-rules=agent-access-rules.json \
  --project=${PROJ_ID} \
  --location=global

12. KI-Agenten testen

Wenn Sie den Agent-Betrieb in der Google Cloud Console validieren, prüfen Sie, ob die End-to-End-Kommunikation, IAM-Richtlinien und VPC Service Controls-Grenzen ordnungsgemäß funktionieren. Jetzt können Sie den Agenten testen:

1. Rufen Sie in der Google Cloud Console die Seite Agent-Bereitstellungen auf.
2. Wählen Sie den bereitgestellten KI-Agenten (gcp_agent_...) aus.
3. Öffnen Sie den Tab Playground.
4. Geben Sie im Prompt-Feld Folgendes ein: List storage buckets in the current project.
5. Prüfen Sie, ob der Agent die Liste der Buckets über das private Agent Gateway zurückgibt.
6. Prüfen Sie, ob der Agent aufgrund einer Zugriffsverweigerung keine Buckets aus einem anderen Projekt abrufen kann. Sie können die Verweigerung in Cloud-Audit-Logs oder im Dashboard für VPC Service Controls-Verstöße prüfen.

13. Bereinigen

Damit Ihrem Google Cloud-Konto die in diesem Codelab verwendeten Ressourcen nicht in Rechnung gestellt werden, löschen Sie das erstellte Projekt:

gcloud projects delete ${PROJ_ID}

14. Glückwunsch

Glückwunsch! Sie haben einen Agent und ein Agent Gateway innerhalb eines sicheren VPC Service Controls-Perimeters in Google Cloud konfiguriert.

Nächste Schritte

• Detaillierte Regeln für ein- und ausgehenden Traffic in VPC Service Controls
• Zugriffs- und semantische Richtlinien mit dem Agent Gateway konfigurieren
• Binden Sie Model Armor für erweiterte Sicherheits- und Sicherheitsfilter ein.

Referenzdokumentation

• VPC Service Controls – Übersicht
• Agent Gateway-Richtlinien – Übersicht
• Model Armor – Übersicht