Agent Gateway für cloudübergreifende Nutzung einrichten

In diesem Leitfaden wird beschrieben, wie Sie Agent Gateway für Cross-Cloud auf Standard-Kubernetes-Clustern bereitstellen, um die Governance der Gemini Enterprise Agent Platform auf Ihre Umgebung auszuweiten. Eine Übersicht über die Architektur mit drei Ebenen finden Sie unter Agent Gateway für cloudübergreifende Übersicht.

Hinweis

Bevor Sie beginnen, benötigen Sie Folgendes:

  • Ein CNCF-konformer (Cloud Native Computing Foundation) Kubernetes-Cluster.
  • Ein vorhandenes Service Mesh oder ein vorhandener Netzwerkstack, der in Ihrem Cluster konfiguriert ist.
  • Ausgehende Netzwerkverbindung von Ihrem Cluster zu Google Cloud APIs über HTTPS (TCP-Port 443).
  • Die Google Cloud CLI-Version 591.0.0 oder höher ist installiert. Zum Aktualisieren auf die aktuelle Version führen Sie gcloud components update aus.
  • Die IAM-Rollen (Identity and Access Management) in Ihrem Google Cloud -Projekt, die Sie benötigen, um APIs zu aktivieren, einen Workload Identity-Pool und einen Anbieter zu erstellen und IAM-Rollen zuzuweisen.

APIs aktivieren und Cluster registrieren

Aktivieren Sie die erforderlichen Google Cloud -APIs und registrieren Sie dann Ihren externen Cluster.

Erforderliche APIs aktivieren

Führen Sie den folgenden Befehl aus, um die APIs zu aktivieren, die Agent Gateway für cloudübergreifende Anforderungen benötigt:

gcloud services enable \
    agentregistry.googleapis.com \
    apphubendpoint.googleapis.com \
    cloudresourcemanager.googleapis.com \
    cloudtrace.googleapis.com \
    iam.googleapis.com \
    iamcredentials.googleapis.com \
    iap.googleapis.com \
    logging.googleapis.com \
    modelarmor.googleapis.com \
    monitoring.googleapis.com \
    networkservices.googleapis.com \
    serviceextensions.googleapis.com \
    sts.googleapis.com \
    telemetry.googleapis.com \
    trafficdirector.googleapis.com \
    --project=PROJECT_ID

Ersetzen Sie PROJECT_ID durch die ID Ihres Projekts vonGoogle Cloud .

Öffentlichen Schlüssel des Kubernetes API-Servers extrahieren

Zum Registrieren Ihres Clusters benötigen Sie den öffentlichen Schlüssel, den Ihr Cluster zum Signieren von Dienstkontotokens verwendet. So extrahieren Sie den öffentlichen Schlüssel:

  1. Legen Sie den aktuellen kubectl-Kontext auf den Cluster fest, den Sie registrieren möchten.

  2. Rufen Sie das JSON Web Key Set (JWKS) Ihres Clusters ab und konvertieren Sie dann den ersten RSA-Schlüssel in eine Datei mit dem öffentlichen Schlüssel namens pubkey.pem:

    kubectl get --raw /openid/v1/jwks > cluster-jwks.json
    
    N_HEX=$(jq -r '[.keys[] | select((.kty // "" | ascii_upcase) == "RSA" and (.n // "") != "" and (.e // "") != "")][0].n | gsub("-";"+") | gsub("_";"/") | . + ("==="[:(4 - length % 4) % 4])' cluster-jwks.json | base64 -d | od -An -tx1 | tr -d ' \n')
    E_HEX=$(jq -r '[.keys[] | select((.kty // "" | ascii_upcase) == "RSA" and (.n // "") != "" and (.e // "") != "")][0].e | gsub("-";"+") | gsub("_";"/") | . + ("==="[:(4 - length % 4) % 4])' cluster-jwks.json | base64 -d | od -An -tx1 | tr -d ' \n')
    
    openssl asn1parse -genconf <(printf "asn1=SEQUENCE:rsa_key\n[rsa_key]\nmodulus=INTEGER:0x%s\nexponent=INTEGER:0x%s\n" "$N_HEX" "$E_HEX") -noout -out /dev/stdout \
      | openssl rsa -RSAPublicKey_in -inform DER -pubout -out pubkey.pem
    

    Für diese Befehle sind eine Bash-Shell und die Dienstprogramme jq und openssl erforderlich.

Cluster registrieren

So registrieren Sie Ihren Cluster:

  1. Rufen Sie die OIDC-Aussteller-URL (OpenID Connect) Ihres Clusters ab:

    kubectl get --raw /.well-known/openid-configuration | jq -r '.issuer'
    

    Die Ausgabe ist der Wert des Flags --service-account-issuer des Kubernetes API-Servers Ihres Clusters. Dieser Wert kann von der externen URL Ihres Kubernetes API-Servers abweichen. Kopieren Sie die Ausgabe genau. Fügen Sie keinen abschließenden Schrägstrich hinzu und entfernen Sie ihn nicht.

  2. Registrieren Sie den Cluster:

    gcloud alpha network-services registered-clusters create CLUSTER_NAME \
        --project=PROJECT_ID \
        --location=LOCATION \
        --oidc-issuer-url=OIDC_ISSUER_URL \
        --api-server-public-key="$(cat pubkey.pem)"
    

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: ein Name für den registrierten Cluster.
    • PROJECT_ID: die ID Ihres Projekts in Google Cloud.
    • LOCATION: Die Google Cloud Region für den registrierten Cluster, z. B. us-central1.
    • OIDC_ISSUER_URL: die genaue Aussteller-URL, die Sie im vorherigen Schritt abgerufen haben. Die URL muss mit https:// beginnen.

Versehentliches Löschen von Ressourcen verhindern

Wenn Sie Ihr Google Cloud -Projekt löschen oder die Registrierung eines registrierten Clusters aufheben, während cloudübergreifende Arbeitslasten aktiv sind, werden die Controller im Cluster getrennt und die Richtlinienerzwingung wird unterbrochen. Wenden Sie die folgenden Sicherheitsmaßnahmen an, um Ihre Google Cloud -Ressourcen vor versehentlichem Löschen zu schützen:

  • Google Cloud -Projekt mit Sperren schützen: Wenden Sie eine Projektsperre auf dasGoogle Cloud -Projekt an, das Ihren registrierten Cluster, die Agent Registry und föderierte Identitätspools hostet, um ein versehentliches Löschen des Projekts zu verhindern, bis alle cloudübergreifenden Cluster außer Betrieb genommen wurden.
  • Destruktive IAM-Berechtigungen einschränken: Beschränken Sie Berechtigungen, mit denen registrierte Cluster oder Gateway-Ressourcen (z. B. networkservices.registeredClusters.delete und networkservices.agentGateways.delete) gelöscht werden können, auf dedizierte Plattformadministratorrollen.
  • Kubernetes-Ressourcen-Finalizer beibehalten: Entfernen Sie keine Finalizer für benutzerdefinierte Ressourcen im Cluster, die vom agent-governance-cross-cloud-controller-Controller verwaltet werden. Finalizer sorgen dafür, dass die entsprechenden Registrierungen der Google Cloud -Steuerungsebene ordnungsgemäß aufgehoben werden, bevor lokale Clusterressourcen entfernt werden.
  • Benutzerdefinierte Ressourcen vor dem Entfernen des Controllers löschen: Bevor Sie das Helm-Diagramm agent-governance-cross-cloud deinstallieren oder Ihren Kubernetes-Cluster löschen, löschen Sie alle benutzerdefinierten Ressourcen GCPExtensionBinding und GCPAgentGateway und warten Sie, bis der Löschvorgang abgeschlossen ist. Wenn Sie zuerst den Controller entfernen, bleibt die entsprechende Agent-Gateway-Ressource in Network Services verwaist. Das verwaiste Gateway verhindert das Löschen der Konnektivitätsvorlage des KI-Agenten und des registrierten Clusters.

Identitätsföderation von Arbeitslasten konfigurieren

Die clusterinternen Komponenten von Agent Gateway für Cloudübergreifend – der agent-governance-cross-cloud-controller-Controller, der Telemetrie-Collector und der Proxy – verwenden die Identitätsföderation von Arbeitslasten, um sich beiGoogle Cloud -APIs zu authentifizieren. Jede Komponente tauscht ihr Kubernetes-Dienstkonto-Token (KSA) gegen ein föderiertes Zugriffstoken aus. Sie weisen diesen föderierten Identitäten IAM-Rollen direkt zu. Daher müssen Sie keineGoogle Cloud -Dienstkonten erstellen oder Dienstkontoschlüssel in Ihrem Cluster speichern.

Die Agent Identity Runtime (AIR)-Sidecar, die mit jedem Proxy ausgeführt wird, verwendet den Workload Identity-Pool, um Ihren Agent-Arbeitslasten SPIFFE-Identitäten bereitzustellen. Diese Identitäten sind die Agent-Identitäten Ihrer Agenten. Model Armor- und IAP-Richtlinien identifizieren Agenten anhand ihrer Agentenidentität, nicht anhand der föderierten Identitäten der clusterinternen Komponenten. Informationen zum Agenten-Prinzipal-Format finden Sie unter Agenten-Hauptkonto identifizieren.

Workload Identity-Pool und -Poolanbieter erstellen

So erstellen Sie einen Workload Identity-Pool und einen OIDC-Anbieter für Ihren Cluster:

  1. Wenn die OIDC-Aussteller-URL Ihres Clusters nicht öffentlich erreichbar ist, speichern Sie das JSON Web Key Set (JWKS) Ihres Clusters in einer Datei:

    kubectl get --raw /openid/v1/jwks > cluster-jwks.json
    

    Wenn Sie dem Anbieter das JWKS zur Verfügung stellen, kann Google Cloud KSA-Tokens verifizieren, ohne eine Verbindung zum OIDC-Aussteller Ihres Clusters herzustellen.

  2. Erstellen Sie einen Workload Identity-Pool:

    gcloud iam workload-identity-pools create POOL_ID \
        --project=PROJECT_ID \
        --location=global \
        --display-name="POOL_DISPLAY_NAME"
    
  3. Erstellen Sie einen OIDC-Anbieter im Pool:

    gcloud iam workload-identity-pools providers create-oidc PROVIDER_ID \
        --project=PROJECT_ID \
        --location=global \
        --workload-identity-pool=POOL_ID \
        --issuer-uri=OIDC_ISSUER_URL \
        --jwk-json-path=cluster-jwks.json \
        --attribute-mapping="google.subject=assertion.sub,attribute.namespace=assertion['kubernetes.io']['namespace'],attribute.service_account=assertion['kubernetes.io']['serviceaccount']['name']"
    

    Geben Sie das Flag --allowed-audiences nicht an. Die cloudübergreifenden Komponenten fordern Tokens für die Standardzielgruppe an, die dem vollständigen Ressourcennamen des Anbieters entspricht: //iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/providers/PROVIDER_ID.

Ersetzen Sie Folgendes:

  • POOL_ID: eine ID für den Workload Identity-Pool.
  • PROJECT_ID: Projekt-ID in Google Cloud .
  • POOL_DISPLAY_NAME: Ein Anzeigename für den Pool.
  • PROVIDER_ID: eine ID für den OIDC-Anbieter.
  • OIDC_ISSUER_URL: die genaue OIDC-Aussteller-URL, die Sie beim Registrieren des Clusters abgerufen haben. Dieser Wert muss mit dem Wert übereinstimmen, den Sie an --oidc-issuer-url übergeben haben, einschließlich der Angabe, ob er mit einem abschließenden Schrägstrich endet.

Steuerungsebene bereitstellen

Verwenden Sie das bereitgestellte Helm-Diagramm, um den In-Cluster-Controller agent-governance-cross-cloud-controller und den Telemetrie-Collector im Namespace geap-system bereitzustellen.

Konnektivität für den Controller sicherstellen

Achten Sie darauf, dass die Firewall, der Proxy, die Regeln für ausgehenden Traffic und die Netzwerkrichtlinien Ihres Clusters die folgenden Verbindungen zulassen:

  • Google Cloud -APIs: Die agent-governance-cross-cloud-controller-Controller-Pods und der Telemetrie-Collector müssen ausgehende HTTPS- und gRPC-Verbindungen über TCP-Port 443 zu *.googleapis.com haben.
  • Kubernetes API-Server: Die Controller-Pods müssen den Kubernetes API-Server erreichen können, um Kubernetes-Dienste, Arbeitslasten und benutzerdefinierte Ressourcen zu beobachten.
  • Agent-Arbeitslasten in allen Namespaces: Die Controller-Pods müssen in der Lage sein, Agent- und MCP-Server-Pods in jedem Namespace im Cluster aufzurufen. Der Controller ruft die Agentenkarte von jeder Agentenarbeitslast ab, um den Agenten in Agent Registry zu registrieren.

Controller und Telemetrie-Collector IAM-Rollen zuweisen

Weisen Sie den föderierten Identitäten des agent-governance-cross-cloud-controller-Controllers und des Telemetrie-Collectors, die im Namespace geap-system ausgeführt werden, IAM-Rollen zu:

  • Satellitenbetreiber (roles/networkservices.satelliteOperator)
  • Cloud Telemetry Writer (roles/telemetry.writer)

Führen Sie den folgenden Befehl aus, um die Rollen zuzuweisen:

for ROLE in \
    roles/networkservices.satelliteOperator \
    roles/telemetry.writer; do
  gcloud projects add-iam-policy-binding PROJECT_ID \
      --role="${ROLE}" \
      --member="principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/attribute.namespace/geap-system"
done

Ersetzen Sie Folgendes:

  • PROJECT_ID: Projekt-ID in Google Cloud .
  • PROJECT_NUMBER: Ihre Google Cloud -Projektnummer.
  • POOL_ID: die ID des Workload Identity-Pools.

Helm-Diagramm für die Steuerungsebene installieren

So installieren Sie die Steuerungsebene:

  1. Installieren Sie das Helm-Diagramm agent-governance-cross-cloud im Namespace geap-system:

    helm upgrade --install agent-governance-cross-cloud \
        oci://gcr.io/gke-release/agent-governance-cross-cloud \
        --version 0.1.1-preview \
        --namespace geap-system \
        --create-namespace \
        --set gcp.projectId=PROJECT_ID \
        --set-string gcp.projectNumber=PROJECT_NUMBER \
        --set-string gcp.orgId=ORGANIZATION_ID \
        --set gcp.location=LOCATION \
        --set gcp.registeredCluster=CLUSTER_NAME \
        --set gcp.workloadIdentityPool=POOL_ID \
        --set gcp.identityProvider=PROVIDER_ID
    

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Projekt-ID in Google Cloud .
    • PROJECT_NUMBER: Ihre Google Cloud -Projektnummer.
    • ORGANIZATION_ID: die ID IhrerGoogle Cloud -Organisation. Wenn Ihr Projekt nicht mit einer Organisation verknüpft ist, lassen Sie das Flag --set-string gcp.orgId weg.
    • LOCATION: die Region, in der Sie den Cluster registriert haben, z. B. us-central1.
    • CLUSTER_NAME: der Name des registrierten Clusters.
    • POOL_ID: die ID des Workload Identity-Pools.
    • PROVIDER_ID: die ID des Workload Identity-Poolanbieters.

    Wenn die Knoten Ihres Clusters Markierungen haben, z. B. arm64-Knoten bei den meisten Cloud-Anbietern, einschließlich Google Cloud, AWS und Azure, legen Sie Pod-Toleranzen im Helm-Wert k8s.tolerations fest. Die Toleranzen gelten für den Controller, den OpenTelemetry-Collector (OTel) und die Gateway-Bereitstellungen, die der Controller erstellt. Speichern Sie beispielsweise Folgendes als tolerations-values.yaml und fügen Sie dann --values tolerations-values.yaml dem vorherigen Befehl hinzu:

    k8s:
      tolerations:
      - key: "kubernetes.io/arch"
        operator: "Equal"
        value: "arm64"
        effect: "NoSchedule"
    
  2. Warten Sie, bis die Controller-Bereitstellung bereit ist:

    kubectl rollout status deployment/agent-governance-cross-cloud-controller \
        --namespace geap-system --timeout=180s
    

Datenebene bereitstellen

Stellen Sie das Agent Gateway für den cloudübergreifenden Proxy (Envoy-Proxy) bereit, indem Sie eine benutzerdefinierte GCPAgentGateway-Ressource erstellen. Der Proxy prüft den Traffic und setzt Richtlinien für die von ihm verwalteten Agent-Arbeitslasten durch. Jeder Proxy wird mit einem Agent Identity Runtime (AIR)-Sidecar ausgeführt, das Workload Identities, Secret Discovery Service (SDS)-Zertifikate und den lokalen Tokenaustausch für den Proxy vermittelt.

Sie müssen Agent Gateway für cloudübergreifende Zwecke in einem dedizierten Namespace (z. B. agent-gateway-system) bereitstellen, der keine Agent-Arbeitslasten, MCP-Server oder andere Anwendungs-Pods enthält. Ein einzelnes Gateway in diesem dedizierten Namespace kann den ausgehenden Traffic von Agent-Arbeitslasten im gesamten Cluster steuern.

Dem Gateway IAM-Rollen zuweisen

Weisen Sie den föderierten Identitäten des Agent-Gateways für den cloudübergreifenden Proxy IAM-Rollen zu. Die Bindung gilt für alle KSAs im Gateway-Namespace. Gewähren Sie diese Rollen daher für jeden Gateway-Namespace:

  • Traffic Director-Client (roles/trafficdirector.client)
  • App Hub Endpoint Viewer (roles/apphubendpoint.viewer)
  • Agent Registry Viewer (roles/agentregistry.viewer)
  • Service Extensions Editor (roles/serviceextensions.editor), mit der der Proxy Service Extensions-Richtlinien-Callouts aufrufen kann

Führen Sie den folgenden Befehl aus, um die Rollen zuzuweisen:

for ROLE in \
    roles/trafficdirector.client \
    roles/apphubendpoint.viewer \
    roles/agentregistry.viewer \
    roles/serviceextensions.editor; do
  gcloud projects add-iam-policy-binding PROJECT_ID \
      --role="${ROLE}" \
      --member="principalSet://iam.googleapis.com/projects/PROJECT_NUMBER/locations/global/workloadIdentityPools/POOL_ID/attribute.namespace/GATEWAY_NAMESPACE"
done

Ersetzen Sie Folgendes:

  • PROJECT_ID: Projekt-ID in Google Cloud .
  • PROJECT_NUMBER: Ihre Google Cloud -Projektnummer.
  • POOL_ID: die ID des Workload Identity-Pools.
  • GATEWAY_NAMESPACE: ein dedizierter Namespace für das Gateway. Dieser Namespace darf keine Agent-Arbeitslasten enthalten.

Vorlage für die Agent-Konnektivität erstellen

Jedes Gateway verweist auf eine Vorlage für die Agent-Konnektivität. Das ist eineGoogle Cloud -Ressource, die auf Ihren registrierten Cluster verweist. Sie müssen nicht für jedes Gateway eine separate Vorlage erstellen, sondern können mehrere Gateways einer einzelnen Vorlage zuordnen. Sie können auch mehrere Vorlagen für denselben Cluster erstellen.

Wenn Sie bereits eine Agent-Konnektivitätsvorlage für Ihren Cluster haben, die Sie verwenden möchten, fahren Sie mit Gateway erstellen fort.

So erstellen Sie eine Vorlage für die Agent-Konnektivität:

  1. Speichern Sie die folgende Vorlagendefinition als act.yaml:

    description: "Agent connectivity template for CLUSTER_NAME"
    agentCompute: K8S
    registeredCluster: "projects/PROJECT_ID/locations/LOCATION/registeredClusters/CLUSTER_NAME"
    
  2. Importieren Sie die Vorlage:

    gcloud alpha network-services agent-connectivity-templates import ACT_NAME \
        --project=PROJECT_ID \
        --location=LOCATION \
        --source=act.yaml
    

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: der Name des registrierten Clusters.
  • PROJECT_ID: Projekt-ID in Google Cloud .
  • LOCATION: Die Region, in der Sie den Cluster registriert haben.
  • ACT_NAME: ein Name für die Agent-Konnektivitätsvorlage.

Gateway erstellen

So erstellen Sie das Gateway:

  1. Wenn der Gateway-Namespace noch nicht vorhanden ist, erstellen Sie ihn:

    kubectl create namespace GATEWAY_NAMESPACE
    

    Ersetzen Sie GATEWAY_NAMESPACE durch den dedizierten Namespace für das Gateway, den Sie beim Zuweisen von Rollen für das Gateway verwendet haben.

  2. Speichern Sie das folgende Manifest als agent-gateway.yaml:

    apiVersion: networkservices.googleapis.com/v1alpha1
    kind: GCPAgentGateway
    metadata:
      name: GATEWAY_NAME
      namespace: GATEWAY_NAMESPACE
    spec:
      agentConnectivityTemplateUri: "projects/PROJECT_ID/locations/LOCATION/agentConnectivityTemplates/ACT_NAME"
    

    Ersetzen Sie Folgendes:

    • GATEWAY_NAME: ein Name für das Gateway.
    • GATEWAY_NAMESPACE: Der dedizierte Namespace für das Gateway, den Sie verwendet haben, als Sie dem Gateway Rollen zugewiesen haben.
    • PROJECT_ID: Projekt-ID in Google Cloud .
    • LOCATION: die Region der Agent-Konnektivitätsvorlage. Diese Region muss mit der Region übereinstimmen, in der Sie den Cluster registriert haben.
    • ACT_NAME: der Name der Agent-Konnektivitätsvorlage.
  3. Wenden Sie das Manifest an:

    kubectl apply -f agent-gateway.yaml
    
  4. Warten Sie, bis das Gateway bereitgestellt und bereit ist:

    kubectl wait --for=condition=Reconciled=True \
        gcpagentgateway/GATEWAY_NAME \
        -n GATEWAY_NAMESPACE \
        --timeout=300s
    

    Wenn das Gateway bereit ist, gibt der Befehl gcpagentgateway.networkservices.googleapis.com/GATEWAY_NAME condition met zurück.

  5. Konfigurieren Sie Ihr Service Mesh so, dass ausgehender Agent-Traffic, z. B. Anfragen an Large Language Models (LLMs), Model Context Protocol (MCP) und Agent-to-Agent (A2A), über das Gateway weitergeleitet wird.

Toleranzen zu vorhandenen Gateways hinzufügen

Wenn Sie den Helm-Wert k8s.tolerations nach dem Erstellen einer GCPAgentGateway-Ressource hinzufügen, gehen Sie so vor, damit der Controller das Gateway-Deployment mit den neuen Toleranzen neu erstellt:

  1. Führen Sie den Befehl helm upgrade --install aus Helm-Diagramm für die Steuerungsebene installieren mit --values tolerations-values.yaml aus.

  2. Löschen Sie die vorhandene Gateway-Bereitstellung:

    kubectl delete deployment GATEWAY_NAME \
        --namespace GATEWAY_NAMESPACE
    

    Wiederholen Sie diesen Schritt für jedes Gateway in Ihrem Cluster.

  3. Starten Sie den Controller neu, damit er das Gateway-Deployment neu erstellt:

    kubectl rollout restart deployment/agent-governance-cross-cloud-controller \
        --namespace geap-system
    

Dieses Verfahren hat keine Auswirkungen auf die Ressource Google Cloud AgentGateway oder auf angehängte GCPExtensionBinding-Ressourcen. Ausgehender Traffic über das Gateway wird unterbrochen, bis der Controller das Gateway-Deployment neu erstellt.

Ausgehende Verbindungen zu Google APIs zulassen

Achten Sie darauf, dass das Agent Gateway für cloudübergreifende Proxy-Pods ausgehende HTTPS- und gRPC-Verbindungen zu *.googleapis.com über TCP-Port 443 hat.

TLS-Prüfung konfigurieren

Konfigurieren Sie die TLS-Prüfung (Transport Layer Security), damit Agent Gateway für Cross-Cloud ausgehenden Traffic prüfen und steuern kann.

TLS-Prüfungs-CA-Secret sichern

Das Agent Gateway für Cross-Cloud verwendet eine Root-Zertifizierungsstelle, um die Zertifikate auszustellen, die es bei der Prüfung des ausgehenden TLS-Traffics vorlegt. Der Controller erstellt diese Zertifizierungsstelle beim Start. Die Zertifizierungsstelle, einschließlich ihres privaten Schlüssels, wird in Kubernetes-Secret-Ressourcen in zwei Namespaces gespeichert: im Controller-Namespace (geap-system) und im Gateway-Namespace, in dem das Agent-Gateway für den cloudübergreifenden Proxy und die AIR-Sidecar bereitgestellt werden. Jeder, der diese Secret-Ressourcen lesen kann, kann externe Endpunkte für Ihre Agent-Arbeitslasten imitieren. Wenden Sie die folgenden Sicherheitsmaßnahmen an, um die Zertifizierungsstelle zu schützen:

  • RBAC-Zugriff auf Secret einschränken: Beschränken Sie die Berechtigungen get, list und watch für Secret-Ressourcen in den Namespaces geap-system und Gateway auf das Agent Gateway für cloudübergreifende Dienstkonten und dedizierte Plattformadministratoren. Mit den Berechtigungen list und watch werden auch Secret-Inhalte freigegeben.
  • Controller- und Gateway-Namespaces isolieren: Nutzer, die Pods in einem Namespace erstellen können, können alle Secret in diesem Namespace bereitstellen. Führen Sie nur das Agent-Gateway für cloudübergreifende Komponenten im Namespace geap-system und im Gateway-Namespace aus. Stellen Sie in diesen Namespaces keine Agent-Arbeitslasten oder andere Pods bereit. Beschränken Sie die Berechtigungen zum Erstellen oder Ändern von Pods, Deployments und anderen Arbeitslastressourcen in diesen Namespaces auf vertrauenswürdige Administratoren.
  • Secret-Daten im Ruhezustand verschlüsseln: Aktivieren Sie die Verschlüsselung im Ruhezustand für Secret-Ressourcen im etcd-Datenspeicher Ihres Clusters. Verwenden Sie nach Möglichkeit einen KMS-Anbieter, um die Verschlüsselungsschlüssel zu verwalten.
  • Zugriff auf die Secret prüfen: Aktivieren Sie das Kubernetes-Audit-Logging und überwachen Sie den Lesezugriff auf die Zertifizierungsstelle Secret.

Nächste Schritte