Cette page a été traduite par l'API Cloud Translation.

Créer un équilibreur de charge externe basé sur un service de backend

Cette page explique comment déployer un service LoadBalancer externe qui crée un équilibreur de charge réseau passthrough externe basé sur un service de backend. Avant de lire cette page, assurez-vous de connaître les éléments suivants:

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

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 gcloud CLI. Si vous avez déjà installé gcloud CLI, assurez-vous de disposer de la dernière version en exécutant la commande gcloud components update.
Remarque : Pour les installations de gcloud CLI existantes, veillez à définir les propriétés compute/region et compute/zone. En définissant des emplacements par défaut, vous pouvez éviter les erreurs gcloud CLI telles que celle-ci : One of [--zone, --region] must be supplied: Please specify location.

Conditions requises

Pour créer un service LoadBalancer externe qui utilise un équilibreur de charge réseau passthrough externe basé sur un service de backend, votre cluster GKE doit utiliser la version 1.25.5 ou ultérieure. Pour utiliser l'équilibrage de charge pondéré, votre cluster doit utiliser la version 1.31.0-gke.1506000 ou ultérieure.
Le module complémentaire HttpLoadBalancing doit être activé dans votre cluster. Ce module complémentaire est activé par défaut. Il permet au cluster de gérer les équilibreurs de charge qui utilisent des services de backend.

Sélectionnez un cluster

Vous pouvez créer un cluster ou choisir un cluster existant qui répond aux exigences.

Créer un cluster

Autopilot

Pour créer un cluster Autopilot:

gcloud container clusters create-auto CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Remplacez les éléments suivants :

CLUSTER_NAME : nom du nouveau cluster
RELEASE_CHANNEL : nom de la version disponible de GKE pour le cluster.
VERSION: version de GKE pour le cluster.
COMPUTE_LOCATION : région Compute Engine du cluster.

Pour désactiver la création automatique de règles de pare-feu VPC pour les services LoadBalancer, incluez l'indicateur --disable-l4-lb-firewall-reconciliation. Pour en savoir plus, consultez la section Règles de pare-feu gérées par l'utilisateur pour les services de balanceur de charge GKE.

Standard

Pour créer un cluster standard:

gcloud container clusters create CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Remplacez les éléments suivants :

CLUSTER_NAME : nom du nouveau cluster
RELEASE_CHANNEL : nom de la version disponible de GKE pour le cluster.
VERSION: version de GKE pour le cluster.
COMPUTE_LOCATION : région Compute Engine du cluster.

Mettre à niveau un cluster existant

Utilisez la CLI gcloud pour mettre à jour un cluster existant:

gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION

Remplacez les éléments suivants :

CLUSTER_NAME : nom du cluster existant.
VERSION: version spécifique de GKE vers laquelle vous souhaitez mettre à niveau votre cluster. Pour en savoir plus, consultez la section Mettre à jour manuellement le plan de contrôle.
COMPUTE_LOCATION: région Compute Engine du cluster.

Déployer un exemple de charge de travail

Déployez l'exemple de charge de travail suivant, qui fournit les pods de diffusion pour le service LoadBalancer externe.

Enregistrez l'exemple de Déploiement suivant en tant que store-deployment.yaml :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: store
spec:
  replicas: 20
  selector:
    matchLabels:
      app: store
  template:
    metadata:
      labels:
        app: store
    spec:
      containers:
      - image: gcr.io/google_containers/echoserver:1.10
        imagePullPolicy: Always
        name: echoserver
        ports:
          - name: http
            containerPort: 8080
        readinessProbe:
          httpGet:
            path: /healthz
            port: 8080
            scheme: HTTP

Appliquez le fichier manifeste au cluster :
```
kubectl apply -f store-deployment.yaml
```

Vérifiez qu'il existe 20 pods de diffusion pour le déploiement:

kubectl get pods

Le résultat ressemble à ce qui suit :

NAME                     READY   STATUS    RESTARTS   AGE
store-cdb9bb4d6-s25vw      1/1     Running   0          10s
store-cdb9bb4d6-vck6s      1/1     Running   0          10s
....

Créer le Service LoadBalancer externe

Exposez l'exemple de charge de travail en créant un service LoadBalancer externe.
1. Enregistrez le fichier manifeste du Service suivant en tant que store-v1-lb-svc.yaml :
```
apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
spec:
  type: LoadBalancer
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080
```
2. Appliquez le fichier manifeste au cluster :
```
kubectl apply -f store-v1-lb-svc.yaml
```
Notez les points suivants concernant cet exemple de fichier manifeste:
- Le fichier manifeste du service doit inclure l'annotation cloud.google.com/l4-rbs: "enabled" au moment où le fichier manifeste est appliqué pour la première fois au cluster. Cela indique à GKE de créer un équilibreur de charge réseau passthrough externe basé sur un service de backend. Les équilibreurs de charge réseau passthrough externes basés sur un service de backend sont obligatoires pour prendre en charge des fonctionnalités telles que l'IPv6 et l'équilibrage de charge pondéré.
- Si vous ajoutez l'annotation cloud.google.com/l4-rbs: "enabled" au fichier manifeste d'un service LoadBalancer externe existant (c'est-à-dire après la création de l'équilibreur de charge), GKE ignore l'annotation. Les services LoadBalancer externes créés sans cette annotation dans leurs fichiers manifestes utilisent des équilibreurs de charge réseau passthrough externes basés sur un pool cible. Nous vous déconseillons d'utiliser des équilibreurs de charge réseau passthrough externes basés sur un pool cible.

Activer l'équilibrage de charge pondéré

Pour distribuer les nouvelles connexions proportionnellement aux nœuds en fonction du nombre de pods actifs, prêts et non en cours d'arrêt présents sur chaque nœud, activez l'équilibrage de charge pondéré en ajoutant l'annotation networking.gke.io/weighted-load-balancing: "pods-per-node" au fichier manifeste du service.

Ajoutez l'annotation networking.gke.io/weighted-load-balancing: "pods-per-node" au fichier manifeste de service store-v1-lb-svc.yaml et assurez-vous également de définir externalTrafficPolicy: Local comme suit:

apiVersion: v1
kind: Service
metadata:
  name: store-v1-lb-svc
  annotations:
    cloud.google.com/l4-rbs: "enabled"
    networking.gke.io/weighted-load-balancing: "pods-per-node"
spec:
  type: LoadBalancer
  externalTrafficPolicy: Local
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080

Appliquez le fichier manifeste au cluster :
```
kubectl apply -f store-v1-lb-svc.yaml
```

Notez les points suivants concernant cet exemple d'équilibrage de charge pondéré:

Le fichier manifeste du service utilise externalTrafficPolicy: Local. Si vous n'avez pas besoin d'activer l'équilibrage de charge pondéré, vous pouvez également utiliser externalTrafficPolicy: Cluster. Pour en savoir plus sur la manière dont externalTrafficPolicy définit le regroupement de nœuds, les nœuds qui réussissent les vérifications d'état de l'équilibreur de charge et la manière dont les paquets sont traités, consultez la section Concepts du Service LoadBalancer.
Si vous activez l'équilibrage de charge pondéré, GKE ne vous empêche pas d'utiliser externalTrafficPolicy: Cluster, mais externalTrafficPolicy: Cluster désactive effectivement l'équilibrage de charge pondéré, car le paquet peut être acheminé vers un autre nœud après l'équilibreur de charge.

Vous pouvez également activer l'équilibrage de charge pondéré sur un service LoadBalancer externe existant à l'aide de kubectl edit svc service-name. La commande kubectl edit ouvre le fichier manifeste de service de l'équilibreur de charge existant dans votre éditeur de texte configuré, où vous pouvez modifier le fichier manifeste et enregistrer les modifications. Lorsque vous modifiez un service LoadBalancer externe existant, tenez compte des points suivants:

Le service LoadBalancer externe existant doit avoir entraîné la création d'équilibreurs de charge réseau passthrough externes basés sur un service de backend. Cela signifie que le service LoadBalancer externe existant doit avoir inclus l'annotation cloud.google.com/l4-rbs: "enabled" lorsque le fichier manifeste a été appliqué pour la première fois au cluster.

L'ajout de l'annotation networking.gke.io/weighted-load-balancing: "pods-per-node" à un service LoadBalancer externe existant qui utilise un équilibreur de charge réseau passthrough externe basé sur un pool cible n'a aucun effet.
Lorsque vous mettez à jour le fichier manifeste du service LoadBalancer externe existant, veillez à définir externalTrafficPolicy: Local. L'utilisation de externalTrafficPolicy: Cluster désactive efficacement l'équilibrage de charge pondéré, car le paquet peut être acheminé vers un autre nœud après l'équilibreur de charge.

Désactiver l'équilibrage de charge pondéré

Pour distribuer les nouvelles connexions aux nœuds, quel que soit le nombre de pods de diffusion présents sur chaque nœud, désactivez l'équilibrage de charge pondéré en supprimant l'annotation networking.gke.io/weighted-load-balancing: "pods-per-node" du fichier manifeste du service.

Vérifier le Service LoadBalancer externe et ses composants

Vérifiez que votre Service est en cours d'exécution :
```
kubectl get svc store-v1-lb-svc
```
Le résultat ressemble à ce qui suit :
```
NAME               TYPE           CLUSTER-IP        EXTERNAL-IP     PORT(S)          AGE
store-v1-lb-svc   LoadBalancer   10.44.196.160     35.193.28.231   8080:32466/TCP   11m
```
GKE a attribué une EXTERNAL_IP à l'équilibreur de charge réseau passthrough externe.

Remarque: Dans GKE, l'attribution d'une adresse IP externe peut prendre quelques minutes avant que l'équilibreur de charge ne soit prêt à diffuser l'application.

Testez la connexion à l'équilibreur de charge :

curl EXTERNAL_IP:PORT

Remplacez les éléments suivants :

EXTERNAL_IP : adresse IP allouée pour l'équilibreur de charge réseau passthrough externe.
PORT : numéro de port alloué pour l'équilibreur de charge réseau passthrough externe.

Le résultat ressemble à ce qui suit :

Hostname: store-v1-lb-svc-cdb9bb4d6-hflxd

Pod Information:
  -no pod information available-

Server values:
  server_version=nginx: 1.13.3 - lua: 10008

Request Information:
  client_address=10.128.0.50
  method=GET
  real path=/
  query=
  request_version=1.1
  request_scheme=http
  request_uri=EXTERNAL_IP

Request Headers:
  accept=*/*
  host=EXTERNAL_IP
  user-agent=curl/7.81.0

Request Body:
  -no body in request-

Vérifiez votre service LoadBalancer et son ensemble d'annotations décrivant ses ressourcesGoogle Cloud :
```
kubectl describe svc store-v1-lb-svc
```
Le résultat ressemble à ce qui suit :
```
Name:                     my-service-external
Namespace:                default
Labels:                   <none>
Annotations:              cloud.google.com/l4-rbs: enabled
                          networking.gke.io/weighted-load-balancing: pods-per-node #This annotation appears in the output only if weighted load balancing is enabled.
                          service.kubernetes.io/backend-service: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-qvveq1d8-default-my-service-ext-5s55db85-fw
                          service.kubernetes.io/healthcheck: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                          service.kubernetes.io/tcp-forwarding-rule: a808124abf8ce406ca51ab3d4e7d0b7d
Selector:                 app=my-app
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.18.102.23
IPs:                      10.18.102.23
LoadBalancer Ingress:     35.184.160.229
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  31864/TCP
Endpoints:                10.20.1.28:8080,10.20.1.29:8080
Session Affinity:         None
External Traffic Policy:  Local
HealthCheck NodePort:     30394

Events:
  Type    Reason                Age                    From                     Message
  ----    ------                ----                   ----                     -------
  Normal  ADD                   4m55s                  loadbalancer-controller  default/my-service-ext
```
Plusieurs champs indiquent qu'un équilibreur de charge réseau passthrough externe basé sur un service de backend et ses Google Cloud ressources ont été créés avec succès:
- Champ Events. Ce champ est vide lorsque le Service LoadBalancer et ses ressources ont été créés avec succès. Si une erreur s'est produite, elle apparaît dans ce champ.
- Liste des Annotations activées: GKE ajoute la liste d'annotations suivante en lecture seule au fichier manifeste du Service. Chaque annotation dont le nom commence par service.kubernetes.io/ permet d'indiquer le nom d'une ressourceGoogle Cloud créée comme partie intégrante de l'équilibreur de charge ou pour assurer sa compatibilité.
  - L'annotation networking.gke.io/weighted-load-balancing: pods-per-node indique que l'équilibrage de charge pondéré a été appliqué et que l'équilibreur de charge répartit le trafic vers les pods backend en fonction du nombre de pods exécutés sur chaque nœud.
  - L'annotation service.kubernetes.io/backend-service indique le nom du service de backend de l'équilibreur de charge.
  - L'annotation service.kubernetes.io/healthcheck indique le nom de la vérification d'état de l'équilibreur de charge utilisée par le service de backend.
  - L'annotation service.kubernetes.io/tcp-forwarding-rule ou service.kubernetes.io/udp-forwarding-rule indique le nom de la règle de transfert de l'équilibreur de charge.
  - L'annotation service.kubernetes.io/firewall-rule indique le nom de la règle de pare-feu créée pour autoriser le trafic vers les nœuds du cluster. Les plages sources de cette règle de pare-feu sont personnalisables à l'aide de spec.loadBalancerSourceRanges[]. Pour en savoir plus sur les règles de pare-feu pour les Services LoadBalancer, consultez la section Règles de pare-feu et liste d'autorisation d'adresses IP sources.
  - L'annotation service.kubernetes.io/firewall-rule-for-hc indique le nom de la règle de pare-feu requise pour les vérifications d'état de l'équilibreur de charge.
Vérifiez que les ressources de l'équilibreur de charge et les règles de pare-feu ont été créées pour le Service LoadBalancer externe:
- Pour afficher la règle de transfert, exécutez la commande suivante :
```
  gcloud compute forwarding-rules describe FWD_RULE_NAME \
    --region=REGION_NAME
```
  Remplacez les éléments suivants :
  - FWD_RULE_NAME: nom de la règle de transfert fournie par les annotations en lecture seule service.kubernetes.io/tcp-forwarding-rule ou service.kubernetes.io/udp-forwarding-rule. Pour vérifier ces annotations, exécutez la commande kubectl describe svc SERVICE_NAME.
  - REGION_NAME: région contenant le cluster. Google Cloud Pour les clusters zonaux, la région contient la zone utilisée par le cluster.
- Pour afficher le service de backend, exécutez la commande suivante :
```
gcloud compute backend-services describe BACKEND_SERVICE_NAME \
  --region=REGION_NAME
```
  Remplacez les éléments suivants :
  - BACKEND_SERVICE_NAME: nom du service de backend fourni par l'annotation en lecture seule service.kubernetes.io/backend-service. Pour vérifier cette annotation en lecture seule, exécutez la commande kubectl describe svc SERVICE_NAME.
  - REGION_NAME: région contenant le cluster. Google Cloud Pour les clusters zonaux, la région contient la zone utilisée par le cluster.
- Pour afficher la vérification de l'état de l'équilibreur de charge, exécutez la commande suivante :
```
gcloud compute health-checks describe HEALTH_CHECK_NAME \
  --region=REGION_NAME
```
  Remplacez les éléments suivants :
  - HEALTH_CHECK_NAME: nom de la vérification d'état de l'équilibreur de charge. Le nom de la vérification d'état est fourni par l'annotation en lecture seule service.kubernetes.io/healthcheck. Pour vérifier cette annotation en lecture seule, exécutez kubectl describe svc SERVICE_NAME.
  - REGION_NAME: région contenant le cluster. Google Cloud Pour les clusters zonaux, la région contient la zone utilisée par le cluster.
- Pour afficher les règles de pare-feu, exécutez les commandes suivantes :
```
gcloud compute firewall-rules describe FIREWALL_RULE_NAME \
gcloud compute firewall-rules describe HEALTH_CHECK_FIREWALL_RULE_NAME
```
  Remplacez les éléments suivants :
  - FIREWALL_RULE_NAME: nom de la règle de pare-feu qui autorise le trafic vers l'équilibreur de charge. Le nom de cette règle de pare-feu est fourni par l'annotation en lecture seule service.kubernetes.io/firewall-rule. Pour vérifier cette annotation en lecture seule, exécutez la commande kubectl describe svc SERVICE_NAME.
  - HEALTH_CHECK_FIREWALL_RULE_NAME: nom de la règle de pare-feu qui autorise les vérifications de l'état des backends de l'équilibreur de charge (les nœuds du cluster). Le nom de cette règle de pare-feu est fourni par l'annotation en lecture seule service.kubernetes.io/firewall-rule-for-hc. Pour vérifier cette annotation en lecture seule, exécutez la commande kubectl describe svc SERVICE_NAME.

Supprimer le service LoadBalancer externe

Pour supprimer l'exemple de service LoadBalancer externe store-v1-lb-svc, utilisez la commande suivante:

kubectl delete service store-v1-lb-svc

GKE supprime automatiquement toutes les ressources d'équilibreur de charge qu'il a créées pour le service LoadBalancer externe.

Résoudre les problèmes

Cette section décrit un problème que vous pouvez rencontrer lorsque vous configurez l'équilibrage de charge pondéré.

Mauvaise règle de trafic externe pour l'équilibrage de charge pondéré

Si vous ne définissez pas externalTrafficPolicy: Local lorsque vous activez l'équilibrage de charge pondéré, vous pouvez recevoir un événement d'avertissement lorsque vous décrivez le service à l'aide de la commande suivante:

kubectl describe svc store-v1-lb-svc`

Events:
  Type     Reason                   Age      From                     Message
  ----     ------                   ----     ----                     -------
  Warning  UnsupportedConfiguration 4m55s    loadbalancer-controller  Weighted load balancing by pods-per-node has no effect with External Traffic Policy: Cluster.

Pour activer efficacement l'équilibrage de charge pondéré, vous devez définir externalTrafficPolicy: Local.

Étape suivante

Pour obtenir une présentation générale des Services de l'équilibreur de charge, consultez la section Services LoadBalancer.
Pour obtenir une description des paramètres des Services de l'équilibreur de charge, consultez la section Paramètres du Service LoadBalancer.
Résoudre les problèmes liés à l'équilibrage de charge dans GKE.