Services LoadBalancer multiréseaux

La fonctionnalité multiréseau de 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: LoadBalancer. GKE provisionne un Google Cloud équilibreur de charge de couche 4 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. Il couvre la configuration, les fonctionnalités et les limites requises de la fonctionnalité.

Fonctionnement des services LoadBalancer multiréseaux

Pour exposer une charge de travail multiréseau, vous créez 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 du sélecteur filtre les points de terminaison par réseau. Cela garantit que l'équilibreur de charge n'envoie du 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' networking.gke.io/load-balancer-type: "Internal" annotation 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 au fichier manifeste de votre 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éfinir une interface par défaut : utilisez l'networking.gke.io/default-interface annotation 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 NET_ADMIN fonctionnalité 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 de ces objets EndpointSlice appartiennent au réseau secondaire spécifié dans le sélecteur de service.

Si un équilibreur de charge ne dispose d'aucun backend opérationnel, inspectez l'EndpointSlice du service pour vérifier que le contrôleur a sélectionné les adresses IP de pod correctes. Si l'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 limites suivantes s'appliquent aux services LoadBalancer multiréseaux :

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

Étape suivante