Granulare NAT für GKE konfigurieren

In diesem Dokument wird beschrieben, wie Sie die granulare NAT von Google Kubernetes Engine (GKE) konfigurieren, um bestimmten Kubernetes-Namespaces dedizierte IP-Adressen für ausgehenden Traffic zuzuweisen.

Mit Granular NAT können Sie bestimmte externe Quell-IP-Adressen für Public NAT oder bestimmte interne Quell-IP-Adressen für Private NAT konfigurieren, die von Cloud NAT-Gateways unterstützt werden.

Wenn Sie Granular NAT konfigurieren möchten, deklarieren Sie Ihre Routingrichtlinien mit zwei benutzerdefinierten Ressourcen auf Clusterebene:

  • CloudNATGateway: Verwenden Sie diese Ressource, um ein neues öffentliches oder privates Cloud NAT-Gateway für Ihren Cluster bereitzustellen oder Ihren Cluster so zu konfigurieren, dass ein vorhandenes Cloud NAT-Gateway verwendet wird. Das Cloud NAT-Gateway muss sich in der Region und im VPC-Netzwerk Ihres Clusters befinden.
  • TrafficSelector: Mit dieser Ressource können Sie Ihre Routingregeln für ausgehenden Traffic definieren, indem Sie Quell-Namespaces (namespaceSelector) und Ziel-CIDRs einem Ziel-CloudNATGateway zuordnen.

Hinweis

Bevor Sie die granulare NAT für GKE konfigurieren, müssen Sie die folgenden Voraussetzungen erfüllen:

  • Clusteranforderungen prüfen: Prüfen Sie, ob auf Ihrem VPC-nativen Cluster die GKE-Version 1.37.1-gke.2611000 oder höher mit aktiviertem GKE Dataplane V2 ausgeführt wird. GKE Granular NAT wird sowohl in Autopilot- als auch in Standard-Clustern sowie in regionalen und zonalen Clustern unterstützt.
  • IAM-Berechtigungen prüfen:
    • Prüfen Sie, ob Sie die Rolle „Kubernetes Engine-Administrator“ (roles/container.admin) für den Cluster haben, um benutzerdefinierte Ressourcen anzuwenden.
    • Bei Verwendung einer freigegebene VPC: Der Administrator des Hostprojekts muss dem GKE-Dienst-Agent (service-SERVICE_PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com) Ihres Dienstprojekts die Rolle „Compute-Netzwerkadministrator“ (roles/compute.networkAdmin) in der IAM-Richtlinie des Hostprojekts zuweisen. Mit dieser Rolle kann GKE die zugrunde liegenden Cloud NAT-Gateways, Cloud Router und IP-Adressen im freigegebene VPC-Netzwerk erstellen und verwalten. Für eigenständige VPC-Netzwerke ist diese manuelle Gewährung nicht erforderlich.
  • Firewallregeln bei Bedarf aktualisieren, um Link-Local-IP-Adressen einzuschließen: Bevor ausgehende Pakete einen Knoten verlassen, übersetzt GKE Granular NAT ihre Quell-IP-Adresse in eine Link-Local-Adresse im Bereich 169.254.32.0/20. Wenn in Ihrer Organisation strenge benutzerdefinierte Firewallregeln erzwungen werden, prüfen Sie, ob Ihre Regeln dieses Verhalten berücksichtigen:
    • Regeln für ausgehenden Traffic: Vermeiden Sie die Angabe eines Quellparameters in Zulassungsregeln für ausgehenden Traffic, deren Ziele Clusterknoten sind. Wenn Sie einen Quellparameter angeben, müssen Sie den Link-Local-Adressbereich (169.254.32.0/20) angeben.
    • Regeln für eingehenden Traffic: Vermeiden Sie die Angabe des Zielparameters in Zulassungsregeln für eingehenden Traffic, deren Ziele Clusterknoten sind. Wenn Sie einen Zielparameter angeben, müssen Sie den Link-Local-Adressbereich (169.254.32.0/20) angeben.
  • VPC-interner Traffic: Achten Sie darauf, dass TrafficSelector-Ressourcen keine Ziel-CIDRs von Subnetzbereichen im VPC-Netzwerk des Clusters oder in einem anderen VPC-Netzwerk enthalten, das über VPC-Netzwerk-Peering verbunden ist. Private NAT bietet nur Konnektivität für NCC-Spokes oder Konnektivität über Hybrid NAT.
  • VPC-Routenanforderungen: Für jeden CIDR-Block, der von Public NAT verarbeitet werden soll, muss das VPC-Netzwerk des Clusters eine statische Route enthalten, deren Zielbereich den CIDR-Block enthält und deren nächster Hop das Standard-Internetgateway ist.

Beschränkungen

  • Granularität auf Namespace-Ebene: Sie können GKE-Richtlinien für granulare NAT nur auf Kubernetes-Namespace-Ebene anwenden. In der Vorabversion können Sie keine einzelnen Pods oder Dienstkonten mithilfe von Label-Selektoren innerhalb eines Namespace auswählen.
  • Gateway-Regelkapazität: Jedes Cloud NAT-Gateway unterstützt bis zu 128 NAT-Regeln. So können Sie Richtlinien für bis zu 128 verschiedene GKE-Namespaces pro Gateway konfigurieren. Wenn Ihr Cluster Richtlinien für ausgehenden Traffic für mehr als 128 Namespaces benötigt, müssen Sie zusätzliche Gateways bereitstellen.
  • Cloud NAT-Einschränkungen: Lesen Sie die Standardeinschränkungen für Cloud NAT, da diese auch für den ausgehenden Traffic von Granular NAT gelten. Weitere Informationen finden Sie in den Einschränkungen für Public NAT und Private NAT.

Granulares GKE-NAT für einen Cluster aktivieren

Sie können die granulare NAT aktivieren, wenn Sie einen neuen Cluster erstellen, oder einen vorhandenen Cluster aktualisieren.

Neuen Cluster erstellen

Autopilot

Führen Sie den folgenden Befehl aus, um einen neuen Cluster mit aktiviertem Granular NAT und GKE Dataplane V2 zu erstellen:

gcloud container clusters create-auto "CLUSTER_NAME" \
    --LOCATION_FLAG="LOCATION" \
    --network="VPC_NETWORK_NAME" \
    --enable-granular-nat \
    --network-suite=STANDARD

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name des neuen Clusters.
  • LOCATION_FLAG: Geben Sie --region für einen regionalen Cluster an.
  • LOCATION: die Compute Engine-Region oder -Zone für den Cluster (z. B. us-central1 oder us-central1-a).
  • VPC_NETWORK_NAME: der Name des VPC-Netzwerks

Standard

Führen Sie den folgenden Befehl aus, um einen neuen Cluster mit aktiviertem Granular NAT und GKE Dataplane V2 zu erstellen:

gcloud container clusters create <var>CLUSTER_NAME</var> \
    --LOCATION_FLAG="LOCATION" \
    --network="VPC_NETWORK_NAME" \
    --enable-dataplane-v2 \
    --enable-granular-nat \
    --network-suite=STANDARD

Ersetzen Sie Folgendes:

  • CLUSTER_NAME: Der Name des neuen Clusters.
  • LOCATION_FLAG: Geben Sie --region für einen regionalen Cluster oder --zone für einen zonalen Cluster an.
  • LOCATION: die Compute Engine-Region oder -Zone für den Cluster (z. B. us-central1 oder us-central1-a).
  • VPC_NETWORK_NAME: der Name des VPC-Netzwerks

Vorhandenen Cluster aktualisieren

Autopilot

Führen Sie den folgenden Befehl aus, um die detaillierte NAT für einen vorhandenen Cluster zu aktivieren:

gcloud container clusters update `CLUSTER_NAME` \
    --LOCATION_FLAG="LOCATION" \
    --enable-granular-nat

Ersetzen Sie Folgendes:

  • CLUSTER_NAME ist der Name Ihres vorhandenen Clusters.
  • LOCATION_FLAG: Geben Sie --region an, wenn Ihr vorhandener Cluster regional ist, oder --zone, wenn er zonal ist.
  • LOCATION: die Compute Engine-Region oder -Zone, in der sich Ihr Cluster befindet.

Standard

Führen Sie den folgenden Befehl aus, um die detaillierte NAT für einen vorhandenen Standardcluster zu aktivieren:

gcloud container clusters update `CLUSTER_NAME` \
    --LOCATION_FLAG="LOCATION" \
    --enable-granular-nat \
    --network-suite=STANDARD

Ersetzen Sie Folgendes:

  • CLUSTER_NAME ist der Name Ihres vorhandenen Clusters.
  • LOCATION_FLAG: Geben Sie --region an, wenn Ihr vorhandener Cluster regional ist, oder --zone, wenn er zonal ist.
  • LOCATION: die Compute Engine-Region oder -Zone, in der sich Ihr Cluster befindet.

Öffentliche granulare NAT mit statischen externen ausgehenden IP-Adressen konfigurieren

Konfigurieren Sie die öffentliche detaillierte NAT, wenn Arbeitslasten in separaten Namespaces unterschiedliche, statische öffentliche IP-Adressen für externe Drittanbieterdienste wie Partner-APIs oder Zahlungs-Gateways bereitstellen müssen, die strenge IP-Adressen-Zulassungslisten erzwingen.

  1. Erstellen Sie einen regionalen Cloud Router für Ihr Cloud NAT-Gateway. GKE erstellt den Cloud Router nicht automatisch für Sie.

    gcloud compute routers create ROUTER_NAME \
        --network=VPC_NETWORK_NAME \
        --region=REGION
    

    Ersetzen Sie Folgendes:

    • ROUTER_NAME: Der Name Ihres neuen regionalen Cloud Router.
    • VPC_NETWORK_NAME: der Name des VPC-Netzwerks
    • REGION: die Compute Engine-Region, in der sich Ihr Cluster befindet (z. B. us-central1).
  2. Reservieren Sie statische externe IP-Adressen in derselben Region wie Ihr GKE-Cluster, um dedizierte externe IP-Adressen für ausgehenden Traffic für Ihre Namespaces sowie eine Standard-IP-Adresse für das Gateway zuzuweisen:

    gcloud compute addresses create nat-ip-default \
        --region=REGION
    gcloud compute addresses create nat-ip-1 \
        --region=REGION
    gcloud compute addresses create nat-ip-2 \
        --region=REGION
    

    Ersetzen Sie REGION durch die Compute Engine-Region, in der sich Ihr Cluster befindet (z. B. us-central1).

  3. Speichern Sie das folgende Manifest als cloud-nat-public.yaml, um ein verwaltetes regionales Cloud NAT-Gateway zu definieren:

    kind: CloudNATGateway
    apiVersion: networking.gke.io/v1
    metadata:
      name: cloud-nat-public-managed
    spec:
      type: Public
      cloudRouter:
        name: projects/PROJECT_ID/regions/REGION/routers/ROUTER_NAME
      publicNATOptions:
        defaultNatExternalIPs:
        - name: nat-ip-default
      connectionOptions:
        udpTimeoutSeconds: 30
        tcpEstablishedTimeoutSeconds: 1200
        tcpTransitoryTimeoutSeconds: 30
        tcpTimeWaitSeconds: 120
        icmpTimeoutSeconds: 30
      portOptions:
        minPortsPerVM: 32
        maxPortsPerVM: 65536
      logOptions:
        enable: true
        filter: ALL
    

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Projekt-ID in Google Cloud .
    • REGION: die Compute Engine-Region, in der sich Ihr Cluster und Ihr Cloud Router befinden.
    • ROUTER_NAME ist der Name Ihres Cloud Routers.
  4. Speichern Sie das folgende Manifest als traffic-selectors-public.yaml, um jeden Ziel-Namespace der dafür vorgesehenen Public NAT IP-Adresse zuzuordnen:

    kind: TrafficSelector
    apiVersion: networking.gke.io/v2
    metadata:
      name: ns-red-public-route
      annotations:
        cloud.google.com/cloud-nat: '{"nat-external-ips":"nat-ip-1"}'
    spec:
      action:
        kind: CloudNATGateway
        name: cloud-nat-public-managed
      subject:
        pods:
          namespaceSelector:
            matchLabels:
              app: namespace-red-app
      egress:
        to:
          ipBlock:
            cidrs:
            - 0.0.0.0/0
    ---
    kind: TrafficSelector
    apiVersion: networking.gke.io/v2
    metadata:
      name: ns-green-public-route
      annotations:
        cloud.google.com/cloud-nat: '{"nat-external-ips":"nat-ip-2"}'
    spec:
      action:
        kind: CloudNATGateway
        name: cloud-nat-public-managed
      subject:
        pods:
          namespaceSelector:
            matchLabels:
              app: namespace-green-app
      egress:
        to:
          ipBlock:
            cidrs:
            - 0.0.0.0/0
    

    In diesen Manifesten gilt Folgendes:

    • Die Annotation cloud.google.com/cloud-nat gibt an, welche reservierte statische externe IP-Adresse ausgehenden Traffic für den übereinstimmenden Namespace übersetzt.
    • Das Feld namespaceSelector.matchLabels entspricht den Labels, die auf Ihre Kubernetes-Ziel-Namespaces angewendet wurden.
    • Die Liste egress.to.ipBlock.cidrs mit 0.0.0.0/0 leitet den gesamten ausgehenden Internettraffic über das angegebene Cloud NAT-Gateway weiter.
  5. Wenden Sie beide Manifeste auf Ihren Cluster an:

    kubectl apply -f cloud-nat-public.yaml -f traffic-selectors-public.yaml
    

GKE stellt das Cloud NAT-Gateway automatisch bereit, konfiguriert die Übersetzungsregeln basierend auf den Arbeitslastselektoren Ihres Namespace und weist die reservierten externen IP-Adressen zu.

Private Granular Cloud NAT für VPC- oder NCC-Verbindungen konfigurieren

Verwenden Sie private Granular Cloud NAT, um bestimmte interne IP-Adressbereiche für Arbeitslasten zuzuweisen, die eine Verbindung zu lokalen Netzwerken oder zu anderen VPC-Spokes auf einem NCC-Hub herstellen.

  1. Erstellen Sie dedizierte Subnetze mit dem Zweck PRIVATE_NAT in Ihrem VPC-Netzwerk:

    gcloud compute networks subnets create private-nat-subnet-1 \
        --region=REGION \
        --network=VPC_NETWORK_NAME \
        --range=10.0.0.0/29 \
        --purpose=PRIVATE_NAT
    
    gcloud compute networks subnets create private-nat-subnet-2 \
        --region=REGION \
        --network=VPC_NETWORK_NAME \
        --range=10.0.1.0/29 \
        --purpose=PRIVATE_NAT
    

    Ersetzen Sie Folgendes:

    • REGION: die Compute Engine-Region, in der sich Ihr Cluster befindet.
    • VPC_NETWORK_NAME: der Name des VPC-Netzwerks
  2. Speichern Sie das folgende Manifest als cloud-nat-private.yaml, um eine private CloudNATGateway-Ressource zu erstellen:

    kind: CloudNATGateway
    apiVersion: networking.gke.io/v1
    metadata:
      name: cloud-nat-private-managed
    spec:
      type: Private
      privateNATOptions:
        # Optional: Specify hubLink only if you are routing traffic through Network Connectivity Center
        hubLink: //networkconnectivity.googleapis.com/projects/PROJECT_ID/locations/global/hubs/HUB_NAME
      cloudRouter:
        name: projects/PROJECT_ID/regions/REGION/routers/ROUTER_NAME
      connectionOptions:
        udpTimeoutSeconds: 30
        tcpEstablishedTimeoutSeconds: 1200
    

    Ersetzen Sie Folgendes:

    • PROJECT_ID: Projekt-ID in Google Cloud .
    • HUB_NAME: Optional. Der Name Ihres Network Connectivity Center-Hubs. Geben Sie dies nur an, wenn Sie Traffic über das Network Connectivity Center weiterleiten. Wenn Sie das Network Connectivity Center nicht verwenden, lassen Sie den Block privateNATOptions vollständig weg.
    • ROUTER_NAME ist der Name Ihres Cloud Routers.
  3. Speichern Sie das folgende Manifest als traffic-selectors-private.yaml, um private TrafficSelector-Ressourcen zu erstellen, die Ihre Namespaces dem privaten NAT-Gateway zuordnen:

    kind: TrafficSelector
    apiVersion: networking.gke.io/v2
    metadata:
      name: ns-red-private-route
      annotations:
        cloud.google.com/cloud-nat: '{"nat-subnet":"private-nat-subnet-1"}'
    spec:
      action:
        kind: CloudNATGateway
        name: cloud-nat-private-managed
      subject:
        pods:
          namespaceSelector:
            matchLabels:
              app: namespace-red-app
      egress:
        to:
          ipBlock:
            cidrs:
            - 10.200.0.0/24
    ---
    kind: TrafficSelector
    apiVersion: networking.gke.io/v2
    metadata:
      name: ns-green-private-route
      annotations:
        cloud.google.com/cloud-nat: '{"nat-subnet":"private-nat-subnet-2"}'
    spec:
      action:
        kind: CloudNATGateway
        name: cloud-nat-private-managed
      subject:
        pods:
          namespaceSelector:
            matchLabels:
              app: namespace-green-app
      egress:
        to:
          ipBlock:
            cidrs:
            - 10.200.1.0/24
    
  4. Wenden Sie die Private NAT-Konfiguration an:

    kubectl apply -f cloud-nat-private.yaml -f traffic-selectors-private.yaml
    

Vorhandenes Cloud NAT-Gateway verwenden

Wenn Sie mehrere GKE-Cluster im selben VPC-Netzwerk verwalten oder Cluster haben, die sekundäre Pod-IP-Adressbereiche gemeinsam nutzen, können Sie Granular NAT so konfigurieren, dass ein vorhandenes Cloud NAT-Gateway in derselben Region und im selben VPC-Netzwerk verwendet wird. Mit dieser Konfiguration können Arbeitslasten in separaten Clustern einen einheitlichen Pool externer Quell-IP-Adressen bereitstellen, wenn sie eine Verbindung zu externen Endpunkten herstellen.

  1. Listen Sie die vorhandenen Cloud NAT-Gateways in Ihrer Region auf, um den Namen, den zugehörigen Cloud Router und das VPC-Netzwerk eines vorhandenen Gateways zu ermitteln. Die Region und das VPC-Netzwerk müssen mit denen der GKE-Cluster übereinstimmen:

    gcloud beta compute routers nats list \
        --router=ROUTER_NAME \
        --region=REGION \
        --format=yaml
    

    Ersetzen Sie Folgendes:

    • ROUTER_NAME: Der Name des Cloud Router, der das vorhandene Gateway verwaltet.
    • REGION: die Compute Engine-Region, in der sich Ihr Cluster und das vorhandene Gateway befinden (z. B. us-central1).
  2. Speichern Sie das folgende Manifest als cloud-nat-shared.yaml, um Ihren Cluster mit dem vorhandenen Gateway zu verknüpfen:

    kind: CloudNATGateway
    apiVersion: networking.gke.io/v1
    metadata:
      name: cloud-nat-public-shared
    spec:
      type: Public # type is a required field even for shared gateways. Can be either Public or Private.
      gatewayName: SHARED_NAT_GATEWAY_NAME
      cloudRouter:
        name: projects/PROJECT_ID/regions/REGION/routers/ROUTER_NAME
    

    Ersetzen Sie Folgendes:

    • SHARED_NAT_GATEWAY_NAME: der Name des vorhandenen Cloud NAT-Gateways.
    • PROJECT_ID: Projekt-ID in Google Cloud .
    • REGION: die Compute Engine-Region, in der sich Ihr Cluster und das vorhandene Gateway befinden.
    • ROUTER_NAME: der Name des regionalen Cloud Router, der das vorhandene Gateway verwaltet.
  3. Speichern Sie das folgende Manifest als traffic-selector-shared.yaml, um ausgehenden Traffic von Ihrem Namespace über das freigegebene Gateway weiterzuleiten:

    kind: TrafficSelector
    apiVersion: networking.gke.io/v2
    metadata:
      name: ns-shared-public-route
      annotations:
        cloud.google.com/cloud-nat: '{"nat-external-ips":"NAT_IP_NAME"}'
    spec:
      action:
        kind: CloudNATGateway
        name: cloud-nat-public-shared
      subject:
        pods:
          namespaceSelector:
            matchLabels:
              app: NAMESPACE_APP_LABEL
      egress:
        to:
          ipBlock:
            cidrs:
            - 0.0.0.0/0
    

    Ersetzen Sie Folgendes:

    • NAT_IP_NAME: der Name der reservierten externen statischen IP-Adresse, die auf dem freigegebenen Gateway konfiguriert ist.
    • NAMESPACE_APP_LABEL: das Label, das auf Ihren Kubernetes-Ziel-Namespace angewendet wird.
  4. Wenden Sie die Manifeste auf jeden GKE-Cluster an, der das Gateway freigeben muss:

    kubectl apply -f cloud-nat-shared.yaml -f traffic-selector-shared.yaml
    

    Wiederholen Sie diesen Schritt für jeden Cluster, in dem Arbeitslasten im ausgewählten Namespace über das freigegebene Gateway ausgehen müssen.

Granulares NAT bereinigen und deaktivieren

Um laufende Abrechnungsgebühren zu vermeiden und verwaiste Google Cloud -Ressourcen zu verhindern, sollten Sie beim Entfernen von Granular NAT aus Ihrem Cluster eine strikte Reihenfolge einhalten.

So bereinigen Sie Ressourcen für die granulare NAT:

  1. Vom Nutzer erstellte TrafficSelector-Ressourcen löschen:

    Löschen Sie die benutzerdefinierten TrafficSelector-Ressourcen, die Sie für Ihre Namespaces erstellt haben. Verwenden Sie das Flag --all nicht, da das Löschen von systemerstellten Selektoren (z. B. gnat-intra-cluster oder gnat-default-internet) den Clustertraffic beeinträchtigen kann.

    kubectl delete trafficselector SELECTOR_NAME
    

    Ersetzen Sie SELECTOR_NAME durch den Namen der TrafficSelector-Ressource.

    Die Granular NAT-Controller koordinieren mit dem Google Cloud -Netzwerk, um die spezifischen NAT-Regeln und Arbeitslastzuordnungen zu löschen, die mit Ihren Namespaces verknüpft sind.

    Prüfen Sie, ob alle TrafficSelector-Ressourcen beendet wurden, bevor Sie fortfahren.

  2. CloudNATGateway-Ressourcen löschen:

    Löschen Sie alle benutzerdefinierten CloudNATGateway-Ressourcen im Cluster:

    kubectl delete cloudnatgateway --all
    
    • Verwaltete Gateways: GKE löscht das zugrunde liegende Cloud NAT-Gateway in Google Cloud automatisch, nachdem alle Übersetzungsregeln entfernt wurden.
    • Gemeinsam genutzte Gateways: GKE bereinigt die relevanten NAT-Regeln, die mit Ihren Namespaces verknüpft sind. GKE entfernt die sekundären Pod-IP-Adresszuordnungen Ihres Clusters nicht und das freigegebene Cloud NAT-Gateway bleibt für andere Cluster aktiv.
  3. Deaktivieren Sie die Funktion im Cluster:

    Nachdem alle benutzerdefinierten Granular NAT-Ressourcen vollständig entfernt wurden, deaktivieren Sie das Feature in Ihrem Cluster:

    gcloud container clusters update CLUSTER_NAME \
        --location=LOCATION \
        --no-enable-granular-nat
    

    Ersetzen Sie Folgendes:

    • CLUSTER_NAME: Der Name Ihres Clusters.
    • LOCATION: die Compute Engine-Region oder -Zone, in der sich Ihr Cluster befindet (z. B. us-central1 oder us-central1-a).

Fehlerbehebung

Wenn Verbindungsprobleme auftreten, können Sie die folgenden Methoden verwenden, um Fehler bei der Konfiguration von Granular NAT und der Datenebene zu diagnostizieren.

Ressourcenstatus und Logs prüfen

  • Status benutzerdefinierter Ressourcen prüfen: Prüfen Sie, ob Fehlerbedingungen für Ihre benutzerdefinierten CloudNATGateway- oder TrafficSelector-Ressourcen vorliegen:

    kubectl describe cloudnatgateway GATEWAY_NAME
    kubectl describe trafficselector SELECTOR_NAME
    

    Ersetzen Sie Folgendes:

    • GATEWAY_NAME: der Name Ihrer CloudNATGateway-Ressource.
    • SELECTOR_NAME: der Name Ihrer TrafficSelector-Ressource.
  • Cloud NAT-Regeln prüfen: Prüfen Sie, ob die GKE-Arbeitslastauswahlregeln auf dem zugrunde liegenden Cloud NAT-Gateway aktiv sind:

    gcloud beta compute routers nats rules list \
        --router=ROUTER_NAME \
        --nat=NAT_NAME \
        --region=REGION \
        --format=yaml
    

    Ersetzen Sie Folgendes:

    • ROUTER_NAME: Der Name Ihres regionalen Cloud Router.
    • NAT_NAME: der Name Ihres Cloud NAT-Gateways
    • REGION: die Compute Engine-Region, in der sich Ihre Ressourcen befinden.
  • Cloud NAT-Logs analysieren: Wenn ausgehender Traffic verworfen wird oder nicht übersetzt werden kann, rufen Sie die Cloud NAT-Logeinträge in Cloud Logging auf. Filtern Sie nach dem Feld gke_workload_identity, um Verbindungsereignisse direkt mit bestimmten GKE-Namespaces zu korrelieren.

Weitere Informationen zur Diagnose allgemeiner Cloud NAT-Fehler finden Sie unter Fehlerbehebung bei Cloud NAT.

Nächste Schritte