Servicios LoadBalancer de varias redes

La función de redes múltiples de GKE te permite conectar tus cargas de trabajo a varias redes de VPC. Puedes exponer estos Pods de varias redes a clientes internos o externos con un servicio de Kubernetes de type: LoadBalancer. GKE aprovisiona un balanceador de cargas de Google Cloud L4 para el Service que envía tráfico a los Pods en una red secundaria especificada.

En este documento, se explica cómo GKE implementa los servicios de LoadBalancer para los Pods de varias redes. Abarca la configuración, las capacidades y las limitaciones requeridas de la función.

Cómo funcionan los Services LoadBalancer de varias redes

Para exponer una carga de trabajo de varias redes, crea un Service de type: LoadBalancer. Este servicio debe incluir un selector especial que segmenta los Pods según la red de su interfaz secundaria. También agregas una anotación para especificar si se debe crear un balanceador de cargas interno o externo.

La etiqueta networking.gke.io/network en el selector filtra los extremos por red. Esto garantiza que el balanceador de cargas solo envíe tráfico a las interfaces de Pod conectadas a la red especificada.

Service LoadBalancer interno

Para crear un balanceador de cargas interno, agrega la anotación networking.gke.io/load-balancer-type: "Internal" a tu manifiesto de Service. En el siguiente ejemplo, se muestra un objeto Service que crea un balanceador de cargas interno para segmentar Pods en la red dmz:

apiVersion: v1
kind: Service
metadata:
  name: web-app-internal-lb
  namespace: default
  annotations:
    networking.gke.io/load-balancer-type: "Internal"
spec:
  externalTrafficPolicy: Local
  ports:
  - port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    networking.gke.io/network: dmz
    app: web-app
  type: LoadBalancer

Servicio LoadBalancer externo

Para crear un balanceador de cargas de red externo, debes configurar un balanceador de cargas basado en servicios de backend. En GKE 1.37 y versiones posteriores, este es el comportamiento predeterminado. En versiones anteriores, agrega la anotación cloud.google.com/l4-rbs: enabled al manifiesto de tu servicio. En el siguiente ejemplo, se muestra un objeto Service que crea un balanceador de cargas externo para segmentar Pods en la red dmz:

apiVersion: v1
kind: Service
metadata:
  name: web-app-external-lb
  namespace: default
  annotations:
    cloud.google.com/l4-rbs: enabled
spec:
  externalTrafficPolicy: Local
  ports:
  -   port: 80
    protocol: TCP
    targetPort: 8080
  selector:
    networking.gke.io/network: dmz
    app: web-app
  type: LoadBalancer

Configuración de la red y el Pod

Tus Pods deben tener una interfaz en la red a la que se dirige el servicio LoadBalancer. También debes configurar el enrutamiento dentro del Pod para que pueda responder correctamente a las solicitudes en la interfaz de red adecuada.

Puedes configurar el enrutamiento de Pod de una de las siguientes maneras:

  • Configura una interfaz predeterminada: Usa la anotación networking.gke.io/default-interface en el Pod para establecer la interfaz de red secundaria como la ruta predeterminada.

  • Configura el enrutamiento basado en políticas: Usa un initContainer con la capacidad NET_ADMIN para configurar reglas de enrutamiento dentro del Pod.

En el siguiente ejemplo, se muestra un manifiesto de Deployment para Pods con una interfaz en la red dmz. La anotación networking.gke.io/default-interface establece la interfaz dmz (eth1) como la ruta predeterminada.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web-app
  labels:
    app: web-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: web-app
  template:
    metadata:
      labels:
        app: web-app
      annotations:
        networking.gke.io/default-interface: 'eth1'
        networking.gke.io/interfaces: |-
          [
            {"interfaceName":"eth0","network":"default"},
            {"interfaceName": "eth1","network": "dmz"}
          ]
    spec:
      containers:
      -   name: whereami
        image: us-docker.pkg.dev/google-samples/containers/gke/whereami:v1
        ports:
        -   containerPort: 8080

Verifica los extremos de varias redes

GKE usa un controlador dedicado, multinet-endpointslice-controller.gke.io, para administrar los extremos de los Services de varias redes. Este controlador crea objetos EndpointSlice para tus Services de varias redes. Las direcciones IP de estos objetos EndpointSlice pertenecen a la red secundaria especificada en el selector de servicio.

Si un balanceador de cargas no tiene backends en buen estado, inspecciona EndpointSlice para el Service y verifica que el controlador haya seleccionado las direcciones IP de Pod correctas. Si el objeto EndpointSlice no tiene extremos, verifica que las etiquetas del selector del Service coincidan con los Pods en ejecución y que el selector networking.gke.io/network coincida con la red de los Pods.

Limitaciones

Los servicios de LoadBalancer de varias redes tienen las siguientes limitaciones:

  • Los balanceadores de cargas internos requieren la subdivisión de GKE.
  • No se admiten los balanceadores de cargas basados en grupos de instancias o grupos de destino.
  • No se admiten los servicios que usan externalTrafficPolicy: Cluster.
  • Los servicios no pueden segmentar Pods de hostNetwork.
  • No se admiten IPv6 ni las redes de pila doble.
  • No puedes cambiar la red de un servicio existente.
  • Solo se admiten redes de capa 3.

¿Qué sigue?