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 servicio de Kubernetes de type: LoadBalancer. GKE aprovisiona un Google Cloud balanceador de cargas de capa 4 para el servicio que envía tráfico a los Pods en una red secundaria especificada.

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

Cómo funcionan los servicios 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 se oriente a los Pods según la red de su interfaz secundaria. También debes agregar una anotación para especificar si deseas 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 networking.gke.io/load-balancer-type: "Internal" anotación a tu Service manifest. En el siguiente ejemplo, se muestra un servicio que crea un balanceador de cargas interno para orientar los 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 basado en servicios de backend, agrega la anotación cloud.google.com/l4-rbs: enabled a tu manifiesto de Service. En el siguiente ejemplo, se muestra un servicio que crea un balanceador de cargas externo para orientar los 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 Pod y red

Tus Pods deben tener una interfaz en la red a la que se orienta 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:

  • Establece una interfaz predeterminada: Usa la networking.gke.io/default-interface anotación 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 NET_ADMIN capacidad 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 extremos para servicios de varias redes. Este controlador crea objetos EndpointSlice para tus servicios de varias redes. Las direcciones IP de estos objetos EndpointSlice pertenecen a la red secundaria especificada en el selector de servicios.

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

Limitaciones

Los servicios LoadBalancer de varias redes tienen las siguientes limitaciones:

  • Los balanceadores de cargas internos requieren la creación de subconjuntos 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 orientarse a los Pods hostNetwork.
  • No se admiten las redes IPv6 ni de pila doble.
  • No puedes cambiar la red de un servicio existente.
  • Solo se admiten las redes de capa 3.

¿Qué sigue?