Créer un équilibreur de charge externe multiprotocole

Autopilot Standard

Ce document explique comment exposer à Internet une application exécutée dans un cluster Google Kubernetes Engine (GKE) à l'aide d'un service LoadBalancer externe à protocole mixte pour le trafic TCP et UDP.

Pour en savoir plus sur les équilibreurs de charge réseau passthrough externes, consultez Équilibreur de charge réseau passthrough externe basé sur un service de backend.

Présentation

Vous pouvez exposer des applications qui utilisent les protocoles TCP et UDP en utilisant deux services GKE LoadBalancer distincts avec une adresse IP partagée coordonnée manuellement. Toutefois, cette approche est inefficace, car elle nécessite de gérer plusieurs services pour une même application et peut entraîner des problèmes tels que des erreurs de configuration ou des quotas d'adresses IP épuisés.

Les services LoadBalancer à protocole mixte vous permettent d'utiliser un seul service pour gérer le trafic TCP et UDP. L'utilisation d'un seul service simplifie votre configuration en vous permettant d'utiliser une seule adresse IPv4 et un ensemble consolidé de règles de transfert pour les deux protocoles. Cette fonctionnalité est compatible avec les équilibreurs de charge réseau passthrough externes.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

Activez l'API Google Kubernetes Engine.

Activer l'API Google Kubernetes Engine

Si vous souhaitez utiliser Google Cloud CLI pour cette tâche, installez puis initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.
Remarque : Pour les installations de la gcloud CLI existantes, veillez à définir la propriété compute/region. Si vous utilisez principalement des clusters zonaux, définissez plutôt compute/zone. En définissant un emplacement par défaut, vous pouvez éviter les erreurs gcloud CLI de ce type : One of [--zone, --region] must be supplied: Please specify location. Vous devrez peut-être spécifier l'emplacement dans certaines commandes si celui de votre cluster diffère de l'emplacement par défaut que vous avez défini.

Assurez-vous de disposer d'un cluster Autopilot ou Standard existant. Pour créer un cluster, consultez la page Créer un cluster Autopilot.

Conditions requises

Pour créer un service LoadBalancer externe qui utilise des protocoles mixtes, votre cluster doit répondre aux exigences suivantes :

L'équilibrage de charge multiprotocole n'est disponible que sur les clusters nouvellement créés exécutant la version 1.34.1-gke.2190000 ou ultérieure.
Le module complémentaire HttpLoadBalancing doit être activé sur votre cluster.
Pour les nouveaux services LoadBalancer externes, afin d'implémenter l'équilibreur de charge, définissez le champ spec.loadBalancerClass sur networking.gke.io/l4-regional-external dans le fichier manifeste du service. Pour les services existants, votre fichier manifeste comporte déjà l'annotation cloud.google.com/l4-rbs: "enabled". Vous pouvez la laisser telle quelle.

Limites

Les équilibreurs de charge à protocole mixte n'acceptent que les adresses IPv4.
Vous ne pouvez pas utiliser de protocoles mixtes dans un fichier manifeste de service avec les finaliseurs suivants :
- gke.networking.io/l4-ilb-v1
- gke.networking.io/l4-netlb-v1
Si votre fichier manifeste comporte ces finaliseurs, vous devez supprimer et recréer le service en respectant les exigences précédentes.

Tarifs

Google Cloud vous facture chaque règle de transfert, chaque adresse IP externe et les données envoyées. Le tableau suivant décrit le nombre de règles de transfert et d'adresses IP externes utilisées pour les configurations spécifiées. Pour en savoir plus, consultez la section Tarifs des réseaux VPC.

Type	Couche de transport	Couche Internet	Nombre de règles de transfert	Nombre d'adresses IP externes
Externe	Unique (TCP ou UDP)	IPv4	1	1
		IPv6	1	1
		IPv4 et IPv6(double pile)	2	2
	Mixte (TCP et UDP)	IPv4	2	1

Déployer une charge de travail

Cette section explique comment déployer un exemple de charge de travail qui écoute les ports TCP et UDP. Notez que la configuration du déploiement est la même, que vous utilisiez un service LoadBalancer à protocole mixte ou deux services LoadBalancer à protocole unique distincts.

Le fichier manifeste suivant concerne un exemple d'application qui écoute sur le port 8080 pour le trafic TCP et UDP. Enregistrez le manifeste suivant sous le nom mixed-app-deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: mixed-app-deployment
spec:
  replicas: 3
  selector:
    matchLabels:
      app: mixed-app
  template:
    metadata:
      labels:
        app: mixed-app
    spec:
      containers:
      - image: gcr.io/kubernetes-e2e-test-images/agnhost:2.6
        name: agnhost
        args: ["serve-hostname", "--port=8080", "--tcp=true", "--udp=true", "--http=false"]
        ports:
          - name: tcp8080
            protocol: TCP
            containerPort: 8080
          - name: udp8080
            protocol: UDP
            containerPort: 8080

Appliquez le fichier manifeste à votre cluster :
```
kubectl apply -f mixed-app-deployment.yaml
```

Créer un équilibreur de charge à protocole mixte

Créez un service de type LoadBalancer qui expose le déploiement au trafic TCP et UDP.

Enregistrez le manifeste suivant sous le nom mixed-protocol-lb.yaml :

apiVersion: v1
kind: Service
metadata:
  name: mixed-protocol-lb
spec:
  loadBalancerClass: "networking.gke.io/l4-regional-external"
  type: LoadBalancer
  selector:
    app: mixed-app
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
  - name: udp-port
    protocol: UDP
    port: 8080

Le service précédent comporte deux ports, un pour TCP et un pour UDP, tous deux sur le port 8080.

Appliquez le fichier manifeste à votre cluster :

kubectl apply --server-side -f mixed-protocol-lb.yaml

Vérifier l'équilibreur de charge à protocole mixte

Une fois le service créé, vérifiez que GKE a correctement créé l'équilibreur de charge.

Inspectez le service :
```
kubectl describe service mixed-protocol-lb
```
La sortie affiche l'adresse IP externe de l'équilibreur de charge et les règles de transfert pour TCP et UDP. Vérifiez les informations suivantes dans le résultat :
- Le champ status.loadBalancer.ingress.ip est renseigné.
- Vérifiez que les annotations suivantes pour votre équilibreur de charge externe sont présentes :
  - service.kubernetes.io/tcp-forwarding-rule
  - service.kubernetes.io/udp-forwarding-rule
- La section Events ne contient aucun message d'erreur.

Mettre à jour l'équilibreur de charge à protocole mixte

Vous pouvez modifier les ports d'un équilibreur de charge à protocole mixte en modifiant le fichier manifeste du service. Pour modifier l'objet Service, exécutez la commande suivante :

kubectl edit service SERVICE_NAME

Remplacez SERVICE_NAME par le nom de votre service.

Mettre à jour les ports

Pour mettre à jour les ports d'un équilibreur de charge à protocole mixte, modifiez la section ports du fichier manifeste du service. Vous pouvez ajouter, supprimer ou modifier des ports.

L'exemple suivant ajoute un port UDP pour le streaming et un port TCP pour les métadonnées du serveur de jeu :

apiVersion: v1
kind: Service
metadata:
  name: mixed-protocol-lb
spec:
  loadBalancerClass: "networking.gke.io/l4-regional-external"
  type: LoadBalancer
  selector:
    app: mixed-app
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
  - name: streaming
    protocol: UDP
    port: 10100
  - name: gameserver-metadata
    protocol: TCP
    port: 10400
  - name: https
    protocol: TCP
    port: 443

Mettre à jour un équilibreur de charge monoprotocole vers un équilibreur multiprotocole

Pour transformer un équilibreur de charge monoprotocole en équilibreur de charge multiprotocole, modifiez le service pour inclure les ports des protocoles TCP et UDP.

L'exemple suivant ajoute un port UDP pour le DNS à un équilibreur de charge existant qui n'utilise que le protocole TCP :

apiVersion: v1
kind: Service
metadata:
  name: already-existing-single-protocol-lb
spec:
  loadBalancerClass: "networking.gke.io/l4-regional-external"
  type: LoadBalancer
  selector:
    app: mixed-app
  ports:
  - name: http
    protocol: TCP
    port: 80
  - name: https
    protocol: TCP
    port: 443
  - name: dns
    protocol: UDP
    port: 53

Mettre à jour un équilibreur de charge multiprotocole vers un équilibreur de charge monoprotocole

Pour transformer un équilibreur de charge multiprotocole en équilibreur de charge monoprotocole, supprimez tous les ports pour l'un des protocoles.

L'exemple suivant supprime le port UDP pour le DNS, ce qui convertit l'équilibreur de charge en équilibreur TCP uniquement :

apiVersion: v1
kind: Service
metadata:
  name: already-existing-mixed-protocol-lb
spec:
  loadBalancerClass: "networking.gke.io/l4-regional-external"
  type: LoadBalancer
  selector:
    app: mixed-app
  ports:
  - name: http
    protocol: TCP
    port: 80
  - name: https
    protocol: TCP
    port: 443

Supprimer l'équilibreur de charge à protocole mixte

Pour supprimer le service LoadBalancer externe mixed-protocol-lb, exécutez la commande suivante :

kubectl delete service mixed-protocol-lb

GKE supprime automatiquement toutes les ressources d'équilibreur de charge créées pour le service.

Dépannage

Cette section explique comment résoudre les problèmes courants liés aux services LoadBalancer à protocole mixte.

Rechercher les événements d'erreur

La première étape du dépannage consiste à vérifier les événements associés à votre service.

Obtenez les détails de votre service :

kubectl describe service mixed-protocol-lb

Examinez la section Events à la fin du résultat pour détecter d'éventuels messages d'erreur.

Erreur : Le protocole mixte n'est pas compatible avec LoadBalancer

Si vous avez créé le service avec l'annotation cloud.google.com/l4-rbs: "enabled", vous pouvez voir un événement d'avertissement du contrôleur de service d'origine après avoir créé l'équilibreur de charge à protocole mixte : mixed-protocol is not supported for LoadBalancer.

Vous pouvez ignorer ce message, car le nouveau contrôleur, qui est compatible avec les protocoles mixtes, provisionne correctement l'équilibreur de charge.

La définition du port est manquante après une mise à jour

Symptôme :

Lorsque vous mettez à jour un service qui utilise le même port pour TCP et UDP (par exemple, le port 8080), l'une des définitions de port est manquante dans le service mis à jour.

Cause :

Il s'agit d'un problème connu dans Kubernetes. Lorsque vous mettez à jour un service avec plusieurs protocoles sur le même port, le calcul du correctif côté client peut fusionner incorrectement la liste des ports, ce qui entraîne la suppression de l'une des définitions de port. Ce problème concerne les clients qui utilisent le patching côté client, comme kubectl apply et le client Go avec des correctifs de fusion.

Solution :

La solution de contournement de ce problème dépend de votre client.

Pour kubectl : utilisez l'indicateur --server-side avec kubectl apply :
```
kubectl apply --server-side -f YOUR_SERVICE_MANIFEST.yaml
```
Remplacez YOUR_SERVICE_MANIFEST par le nom de votre fichier manifeste de service.
Pour go-client : n'utilisez pas de correctifs de fusion. Utilisez plutôt un appel de mise à jour pour remplacer le service. Cela nécessite une requête HTTP PUT avec la spécification complète de l'objet Service.

Étapes suivantes

Découvrez comment exposer des applications à l'aide de services.
En savoir plus sur les services LoadBalancer