Préparer la mise en réseau ambiante GKE

Cette page vous explique comment activer la mise en réseau ambiante sur un cluster nouveau ou existant, enregistrer des espaces de noms et des charges de travail pour activer la redirection du trafic ambiant, et configurer mTLS et des règles d'autorisation.

Pour en savoir plus sur l'architecture, les avantages et les fonctionnalités de la mise en réseau ambiant, consultez la présentation de la mise en réseau ambiant.

Prérequis et limitations

Avant de configurer la mise en réseau ambiante, consultez les limites des fonctionnalités, les exigences de version et les restrictions de champ d'application suivantes :

  • Version de GKE : nécessite GKE version 1.36.4-gke.1391000 ou ultérieure.
  • Version de la Google Cloud CLI : nécessite la version 592.0.0 ou ultérieure de la Google Cloud CLI.
  • Compatibilité régionale : les clusters doivent être créés dans une région compatible avec Cloud Service Mesh régional.
  • Interopérabilité des charges de travail : les charges de travail enregistrées dans une mise en réseau ambiant ne peuvent pas interagir avec les charges de travail injectées par side-car ou gRPC sans proxy.
  • Fonctionnalités non compatibles :
    • Champ trafficDistribution du service Kubernetes.
    • Services sans interface graphique.
    • GKE Sandbox (gVisor).
  • Avis de sécurité : Si le composant gke-ambient-nriplugin devient indisponible sur un nœud, l'authentification du trafic entrant et l'application de l'autorisation peuvent être contournées.

Avant de commencer

Suivez les étapes de configuration préalables suivantes dans Cloud de Confiance by S3NS :

  1. Créer ou sélectionner un projet
  2. Activez les API requises :

    gcloud services enable \
        privateca.googleapis.com \
        gkehub.googleapis.com \
        compute.googleapis.com \
        container.googleapis.com \
        trafficdirector.googleapis.com \
        networkservices.googleapis.com \
        networksecurity.googleapis.com \
        telemetry.googleapis.com \
        monitoring.googleapis.com \
        logging.googleapis.com
    
  3. Configurer l'authentification des identités de charge de travail gérées pour GKE

Activer la mise en réseau ambiante sur un nouveau cluster

Exécutez la commande suivante pour créer un cluster GKE avec la mise en réseau ambiante activée :

  1. Créer un cluster GKE avec la mise en réseau ambiante activée

    gcloud container clusters create CLUSTER_NAME \
        --machine-type=e2-standard-4 \
        --enable-ambient-networking \
        --enable-dataplane-v2 \
        --enable-fleet \
        --gateway-api=standard \
        --location=CLUSTER_LOCATION \
        --release-channel=rapid \
        --workload-pool=PROJECT_ID.s3ns.svc.id.goog
    

    Deux DaemonSets s'exécutent désormais dans l'espace de noms gke-managed-ambient.

Activer la mise en réseau ambiante sur un cluster existant

Pour activer ambient mesh sur un cluster GKE existant, procédez comme suit :

  1. Vérifiez que votre cluster répond aux exigences suivantes :

    • Version 1.36.4-gke.1391000 ou ultérieure.
    • GKE Dataplane V2 activé.
    • Le type de machine doit être e2-standard-4 ou supérieur.
    • Le cluster doit être ajouté à un parc.
    • L'API Gateway et Workload Identity doivent être activés sur le cluster.
  2. Activez la mise en réseau ambiante sur un cluster existant :

    gcloud container clusters update CLUSTER_NAME \
        --enable-ambient-networking \
        --location=CLUSTER_LOCATION \
        --enable-fleet
    

    Deux DaemonSets s'exécutent désormais dans l'espace de noms gke-managed-ambient.

  3. Pour vérifier, pointez votre CLI vers le cluster :

    gcloud container clusters get-credentials CLUSTER_NAME \
        --location=CLUSTER_LOCATION
    
  4. Récupérez les DaemonSets dans l'espace de noms gke-managed-ambient :

    kubectl get daemonset -n gke-managed-ambient
    

    Le résultat est semblable à :

    NAME                    DESIRED   CURRENT   READY   UP-TO-DATE   AVAILABLE   AGE
    gke-ambient-nriplugin   9         9         9       9            9           4d1h
    gke-ambient-proxy       9         9         9       9            9           4d1h
    

Enregistrer un espace de noms pour la mise en réseau ambiante

Pour déployer un exemple d'application et activer la redirection du trafic ambiant sur son espace de noms, procédez comme suit :

  1. Déployez un exemple d'application :

    kubectl apply -f - <<EOF
    apiVersion: v1
    kind: Namespace
    metadata:
      name: ambient-test
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: client
      namespace: ambient-test
    ---
    apiVersion: v1
    kind: ServiceAccount
    metadata:
      name: server
      namespace: ambient-test
    ---
    apiVersion: v1
    kind: Service
    metadata:
      name: server
      namespace: ambient-test
      labels:
        app: server
    spec:
      ports:
      - port: 80
        protocol: TCP
      selector:
        app: server
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: client
      namespace: ambient-test
      labels:
        app: client
    spec:
      replicas: 1
      selector:
        matchLabels:
          app: client
      template:
        metadata:
          labels:
            app: client
        spec:
          serviceAccountName: client
          containers:
          - name: nginx
            image: nginx:1.29.6
    ---
    apiVersion: apps/v1
    kind: Deployment
    metadata:
      name: server
      namespace: ambient-test
      labels:
        app: server
    spec:
      replicas: 2
      selector:
        matchLabels:
          app: server
      template:
        metadata:
          labels:
            app: server
        spec:
          serviceAccountName: server
          containers:
          - name: nginx
            image: nginx:1.29.6
            readinessProbe:
              httpGet:
                path: /
                port: 80
    EOF
    
  2. Ajoutez un libellé à l'espace de noms ambient-test pour activer la redirection du trafic via le proxy ambiant GKE :

    kubectl label namespace ambient-test networking.gke.io/dataplane-mode=ambient
    
  3. Vérifiez que les pods individuels de l'espace de noms ont été configurés pour la redirection du trafic :

    kubectl get pods -n ambient-test -o yaml | grep redirection
    

    Le résultat est semblable à :

    ambient.networking.gke.io/redirection: enabled
    ambient.networking.gke.io/redirection: enabled
    
  4. Testez le trafic client-serveur :

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  5. Pour vérifier que le trafic en texte brut transite par gke-ambient-proxy, consultez les journaux d'accès dans l'explorateur de journaux et recherchez le nom de journal gke-ambient-node-proxy-accesslog :

    Accéder à l'explorateur de journaux

Activer mTLS pour un service

Après avoir activé la redirection du trafic pour les charges de travail d'un espace de noms, appliquez des règles pour imposer le chiffrement, l'authentification et l'autorisation.

  1. Configurez une règle mTLS permissive sur les charges de travail côté serveur :

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPServerTLSPolicy
    metadata:
      name: server
      namespace: ambient-test
    spec:
      mtlsMode: Permissive
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
    EOF
    

    Cette règle permet aux pods d'accepter à la fois le trafic mTLS et le trafic en texte brut. Notez que le mTLS permissif utilise le sniffing de trafic pour détecter si le trafic est mTLS ou en texte brut. Cela interrompt le trafic de l'application qui utilise son propre protocole TLS ou un protocole de type "le serveur parle en premier" tel que MySQL.

  2. Vérifiez que la règle a été acceptée par le contrôleur :

    kubectl describe gcpservertlspolicies -n ambient-test server | grep -A50 Status
    

    Le résultat est semblable à :

    [...]
    
        Conditions:
        Last Transition Time:  2026-03-25T17:47:30Z
        Message:
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Controller Name:         networking.gke.io/dpv2-1n
    Events:
    Type    Reason  Age                   From                   Message
    ----    ------  ----                  ----                   -------
    Normal  Sync    108s (x2 over 2m20s)  sc-dpv2-1n-controller  Sync on Mesh dpv2-1n-fqtx-mesh succeeded
    

    La propagation des règles peut prendre jusqu'à trois minutes après l'acceptation du contrôleur. Patientez trois minutes avant de continuer.

  3. Configurez une règle mTLS côté client qui cible le service :

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPClientTLSPolicy
    metadata:
      name: server-mtls
      namespace: ambient-test
    spec:
      targetRefs:
      - group: ""
        kind: Service
        name: server
      subjectAltNames:
      - uri: spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/server
    EOF
    

    Cette règle configure les clients enregistrés pour qu'ils envoient du trafic mTLS au service du serveur. Vous devrez peut-être attendre au moins deux minutes avant de passer à l'étape suivante.

  4. Vérifiez que la règle a été acceptée par le contrôleur :

    kubectl describe gcpclienttlspolicies -n ambient-test server-mtls | grep -A50 Status
    

    Le résultat est semblable à :

    [...]
    Status:
    Conditions:
        Last Transition Time:  2024-10-13T01:15:03Z
        Message:
        Observed Generation:   1
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
    
  5. Testez le trafic client-serveur :

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    

    Le trafic provenant des pods enregistrés dans la mise en réseau ambiant vers le service de serveur dans l'espace de noms ambient-test devrait désormais utiliser mTLS.

  6. Pour vérifier que les connexions utilisent mTLS, consultez les journaux d'accès dans l'explorateur de journaux et recherchez le nom de journal gke-ambient-node-proxy-accesslog :

    Accéder à l'explorateur de journaux

  7. Mettez à jour la ressource GCPServerTLSPolicy existante pour remplacer la valeur mode de Permissive par Strict sur le service du serveur afin que les pods de charge de travail n'acceptent plus le trafic en texte brut :

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPServerTLSPolicy
    metadata:
      name: server
      namespace: ambient-test
    spec:
      mtlsMode: Strict
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
    EOF
    
  8. Vérifiez que la règle a été acceptée :

    kubectl describe gcpservertlspolicies -n ambient-test server | grep -A50 Status
    

    Le résultat est semblable à :

    Name:         server
    
    <...>
    
    UID:                 e4f2a7a3-69aa-4528-8ea6-6f1bf2142011
    Spec:
    Mtls Mode:  Strict
    Target Refs:
    Group:
    Kind:   Pod
    Selector:
      Match Labels:
        App:  server
    Status:
    Ancestors:
        Ancestor Ref:
        Group:
        Kind:   Pod
        Name:   app=server
        Conditions:
        Last Transition Time:  2026-03-25T22:33:54Z
        Message:
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
        Controller Name:         networking.gke.io/dpv2-1n
    Events:
    Type    Reason  Age                  From                   Message
    ----    ------  ----                 ----                   -------
    Normal  Sync    43s (x5 over 4m57s)  sc-dpv2-1n-controller  Sync on Mesh dpv2-1n-2cdi-mesh succeeded
    

    Tout trafic en texte brut vers votre service de serveur sera désormais rejeté.

  9. Pour vérifier que le trafic en texte brut est désormais rejeté, envoyez du trafic au service du serveur depuis un client qui n'est PAS inscrit dans la mise en réseau ambiant :

    kubectl create namespace noambient-test && \
    kubectl run -it -n noambient-test --rm curl --image=nginx -- \
        /bin/curl -fsLSv http://server.ambient-test.svc.cluster.local
    

    La connexion doit échouer et renvoyer un message semblable à celui-ci :

    * Request completely sent off
    * Empty reply from server
    * shutting down connection #0
    curl: (52) Empty reply from server
    

Définir une règle d'autorisation de couche 4

Pour appliquer l'autorisation basée sur l'identité, les propriétaires de charges de travail spécifient des étiquettes de pod dans le sélecteur de règles. Les propriétaires d'espaces de noms appliquent des règles à l'échelle de l'espace de noms sans sélecteurs.

  1. Appliquez la règle suivante pour vous assurer que seul le client est autorisé à communiquer avec le serveur :

    kubectl apply -f - <<EOF
    apiVersion: networking.gke.io/v1
    kind: GCPAuthzPolicy
    metadata:
      name: allow-client
      namespace: ambient-test
    spec:
      action: ALLOW
      enforcementLevel: L4
      targetRefs:
      - group: ""
        kind: Pod
        selector:
          matchLabels:
            app: server
      rules:
      - from:
          sources:
          - principals:
            - principalSelector: CLIENT_CERT_URI_SAN
              principal:
                type: Exact
                value: spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client
    EOF
    

    Cette règle est appliquée au trafic vers les pods du serveur dans l'espace de noms ambient-test. Elle garantit que le trafic n'est autorisé qu'à partir de sources disposant de l'identité SPIFFE spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client.

  2. Vérifiez que l'application des règles est autorisée en envoyant un exemple de requête à partir du compte de service client.

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  3. Vérifiez que l'application des règles n'est pas autorisée en envoyant un exemple de requête à partir du compte de service server.

    kubectl exec -it deploy/server -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    

    Le résultat est semblable à :

    curl: (52) Empty reply from server
    command terminated with exit code 52
    
  4. Vous pouvez utiliser l'explorateur de journaux pour afficher la journalisation de l'application des autorisations. Dans la console Cloud de Confiance , accédez à la page Explorateur de journaux et recherchez les requêtes refusées à l'aide du nom de journal gke-ambient-node-proxy-accesslog :

    resource.type="k8s_container"
    logName="projects/PROJECT_ID/logs/gke-ambient-node-proxy-accesslog"
    jsonPayload.error_details=~"rbac_access_denied"
    

    Accéder à l'explorateur de journaux

Activer les métriques de couche 4

Vous pouvez éventuellement activer la génération de métriques de couche 4 pour les charges de travail d'un espace de noms enregistré.

Avant d'activer la génération de métriques de couche 4, vérifiez que vous avez activé telemetry.googleapis.com et monitoring.googleapis.com, et que vous avez appliqué networking.gke.io/dataplane-mode=ambient à l'espace de noms.

  1. Activez la génération de métriques de couche 4 pour les charges de travail de l'espace de noms :

    kubectl label namespace ambient-test networking.gke.io/ambient-network-metrics=enabled
    
  2. Vérifiez que la génération de métriques de couche 4 est activée :

    kubectl get namespace ambient-test --show-labels
    

    Le résultat ressemble à ce qui suit :

    NAME           STATUS   AGE   LABELS
    ambient-test   Active   15m   kubernetes.io/metadata.name=ambient-test,networking.gke.io/ambient-network-metrics=enabled,networking.gke.io/dataplane-mode=ambient
    

    Une fois que vous avez appliqué l'étiquette networking.gke.io/ambient-network-metrics=enabled et que le trafic circule entre les charges de travail enregistrées, les métriques de couche 4 sont disponibles dans Cloud Monitoring. Vous pouvez utiliser la surveillance des services réseau pour les afficher et les analyser.

  3. Dans la console Cloud de Confiance by S3NS , accédez à la page Surveillance des services réseau.

    Accéder à la page "Surveillance des services réseau"

    Pour en savoir plus, consultez Afficher les métriques et la documentation de référence sur les métriques de surveillance des services réseau.