Serviços LoadBalancer de várias redes

A rede múltipla do GKE permite conectar suas cargas de trabalho a várias redes VPC. É possível expor esses pods de várias redes a clientes internos ou externos usando um serviço do Kubernetes de type: LoadBalancer. O GKE provisiona um Google Cloud balanceador de carga L4 para o serviço que envia tráfego para pods em uma rede secundária especificada.

Este documento explica como o GKE implementa serviços LoadBalancer para pods de várias redes. Ele aborda a configuração, os recursos e as limitações necessários do recurso.

Como os serviços LoadBalancer de várias redes funcionam

Para expor uma carga de trabalho de várias redes, crie um Service de type: LoadBalancer. Esse serviço precisa incluir um seletor especial que segmenta pods com base na rede da interface secundária. Você também adiciona uma anotação para especificar se quer criar um balanceador de carga interno ou externo.

O rótulo networking.gke.io/network no seletor filtra endpoints por rede. Isso garante que o balanceador de carga envie tráfego apenas para as interfaces de pod conectadas à rede especificada.

Serviço LoadBalancer interno

Para criar um balanceador de carga interno, adicione a networking.gke.io/load-balancer-type: "Internal" anotação ao manifesto do serviço. O exemplo a seguir mostra um serviço que cria um balanceador de carga interno para segmentar pods na rede 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

Serviço LoadBalancer externo

Para criar um balanceador de carga de rede externo baseado em serviço de back-end, adicione a anotação cloud.google.com/l4-rbs: enabled ao manifesto do serviço. O exemplo a seguir mostra um serviço que cria um balanceador de carga externo para segmentar pods na rede 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

Configuração de pod e rede

Os pods precisam ter uma interface na rede que o serviço LoadBalancer segmenta. Você também precisa configurar o roteamento no pod para que ele possa responder corretamente às solicitações na interface de rede apropriada.

É possível configurar o roteamento de pods de uma das seguintes maneiras:

  • Definir uma interface padrão: use a networking.gke.io/default-interface anotação no pod para definir a interface de rede secundária como a rota padrão.

  • Configurar o roteamento com base na política: use um initContainer com a NET_ADMIN competência para configurar regras de roteamento dentro do pod.

O exemplo a seguir mostra um manifesto de Deployment para pods com uma interface na rede dmz. A anotação networking.gke.io/default-interface define a interface dmz (eth1) como a rota padrão.

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

Como verificar endpoints de várias redes

O GKE usa um controlador dedicado, multinet-endpointslice-controller.gke.io, para gerenciar endpoints de serviços de várias redes. Esse controlador cria objetos EndpointSlice para seus serviços de várias redes. Os endereços IP nesses objetos EndpointSlice pertencem à rede secundária especificada no seletor de serviço.

Se um balanceador de carga não tiver back-ends íntegros, inspecione o EndpointSlice do serviço para verificar se o controlador selecionou os endereços IP corretos do pod. Se o EndpointSlice não tiver endpoints, verifique se os rótulos do seletor de serviço correspondem aos pods em execução e se o seletor networking.gke.io/network corresponde à rede dos pods.

Limitações

Os serviços LoadBalancer de várias redes têm as seguintes limitações:

  • Os balanceadores de carga internos exigem a criação de subconjuntos do GKE.
  • Os balanceadores de carga baseados em pool de destino ou grupo de instâncias não são compatíveis.
  • Os serviços que usam externalTrafficPolicy: Cluster não são compatíveis.
  • Os serviços não podem segmentar pods hostNetwork.
  • As redes IPv6 e de pilha dupla não são compatíveis.
  • Não é possível mudar a rede de um serviço atual.
  • Somente redes da camada 3 são compatíveis.

A seguir