Serviços LoadBalancer de várias redes

Com as várias redes do GKE, é possível 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 balanceador de carga L4 do Google Cloud para o Serviço que envia tráfego para pods em uma rede secundária especificada.

Neste documento, explicamos como o GKE implementa os 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 funcionam os Serviços LoadBalancer de várias redes

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 segmente pods com base na rede da interface secundária deles. 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 os 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 anotação networking.gke.io/load-balancer-type: "Internal" 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, configure um balanceador de carga baseado em serviço de back-end. No GKE 1.37 e versões mais recentes, esse é o comportamento padrão. Em versões anteriores, 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 os pods de destino 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. Também é necessário 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 anotação networking.gke.io/default-interface 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 o recurso NET_ADMIN para configurar regras de rota dentro do pod.

O exemplo a seguir mostra um manifesto 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.
  • Não há suporte para balanceadores de carga baseados em pool de destino ou grupo de instâncias.
  • Os serviços que usam externalTrafficPolicy: Cluster não são compatíveis.
  • Os serviços não podem segmentar pods do hostNetwork.
  • Não há suporte para IPv6 e rede de pilha dupla.
  • Não é possível alterar a rede de um serviço atual.
  • Somente redes de camada 3 são compatíveis.

A seguir