Services LoadBalancer multiréseaux

La multiconnectivité GKE vous permet de connecter vos charges de travail à plusieurs réseaux VPC. Vous pouvez exposer ces pods multiréseaux à des clients internes ou externes à l'aide d'un service Kubernetes de type type: LoadBalancer. GKE provisionne un équilibreur de charge L4 Google Cloud pour le service, qui envoie le trafic aux pods sur un réseau secondaire spécifié.

Ce document explique comment GKE implémente les services LoadBalancer pour les pods multiréseaux. Elle couvre la configuration requise, les fonctionnalités et les limites de la fonctionnalité.

Fonctionnement des services LoadBalancer multiréseaux

Pour exposer une charge de travail multiréseau, vous devez créer un Service de type: LoadBalancer. Ce service doit inclure un sélecteur spécial qui cible les pods en fonction du réseau de leur interface secondaire. Vous ajoutez également une annotation pour spécifier si vous souhaitez créer un équilibreur de charge interne ou externe.

Le libellé networking.gke.io/network dans le sélecteur filtre les points de terminaison par réseau. Cela garantit que l'équilibreur de charge n'envoie le trafic qu'aux interfaces de pod connectées au réseau spécifié.

Service LoadBalancer interne

Pour créer un équilibreur de charge interne, ajoutez l'annotation networking.gke.io/load-balancer-type: "Internal" au fichier manifeste de votre service. L'exemple suivant montre un service qui crée un équilibreur de charge interne pour cibler les pods sur le réseau 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

Service LoadBalancer externe

Pour créer un équilibreur de charge réseau externe basé sur un service de backend, ajoutez l'annotation cloud.google.com/l4-rbs: enabled à votre fichier manifeste de service. L'exemple suivant montre un service qui crée un équilibreur de charge externe pour cibler les pods sur le réseau 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

Configuration des pods et du réseau

Vos pods doivent disposer d'une interface dans le réseau ciblé par le service LoadBalancer. Vous devez également configurer le routage dans le pod afin qu'il puisse répondre correctement aux requêtes sur l'interface réseau appropriée.

Vous pouvez configurer le routage des pods de l'une des manières suivantes :

  • Définissez une interface par défaut : utilisez l'annotation networking.gke.io/default-interface sur le pod pour définir l'interface réseau secondaire comme route par défaut.

  • Configurer le routage basé sur des règles : utilisez un initContainer avec la fonctionnalité NET_ADMIN pour configurer des règles de routage dans le pod.

L'exemple suivant montre un fichier manifeste Deployment pour les pods avec une interface sur le réseau dmz. L'annotation networking.gke.io/default-interface définit l'interface dmz (eth1) comme route par défaut.

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

Valider les points de terminaison multiréseaux

GKE utilise un contrôleur dédié, multinet-endpointslice-controller.gke.io, pour gérer les points de terminaison des services multiréseaux. Ce contrôleur crée des objets EndpointSlice pour vos services multiréseaux. Les adresses IP des objets EndpointSlice appartiennent au réseau secondaire spécifié dans le sélecteur de service.

Si un équilibreur de charge ne comporte aucun backend opérationnel, inspectez le EndpointSlice du service pour vérifier que le contrôleur a sélectionné les adresses IP de pod correctes. Si EndpointSlice ne comporte aucun point de terminaison, vérifiez que les libellés du sélecteur de service correspondent à vos pods en cours d'exécution et que le sélecteur networking.gke.io/network correspond au réseau des pods.

Limites

Les services LoadBalancer multiréseaux présentent les limites suivantes :

  • Les équilibreurs de charge internes nécessitent le sous-paramètre GKE.
  • Les équilibreurs de charge basés sur un pool cible ou un groupe d'instances ne sont pas acceptés.
  • Les services qui utilisent externalTrafficPolicy: Cluster ne sont pas acceptés.
  • Les services ne peuvent pas cibler les pods hostNetwork.
  • La mise en réseau IPv6 et à double pile n'est pas prise en charge.
  • Vous ne pouvez pas modifier le réseau d'un service existant.
  • Seuls les réseaux de couche 3 sont acceptés.

Étapes suivantes