Prepara las herramientas de redes ambientales de GKE

En esta página, se muestra cómo habilitar Ambient Networking en un clúster nuevo o existente, inscribir espacios de nombres y cargas de trabajo para habilitar el redireccionamiento del tráfico de Ambient y configurar mTLS y políticas de autorización.

Para obtener más información sobre la arquitectura, los beneficios y las capacidades de Ambient Networking, consulta la descripción general de Ambient Networking.

Requisitos previos y limitaciones

Antes de configurar Ambient Networking, revisa las siguientes limitaciones de funciones, requisitos de versión y restricciones de alcance:

  • Versión de GKE: Requiere la versión 1.36.4-gke.1391000 o posterior de GKE.
  • Versión de Google Cloud CLI: Requiere la versión 592.0.0 o una posterior de Google Cloud CLI.
  • Asistencia regional: Los clústeres se deben crear en una región compatible con Cloud Service Mesh regional.
  • Interoperabilidad de las cargas de trabajo: Las cargas de trabajo inscritas en Ambient Networking no pueden interoperar con cargas de trabajo con inyección de sidecar ni con gRPC sin proxy.
  • Funciones no admitidas:
    • Campo trafficDistribution del Service de Kubernetes.
    • Servicios sin interfaz gráfica.
    • GKE Sandbox (gVisor)
  • Aviso de seguridad: Si el componente gke-ambient-nriplugin no está disponible en un nodo, es posible que se omita la aplicación de la autenticación y la autorización del tráfico entrante.

Antes de comenzar

Completa los siguientes pasos de configuración de requisitos previos en Cloud de Confiance by S3NS:

  1. Crea o selecciona un proyecto.
  2. Habilita las APIs necesarias:

    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. Configura la autenticación de identidad de carga de trabajo administrada para GKE.

Habilita Ambient Networking en un clúster nuevo

Ejecuta el siguiente comando para crear un clúster de GKE nuevo con Ambient Networking habilitado:

  1. Crea un clúster de GKE con Ambient Networking habilitado

    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
    

    Ahora se ejecutan dos DaemonSets en el espacio de nombres gke-managed-ambient.

Habilita Ambient Networking en un clúster existente

Sigue estos pasos para habilitar la malla de ambient en un clúster de GKE existente:

  1. Verifica que tu clúster cumpla con los siguientes requisitos:

    • Versión 1.36.4-gke.1391000 o posterior
    • GKE Dataplane V2 habilitado.
    • El tipo de máquina debe ser e2-standard-4 o superior.
    • El clúster se debe agregar a una flota.
    • El clúster debe tener habilitadas la API de Gateway y Workload Identity.
  2. Habilita Ambient Networking en un clúster existente:

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

    Ahora se ejecutan dos DaemonSets en el espacio de nombres gke-managed-ambient.

  3. Para verificar, apunta la CLI al clúster:

    gcloud container clusters get-credentials CLUSTER_NAME \
        --location=CLUSTER_LOCATION
    
  4. Obtén los DaemonSets en el espacio de nombres gke-managed-ambient:

    kubectl get daemonset -n gke-managed-ambient
    

    El resultado es similar al siguiente:

    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
    

Inscribe un espacio de nombres para Ambient Networking

Sigue estos pasos para implementar una aplicación de ejemplo y habilitar el redireccionamiento de tráfico de Ambient en su espacio de nombres:

  1. Implementa una aplicación de ejemplo:

    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. Etiqueta el espacio de nombres ambient-test para habilitar el redireccionamiento del tráfico a través del proxy de GKE ambient:

    kubectl label namespace ambient-test networking.gke.io/dataplane-mode=ambient
    
  3. Verifica que los Pods individuales en el espacio de nombres se hayan configurado para el redireccionamiento del tráfico:

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

    El resultado es similar al siguiente:

    ambient.networking.gke.io/redirection: enabled
    ambient.networking.gke.io/redirection: enabled
    
  4. Prueba el tráfico del cliente al servidor:

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  5. Para verificar que el tráfico de texto simple fluya a través de gke-ambient-proxy, revisa los registros de acceso en el Explorador de registros y busca el nombre del registro gke-ambient-node-proxy-accesslog:

    Ve al Explorador de registros

Habilita la mTLS para un servicio

Después de habilitar el redireccionamiento del tráfico para las cargas de trabajo en un espacio de nombres, aplica políticas para aplicar de manera forzosa la encriptación, la autenticación y la autorización.

  1. Configura una política de mTLS permisiva en las cargas de trabajo del servidor:

    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
    

    Esta política hace que los Pods acepten el tráfico de mTLS y de texto simple. Ten en cuenta que la mTLS permisiva usa la detección de tráfico para determinar si el tráfico es mTLS o texto sin formato. Esto interrumpirá el tráfico de la aplicación que usa su propio TLS o un protocolo de "el servidor habla primero", como MySQL.

  2. Verifica que el controlador haya aceptado la política:

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

    El resultado es similar al siguiente:

    [...]
    
        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 propagación de la política puede tardar hasta tres minutos después de la aceptación del controlador. Espera tres minutos antes de continuar.

  3. Configura una política de mTLS del cliente que se oriente al servicio:

    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
    

    Esta política configura los clientes inscritos para que originen tráfico de mTLS al Service del servidor. Es posible que debas esperar al menos dos minutos antes de continuar con el siguiente paso.

  4. Verifica que el controlador haya aceptado la política:

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

    El resultado es similar al siguiente:

    [...]
    Status:
    Conditions:
        Last Transition Time:  2024-10-13T01:15:03Z
        Message:
        Observed Generation:   1
        Reason:                Accepted
        Status:                True
        Type:                  Accepted
    
  5. Prueba el tráfico del cliente al servidor:

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

    El tráfico de los Pods inscritos en Ambient Networking al servicio del servidor en el espacio de nombres ambient-test ahora debería usar mTLS.

  6. Para verificar que las conexiones usen mTLS, revisa los registros de acceso en el Explorador de registros y busca el nombre de registro gke-ambient-node-proxy-accesslog:

    Ve al Explorador de registros

  7. Actualiza la GCPServerTLSPolicy existente para cambiar el mode de Permisivo a Estricto en el servicio del servidor para que los Pods de carga de trabajo ya no acepten tráfico de texto sin formato:

    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. Verifica que se haya aceptado la política:

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

    El resultado es similar al siguiente:

    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
    

    Ahora se rechazará todo el tráfico de texto sin formato que se dirija al Service del servidor.

  9. Para verificar que ahora se rechaza el tráfico de texto simple, envía tráfico al servicio del servidor desde un cliente que NO esté inscrito en Ambient Networking:

    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
    

    Esta conexión debería fallar con un mensaje similar al siguiente:

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

Establece la política de autorización de capa 4

Para aplicar la autorización basada en la identidad, los propietarios de las cargas de trabajo especifican etiquetas de Pods en el selector de políticas. Los propietarios de espacios de nombres aplican políticas en todo el espacio de nombres sin selectores.

  1. Aplica la siguiente política para aplicar de manera forzosa que solo el cliente pueda comunicarse con el servidor:

    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
    

    Esta política se aplica al tráfico que se dirige a los Pods del servidor en el espacio de nombres ambient-test. Esto garantiza que solo se permita el tráfico de fuentes con la identidad de SPIFFE spiffe://PROJECT_ID.s3ns.svc.id.goog/ns/ambient-test/sa/client.

  2. Verifica que la aplicación de la política esté permitida enviando una solicitud de muestra desde la cuenta de servicio del cliente.

    kubectl exec -it deploy/client -n ambient-test -- \
        /bin/curl -fsLS server.ambient-test.svc.cluster.local
    
  3. Verifica que la aplicación de la política no esté permitida enviando una solicitud de muestra desde la cuenta de servicio del servidor.

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

    El resultado es similar al siguiente:

    curl: (52) Empty reply from server
    command terminated with exit code 52
    
  4. Puedes usar el Explorador de registros para ver el registro de aplicación de la autorización. En la consola de Cloud de Confiance , ve a la página Explorador de registros y busca las solicitudes rechazadas con el nombre de registro 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"
    

    Ve al Explorador de registros

Habilita las métricas de la capa 4

De manera opcional, puedes habilitar la generación de métricas de capa 4 para las cargas de trabajo en un espacio de nombres inscrito.

Antes de habilitar la generación de métricas de capa 4, verifica que hayas habilitado telemetry.googleapis.com y monitoring.googleapis.com, y que hayas aplicado networking.gke.io/dataplane-mode=ambient al espacio de nombres.

  1. Habilita la generación de métricas de capa 4 para las cargas de trabajo en el espacio de nombres:

    kubectl label namespace ambient-test networking.gke.io/ambient-network-metrics=enabled
    
  2. Verifica que la generación de métricas de capa 4 esté habilitada:

    kubectl get namespace ambient-test --show-labels
    

    El resultado es similar a lo siguiente:

    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
    

    Después de aplicar la etiqueta networking.gke.io/ambient-network-metrics=enabled y de que el tráfico fluya entre las cargas de trabajo inscritas, las métricas de la capa 4 estarán disponibles en Cloud Monitoring. Puedes usar la supervisión de servicios de red para verlos y analizarlos.

  3. En la consola de Cloud de Confiance by S3NS , ve a la página Supervisión de servicios de red.

    Ir a Supervisión de servicios de red

    Para obtener más información, consulta Visualiza métricas y la referencia de métricas de Monitoring de Network Services.