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

Restez organisé à l'aide des collections Enregistrez et classez les contenus selon vos préférences.

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:

• À propos des services LoadBalancer
• Paramètres du service GKE LoadBalancer

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.

Conditions requises

• 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.

• 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 créer un service LoadBalancer externe qui utilise l'équilibrage de charge pondéré, votre cluster GKE doit utiliser la version 1.31.0-gke.1506000 ou ultérieure.

• Pour créer un service LoadBalancer externe qui utilise des backends de groupes de points de terminaison du réseau (NEG) GCE_VM_IP, votre cluster GKE doit utiliser la version 1.32.2-gke.1652000 ou ultérieure.

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.

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.

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.

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.

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.

1. 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
   

2. Appliquez le fichier manifeste au cluster :

   kubectl apply -f store-deployment.yaml
   

3. 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

1. 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 de 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é.

   • GKE utilise des backends de NEG GCE_VM_IP ou des backends de groupes d'instances non gérés, en fonction de la version du cluster. Dans les clusters avec la version 1.32.2-gke.1652000, l'équilibreur de charge réseau passthrough externe basé sur un service de backend utilise des NEG GCE_VM_IP. Dans les versions précédentes, l'équilibreur de charge réseau passthrough externe basé sur un service de backend utilise des groupes d'instances non gérés.

   • 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.

1. 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
   

2. 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

1. 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.

2. 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-
   
   

3. 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
                             cloud.google.com/neg-status: {"network_endpoint_groups":{"0":"k8s2-qvveq1d8-default-my-service-ext-5s55db85"},"zones":["us-central1-c"]} #This annotation appears in the output only if the service uses NEG backends.
                             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.

     • L'annotation cloud.google.com/neg-status indique à la fois les NEG utilisés par l'équilibreur de charge et leurs zones. Cette annotation n'est présente que si les deux conditions suivantes sont remplies:

       • Le cluster exécutait GKE version 1.32.2-gke.1652000 ou ultérieure au moment de l'application du fichier manifeste au cluster, et
       • L'annotation cloud.google.com/l4-rbs: "enabled" était présente dans le fichier manifeste de service lorsqu'il a été appliqué au cluster.

4. 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.

   • Pour afficher les NEG de l'équilibreur de charge, exécutez la commande suivante:

     gcloud compute network-endpoint-groups describe NEG_NAME \
       --zone=ZONE_NAME
     

     Remplacez les éléments suivants :

     • NEG_NAME: nom du NEG de l'équilibreur de charge. Le nom du NEG est fourni par l'annotation en lecture seule cloud.google.com/neg-status. Pour vérifier cette annotation en lecture seule, exécutez la commande kubectl describe svc SERVICE_NAME. L'annotation contient des données structurées avec des informations sur les noms et les zones de NEG utilisés par l'équilibreur de charge. Pour les clusters zonaux, cette annotation contient des informations sur un NEG. Pour les clusters régionaux, cette annotation contient des informations sur un NEG dans chaque zone dans laquelle se trouve le cluster.
     • ZONE_NAME: Google Cloud zone contenant le NEG.

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.

Migrer vers des backends de NEG GCE_VM_IP

Les services LoadBalancer externes avec l'annotation cloud.google.com/l4-rbs: "enabled" créent des équilibreurs de charge réseau passthrough externes basés sur un service de backend qui utilisent des backends de groupes de points de terminaison du réseau (GCE_VM_IP) ou de groupes d'instances, en fonction de la version GKE du cluster:

• Si le fichier manifeste de service a été appliqué à un cluster exécutant la version 1.32.2-gke.1652000 ou ultérieure de GKE, l'équilibreur de charge réseau passthrough externe qui en résulte utilise des backends de groupe de points de terminaison du réseau (NEG) GCE_VM_IP.

• Si le fichier manifeste de service a été appliqué à un cluster exécutant une version antérieure de GKE, l'équilibreur de charge réseau passthrough externe qui en résulte utilise des backends de groupe d'instances non gérés.

Pour en savoir plus, consultez la section Regroupement de nœuds dans la page "À propos des services LoadBalancer".

Vous pouvez créer un service LoadBalancer externe alimenté par un équilibreur de charge réseau passthrough externe basé sur un service de backend qui utilise des backends NEG GCE_VM_IP si votre service existant utilise l'un des équilibreurs de charge suivants:

• Équilibreur de charge réseau passthrough externe basé sur un service de backend avec des backends de groupe d'instances
• Équilibreur de charge réseau passthrough externe basé sur un pool cible

Pour passer à un équilibreur de charge réseau passthrough externe basé sur un service de backend à l'aide de backends NEG GCE_VM_IP:

1. Si vous ne l'avez pas déjà fait, mettez à niveau votre cluster vers la version 1.32.2-gke.1652000 ou ultérieure de GKE.

2. Identifiez le service LoadBalancer externe que vous souhaitez remplacer par un équilibreur de charge réseau passthrough externe basé sur un service de backend à l'aide de backends NEG GCE_VM_IP. Décrivez le service à l'aide de la commande suivante:

   kubectl describe svc SERVICE_NAME -n SERVICE_NAMESPACE
   

   Remplacez les éléments suivants :

   • SERVICE_NAME: nom du service LoadBalancer externe existant.

   • SERVICE_NAMESPACE: espace de noms du service LoadBalancer externe existant.

   Dans la sortie de la commande, notez l'adresse IPv4 externe utilisée par l'équilibreur de charge existant dans la colonne EXTERNAL-IP.

3. Récupérez le fichier manifeste du service pour le service LoadBalancer existant:

   • Il est préférable de disposer du fichier manifeste de service d'origine que vous avez appliqué au cluster précédemment. Par exemple, vous pouvez le trouver dans un dépôt de contrôle des sources.

   • Si vous ne disposez pas du fichier manifeste de service d'origine:

     • Exécutez la commande suivante pour obtenir une copie YAML du fichier manifeste de service représentant l'implémentation actuelle de l'équilibreur de charge:

       kubectl get svc SERVICE_NAME -n SERVICE_NAMESPACE -o yaml
       

     • Copiez le fichier manifeste YAML dans un éditeur de texte. Supprimez l'attribut status et les attributs metadata suivants:

       • Toutes les annotations suivantes :
         • kubectl.kubernetes.io/last-applied-configuration annotation
         • Toutes les annotations commençant par service.kubernetes.io
       • creationTimestamp
       • finalizers
       • resourceVersion
       • uid

   • Assurez-vous que le fichier manifeste inclut l'annotation cloud.google.com/l4-rbs: "enabled". Si vous migrez depuis un équilibreur de charge réseau passthrough externe basé sur un pool cible, l'annotation doit être ajoutée.

   Notez le chemin d'accès local contenant le fichier manifeste de service. Le reste de cette procédure fait référence au chemin d'accès sous la forme MANIFEST_FILE_PATH.

4. Configurez une ressource d'adresse IPv4 externe statique pour contenir l'adresse IPv4 externe utilisée par l'équilibreur de charge existant:

   gcloud compute addresses create IP_ADDRESS_NAME --region=CLUSTER_REGION --addresses LB_EXTERNAL_IP
   

   Remplacez les éléments suivants :

   • IP_ADDRESS_NAME: nom de l'adresse IP externe statique Le nom doit respecter les conventions d'attribution de noms pour les ressources Compute Engine.

   • CLUSTER_REGION: région qui contient le cluster. Pour les clusters zonaux, il s'agit de la région qui contient la zone du cluster.

   • LB_EXTERNAL_IP: adresse IPv4 externe utilisée par l'équilibreur de charge actuel, déterminée à la deuxième étape de cette procédure.

5. Vérifiez que la ressource d'adresse IPv4 externe statique a été créée:

   gcloud compute addresses describe IP_ADDRESS_NAME --region=CLUSTER_REGION
   

   Remplacez les variables comme indiqué à l'étape précédente.

6. Supprimez le service existant:

   kubectl delete svc SERVICE_NAME -n SERVICE_NAMESPACE
   

7. Ajoutez l'annotation suivante au fichier manifeste de service MANIFEST_FILE_PATH:

   networking.gke.io/load-balancer-ip-addresses: IP_ADDRESS_NAME
   

   Pour en savoir plus sur cette annotation, consultez la section Adresses IP statiques dans les paramètres du service LoadBalancer.

8. Appliquez le fichier manifeste Service mis à jour au cluster:

   kubectl apply -f MANIFEST_FILE_PATH
   

9. (Facultatif) Libérez la ressource d'adresse IPv4 statique.

   gcloud compute addresses delete IP_ADDRESS_NAME --region=CLUSTER_REGION
   

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.