Servicios LoadBalancer de varias redes

Las redes múltiples de GKE te permiten conectar tus cargas de trabajo a varias redes de VPC. Puedes exponer estos Pods de varias redes a clientes internos o externos con un Service de Kubernetes de type: LoadBalancer. GKE aprovisiona un balanceador de cargas de L4 de Google Cloud 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 Services de LoadBalancer para Pods de varias redes. Se abarca la configuración, las capacidades y las limitaciones 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 Service debe incluir un selector especial que se oriente a los Pods en función de la red de su interfaz secundaria. También debes agregar 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" al manifiesto del Service. En el siguiente ejemplo, se muestra un Service que crea un balanceador de cargas interno para orientar 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 Service. En el siguiente ejemplo, se muestra un Service que crea un balanceador de cargas externo para orientar 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 Pods y redes

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

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

  • Establece 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 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 extremos de 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 Service.

Si un balanceador de cargas no tiene backends en buen estado, inspecciona el EndpointSlice del objeto Service para verificar que el controlador haya seleccionado las direcciones IP de Pod correctas. Si el EndpointSlice no tiene extremos, verifica que las etiquetas del selector de 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 Services 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 destino o de instancias.
  • No se admiten los servicios que usan externalTrafficPolicy: Cluster.
  • Los servicios no pueden segmentar Pods de hostNetwork.
  • No se admiten las redes IPv6 ni de pila doble.
  • No puedes cambiar la red de un Service existente.
  • Solo se admiten redes de capa 3.

¿Qué sigue?