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 régional 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 régionaux en général, consultez Équilibreur de charge réseau passthrough externe régional 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 la 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.

Conditions requises

  • Ce tutoriel utilise spec.loadBalancerClass pour créer un équilibreur de charge réseau passthrough externe régional basé sur un service de backend avec des backends de NEG GCE_VM_IP. Ce tutoriel nécessite GKE version 1.33.1-gke.1779000 ou ultérieure, car spec.loadBalancerClass nécessite GKE version 1.33.1-gke.1779000 ou ultérieure. La version 1.33.1-gke.1779000 ou ultérieure dépasse également les exigences de version minimale de GKE pour les backends NEG ou la fonctionnalité d'équilibreur de charge pondéré.

  • Si votre cluster utilise une version antérieure à la version 1.36, le module complémentaire HttpLoadBalancing doit être activé dans votre cluster. Ce module complémentaire est activé par défaut. Pour en savoir plus, consultez Prérequis pour HttpLoadBalancing.

  • Pour activer Cloud Logging pour un service LoadBalancer externe, votre cluster GKE doit utiliser la version 1.36.0-gke.2459000 ou ultérieure.

  • Pour utiliser des adresses IPv6 BYOIP (Bring Your Own IP) avec un service LoadBalancer externe IPv6 à pile unique, votre cluster GKE doit utiliser la version 1.37.1-gke.2097000 ou une version 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 :

Pour désactiver la création automatique de règles de pare-feu VPC pour les services LoadBalancer, incluez l'option --disable-l4-lb-firewall-reconciliation. Pour en savoir plus, consultez Règles de pare-feu gérées par l'utilisateur pour les services LoadBalancer 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 :

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

Mettre à niveau un cluster existant

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

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

Remplacez les éléments suivants :

Pour désactiver la création automatique de règles de pare-feu VPC pour les services LoadBalancer, incluez l'option --disable-l4-lb-firewall-reconciliation. Pour en savoir plus, consultez Règles de pare-feu gérées par l'utilisateur pour les services LoadBalancer 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: registry.k8s.io/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
      spec:
        type: LoadBalancer
        loadBalancerClass: networking.gke.io/l4-regional-external
        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 :

    • Si votre cluster exécute GKE 1.33.1-gke.1779000 à 1.36, vous devez définir le champ spec.loadBalancerClass sur la valeur networking.gke.io/l4-regional-external au moment où le fichier manifeste est appliqué pour la première fois au cluster. Ce champ indique à GKE de créer un équilibreur de charge réseau passthrough externe régional basé sur un service de backend. Dans GKE 1.37 et versions ultérieures, cette configuration est le comportement par défaut et le champ n'est pas obligatoire. Les équilibreurs de charge réseau passthrough externes régionaux basés sur un service de backend sont requis pour prendre en charge des fonctionnalités telles que le trafic 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, selon la version du cluster. Dans les clusters dotés de la version 1.32.2-gke.1652000, l'équilibreur de charge réseau passthrough externe régional 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 régional basé sur un service de backend utilisait des groupes d'instances non gérés.

    • Ce champ spec.loadBalancerClass est immuable et doit être défini lorsque vous créez le service. Comme ce champ n'est pas modifiable, vous ne pouvez pas l'ajouter ni le modifier dans le fichier manifeste d'un service LoadBalancer existant. Toute tentative de modification entraîne une erreur et l'échec de la mise à jour du service.

    • Pour créer un service IPv6 à pile unique dans un cluster à double pile, définissez la valeur du champ spec.ipFamilyPolicy sur SingleStack et la valeur du champ spec.ipFamilies sur IPv6. Dans un cluster IPv6 à pile unique, il s'agit des valeurs par défaut, que vous pouvez omettre. Pour en savoir plus, consultez Services LoadBalancer IPv6.

Créer un service LoadBalancer externe sur un cluster IPv6 à pile unique

Lorsque vous créez un service LoadBalancer externe IPv6 à pile unique sur un cluster IPv6 à pile unique ou un cluster à double pile, le sous-réseau utilisé par l'équilibreur de charge dépend du type d'accès IPv6 (EXTERNAL ou INTERNAL) utilisé par le sous-réseau de nœud de votre cluster. Sur un cluster double pile, vous devez définir la valeur du champ spec.ipFamilyPolicy sur SingleStack et celle du champ spec.ipFamilies sur IPv6 (sur un cluster IPv6 à pile unique, il s'agit des valeurs par défaut, que vous pouvez omettre). Les services LoadBalancer externes IPv6 utilisent toujours un équilibreur de charge réseau passthrough externe régional basé sur un service de backend au niveau Premium. Les exemples suivants définissent explicitement le champ spec.loadBalancerClass sur networking.gke.io/l4-regional-external, bien que cette variante d'équilibreur de charge soit la valeur par défaut dans GKE 1.37 et versions ultérieures :

  • Clusters avec des nœuds externes (type d'accès GUA EXTERNAL) : si vos nœuds de cluster s'exécutent sur un sous-réseau externe avec des adresses unicast globales (GUA), l'équilibreur de charge externe utilise automatiquement le sous-réseau de nœud existant. Créez votre service sans annotations de sous-réseau personnalisé :

    apiVersion: v1
    kind: Service
    metadata:
      name: ext-ipv6-svc
    spec:
      type: LoadBalancer
      loadBalancerClass: networking.gke.io/l4-regional-external
      ipFamilyPolicy: SingleStack
      ipFamilies:
      - IPv6
      selector:
        app: store
      ports:
      - protocol: TCP
        port: 8080
        targetPort: 8080
    
  • Clusters avec des nœuds internes (type d'accès ULA INTERNAL) : si les nœuds de votre cluster s'exécutent sur un sous-réseau interne avec des adresses unicast locales uniques (ULA), un équilibreur de charge externe ne peut pas utiliser ce sous-réseau directement. Vous devez provisionner un sous-réseau IPv6 externe (EXTERNAL) dédié et le référencer à l'aide de l'annotation networking.gke.io/load-balancer-subnet sur votre service :

    1. Créez un sous-réseau IPv6 externe dédié :

      gcloud compute networks subnets create SUBNET_NAME \
          --stack-type=ipv6_only \
          --ipv6-access-type=EXTERNAL \
          --network=NETWORK_NAME \
          --region=COMPUTE_REGION
      

      Remplacez les éléments suivants :

      • SUBNET_NAME : nom du sous-réseau à créer.
      • NETWORK_NAME : nom du réseau VPC dans lequel vous créez ce sous-réseau.
      • COMPUTE_REGION : région Compute Engine du sous-réseau.
    2. Créez le service en référençant le nom de votre sous-réseau dédié dans l'annotation networking.gke.io/load-balancer-subnet :

      apiVersion: v1
      kind: Service
      metadata:
        name: ext-ipv6-svc
        annotations:
          networking.gke.io/load-balancer-subnet: SUBNET_NAME
      spec:
        type: LoadBalancer
        loadBalancerClass: networking.gke.io/l4-regional-external
        ipFamilyPolicy: SingleStack
        ipFamilies:
        - IPv6
        selector:
          app: store
        ports:
        - protocol: TCP
          port: 8080
          targetPort: 8080
      
  1. Vérifiez l'adresse IP du service attribuée :

    kubectl get svc ext-ipv6-svc
    

    Le résultat confirme que les colonnes CLUSTER-IP et EXTERNAL-IP (une adresse GUA publique) sont renseignées :

    NAME           TYPE           CLUSTER-IP                          EXTERNAL-IP                      PORT(S)        AGE
    ext-ipv6-svc   LoadBalancer   2600:2d00:0:4:1a1e:d3b3:de4d:c401   2600:1900:4000:2714:8000:0:0:0   80:31114/TCP   51s
    

Pour en savoir plus, consultez Services LoadBalancer IPv6.

Utiliser des adresses BYOIPv6 (Bring Your Own IPv6)

Dans GKE 1.37.1-gke.2097000 et versions ultérieures, vous pouvez configurer un service LoadBalancer externe IPv6 à pile unique pour utiliser vos propres adresses IPv6 (BYOIPv6) à partir d'un sous-préfixe IPv6 régional d'un préfixe délégué public (PDP) en mode EXTERNAL_IPV6_FORWARDING_RULE_CREATION.

Avant de créer le service, assurez-vous de remplir les conditions suivantes :

  • Votre cluster exécute GKE version 1.37.1-gke.2097000 ou ultérieure. Le cluster peut être à pile unique IPv6 ou à double pile (le service doit être à pile unique IPv6 dans les deux cas), et le sous-réseau du cluster peut avoir un type d'accès IPv6 INTERNAL ou EXTERNAL. Une plage de sous-réseau IPv6 externe n'est pas requise, car la plage d'adresses provient du préfixe délégué public.
  • Vous disposez d'un sous-préfixe IPv6 régional en mode EXTERNAL_IPV6_FORWARDING_RULE_CREATION avec une longueur de préfixe attribuable de /96 et l'état ANNOUNCED, dans la même région que votre cluster. Pour obtenir des instructions, consultez Créer des sous-préfixes IPv6.
  • L'agent de service GKE (service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com) dispose du rôle d'administrateur d'adresses IP publiques Compute (roles/compute.publicIpAdmin) sur le projet propriétaire du préfixe délégué public. Pour attribuer le rôle, exécutez la commande suivante :

    gcloud projects add-iam-policy-binding PDP_PROJECT_ID \
        --member="serviceAccount:service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com" \
        --role="roles/compute.publicIpAdmin"
    

    Remplacez les éléments suivants :

    • PDP_PROJECT_ID : ID du projet propriétaire du préfixe public délégué.
    • PROJECT_NUMBER : numéro du projet contenant votre cluster.
  • Le service est un service IPv6 à pile unique (spec.ipFamilyPolicy: SingleStack et spec.ipFamilies: ["IPv6"]) qui définit le champ spec.loadBalancerClass sur networking.gke.io/l4-regional-external et utilise le niveau Premium. Les services à double pile, les services IPv4 et le niveau Standard ne sont pas compatibles avec BYOIPv6.

  • Le service n'inclut pas l'annotation networking.gke.io/load-balancer-subnet, qui ne peut pas être combinée avec l'annotation networking.gke.io/ip-collection-v6.

Choisissez d'allouer une plage d'adresses BYOIPv6 externes éphémères ou d'utiliser une plage d'adresses BYOIPv6 externes statiques réservées :

  • Plage d'adresses BYOIPv6 externes éphémères : ajoutez l'annotation networking.gke.io/ip-collection-v6 à votre fichier manifeste de service et définissez-la sur l'URL complète de la ressource ou le chemin d'accès partiel de la ressource de votre sous-préfixe régional :

    apiVersion: v1
    kind: Service
    metadata:
      name: ext-byoipv6-svc
      annotations:
        networking.gke.io/ip-collection-v6: "projects/PROJECT_ID/regions/REGION/publicDelegatedPrefixes/SUB_PREFIX_NAME"
    spec:
      type: LoadBalancer
      loadBalancerClass: networking.gke.io/l4-regional-external
      ipFamilyPolicy: SingleStack
      ipFamilies:
      - IPv6
      selector:
        app: store
      ports:
      - name: tcp-port
        protocol: TCP
        port: 80
        targetPort: 8080
    

    Remplacez les éléments suivants :

    • PROJECT_ID : ID du projet contenant le sous-préfixe.
    • REGION : région de votre cluster.
    • SUB_PREFIX_NAME : nom de votre sous-préfixe régional en mode EXTERNAL_IPV6_FORWARDING_RULE_CREATION.

    Si vous modifiez ultérieurement l'annotation networking.gke.io/ip-collection-v6, GKE recrée la règle de transfert IPv6 avec une nouvelle adresse du nouveau préfixe, ce qui perturbe brièvement le trafic vers le service. Si vous supprimez l'annotation, le service revient à une adresse fournie par Google à partir d'un sous-réseau avec une plage IPv6 externe. Si le sous-réseau de votre cluster comporte une plage IPv6 interne, ajoutez l'annotation networking.gke.io/load-balancer-subnet en même temps.

  • Plage d'adresses BYOIPv6 externes statiques : réservez une plage d'adresses IPv6 /96 externes statiques régionales à partir du sous-préfixe et référencez-la à l'aide de l'annotation networking.gke.io/load-balancer-ip-addresses :

    1. Créez une plage d'adresses IPv6 externes statiques régionales à partir de votre sous-préfixe :

      gcloud compute addresses create STATIC_BYOIPV6_NAME \
          --region=REGION \
          --ip-version=IPV6 \
          --endpoint-type=NETLB \
          --ip-collection=projects/PROJECT_ID/regions/REGION/publicDelegatedPrefixes/SUB_PREFIX_NAME
      

      Remplacez les éléments suivants :

      • STATIC_BYOIPV6_NAME : nom de la ressource d'adresse IPv6 statique.
      • REGION : région de votre cluster.
      • PROJECT_ID : ID du projet contenant le sous-préfixe.
      • SUB_PREFIX_NAME : nom de votre sous-préfixe régional en mode EXTERNAL_IPV6_FORWARDING_RULE_CREATION.

      L'annotation networking.gke.io/ip-collection-v6 est facultative lorsque vous utilisez une plage d'adresses BYOIPv6 externe statique. Si vous définissez cette annotation, elle doit faire référence au même sous-préfixe que celui à partir duquel vous avez réservé la plage d'adresses.

    2. Référencez le nom de ressource de l'adresse IPv6 statique réservée dans votre fichier manifeste de service :

      apiVersion: v1
      kind: Service
      metadata:
        name: ext-static-byoipv6-svc
        annotations:
          networking.gke.io/load-balancer-ip-addresses: STATIC_BYOIPV6_NAME
      spec:
        type: LoadBalancer
        loadBalancerClass: networking.gke.io/l4-regional-external
        ipFamilyPolicy: SingleStack
        ipFamilies:
        - IPv6
        selector:
          app: store
        ports:
        - name: tcp-port
          protocol: TCP
          port: 80
          targetPort: 8080
      

Pour en savoir plus, consultez Utiliser vos propres adresses IPv6 (BYOIPv6).

Activer l'équilibrage de charge pondéré

Pour répartir 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 du service store-v1-lb-svc.yaml et assurez-vous de définir également la valeur externalTrafficPolicy: Local de sorte qu'elle ressemble à ceci :

    apiVersion: v1
    kind: Service
    metadata:
      name: store-v1-lb-svc
      annotations:
        networking.gke.io/weighted-load-balancing: "pods-per-node"
    spec:
      type: LoadBalancer
      loadBalancerClass: networking.gke.io/l4-regional-external
      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 le traitement des paquets, 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 l'équilibrage de charge pondéré, car le paquet peut être acheminé, après l'équilibreur de charge, vers un autre nœud.

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 du service de l'équilibreur de charge existant dans l'éditeur de texte que vous avez configuré. Vous pouvez alors 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'un équilibreur de charge réseau passthrough externe régional basé sur un service de backend. Pour les clusters exécutant des versions de GKE antérieures à la version 1.37, cette exigence signifie que le service LoadBalancer externe existant doit avoir le champ spec.loadBalancerClass défini sur networking.gke.io/l4-regional-external 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 régional basé sur un pool cible n'a aucun effet.

  • Lorsque vous mettez à jour le fichier manifeste du service LoadBalancer externe existant, veillez à définir la valeur externalTrafficPolicy: Local. L'utilisation de externalTrafficPolicy: Cluster désactive 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.

Activer la journalisation pour les services de backend

Vous pouvez activer, désactiver et afficher les journaux d'un équilibreur de charge réseau passthrough externe régional basé sur un service de backend.

Vous configurez Cloud Logging en créant une ressource personnalisée L4LBConfig qui spécifie vos paramètres de journalisation. La ressource L4LBConfig est associée à un service Kubernetes dans le fichier manifeste du service. Une fois le fichier manifeste appliqué, le contrôleur GKE configure la journalisation pour le service de backend. Si vous n'associez pas de ressource L4LBConfig au service, le contrôleur cesse de gérer la configuration de journalisation et laisse le service de backend dans son dernier état connu. Pour en savoir plus, consultez Comprendre le comportement de la roue libre.

Vous pouvez configurer les champs suivants :

  • enabled : si la valeur est définie sur true, active la journalisation pour ce service. Les journaux sont disponibles dans Cloud Logging. Sinon, la journalisation est désactivée pour ce service.
  • sampleRate : spécifie une valeur comprise entre 0 et 1,000,000 (par défaut), où 0 signifie qu'aucun paquet n'est enregistré et 1,000,000 signifie que 100 % des paquets sont enregistrés. Le champ sampleRate est facultatif et n'est pertinent que si la valeur du champ enable est définie sur true.
  • optionalMode : contrôle les champs de métadonnées facultatifs inclus dans les journaux générés pour l'équilibreur de charge. Le champ accepte l'une des valeurs de chaîne suivantes :
    • EXCLUDE_ALL_OPTIONAL : paramètre par défaut si optionalMode n'est pas spécifié. Lorsque cette option est définie, aucun champ facultatif n'est inclus dans les journaux, ce qui fournit le format de journal le plus concis.
    • INCLUDE_ALL_OPTIONAL : active la journalisation pour tous les champs facultatifs disponibles, ce qui fournit les entrées de journal les plus détaillées.
    • CUSTOM : spécifie une liste personnalisée de champs facultatifs inclus dans les journaux. Avec le mode CUSTOM, vous devez également utiliser le paramètre optionalFields pour fournir une liste d'éléments séparés par une virgule des champs que vous souhaitez.
  • optionalFields : chaîne de noms de champs séparés par une virgule. Définit les champs de métadonnées facultatifs exacts que vous souhaitez inclure dans les journaux générés. Ce champ n'est utilisé que lorsque optionalMode est défini sur CUSTOM. Sinon, toutes les valeurs sont ignorées.

Pour configurer Cloud Logging, créez la ressource L4LBConfig dans le même espace de noms que votre ressource Service. L'exemple de fichier manifeste L4LBConfig suivant active Cloud Logging et définit le taux d'échantillonnage sur 50 % des requêtes pour un service d'équilibreur de charge donné.

  1. Enregistrez le manifeste suivant sous le nom svc-l4lb-config.yaml :

    apiVersion: networking.gke.io/v1
    kind: L4LBConfig
    metadata:
      name: svc-l4lb-config
      namespace: default
    spec:
      logging:
        enabled: true # must be included
        sampleRate: 500000
        optionalMode: "INCLUDE_ALL_OPTIONAL"
    
  2. Appliquez le fichier manifeste L4LBConfig à votre cluster :

    kubectl apply -f svc-l4lb-config.yaml
    
  3. Ajoutez l'annotation networking.gke.io/l4lb-config au fichier manifeste du service store-v1-lb-svc.yaml :

    apiVersion: v1
    kind: Service
    metadata:
      name: store-v1-lb-svc
      annotations:
        cloud.google.com/l4-rbs: "enabled"
        networking.gke.io/l4lb-config: "svc-l4lb-config"
    spec:
      type: LoadBalancer
      selector:
        app: store
      ports:
        - name: tcp-port
          protocol: TCP
          port: 8080
          targetPort: 8080
    
  4. Appliquez le fichier manifeste Service à votre cluster :

    kubectl apply -f store-v1-lb-svc.yaml
    

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 régional.

  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 régional.
    • PORT : numéro de port alloué pour l'équilibreur de charge réseau passthrough externe régional.

    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:                     store-v1-lb-svc
    Namespace:                default
    Labels:                   <none>
    Annotations:              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=store
    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 régional basé sur un service de backend et ses ressources Google Cloud 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 de 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 de l'é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 lorsque le fichier manifeste a été appliqué au cluster.
        • Le champ spec.loadBalancerClass défini sur la valeur networking.gke.io/l4-regional-external était présent dans le fichier manifeste du 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 Google Cloud contenant le cluster. 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 Google Cloud contenant le cluster. 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 de l'état est fourni par l'annotation en lecture seule service.kubernetes.io/healthcheck. Pour vérifier cette annotation en lecture seule, exécutez la commande kubectl describe svc SERVICE_NAME.
      • REGION_NAME : région Google Cloud contenant le cluster. 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 des 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 où se trouve le cluster.
      • ZONE_NAME : Google Cloud zone contenant le NEG.
  5. Vérifiez que Cloud Logging a été activé pour le service de backend :

    kubectl get svc SERVICE_NAME --output yaml
    

    Remplacez les éléments suivants :

    • SERVICE_NAME : nom du service de backend.

    Dans le résultat, assurez-vous que le champ Status.Conditions contient Type: LoggingConfigManaged et Reason: Reconciled.

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 créent des équilibreurs de charge réseau passthrough externes régionaux basés sur un service de backend s'ils sont créés dans GKE 1.37 ou version ultérieure, spécifient la valeur networking.gke.io/l4-regional-external pour le champ spec.loadBalancerClass ou incluent l'annotation cloud.google.com/l4-rbs: "enabled". Selon la version de GKE du cluster, GKE utilise des groupes de points de terminaison du réseau GCE_VM_IP ou des groupes d'instances non gérés comme backends :

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

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

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

Vous pouvez créer un service LoadBalancer externe optimisé par un équilibreur de charge réseau passthrough externe régional 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 régional basé sur un service de backend avec des backends de groupe d'instances
  • Un équilibreur de charge réseau passthrough externe régional basé sur un pool cible

Pour conserver une adresse IPv4 externe lorsque vous passez à un équilibreur de charge réseau passthrough externe régional basé sur un service de backend qui utilise des backends NEG GCE_VM_IP (les services LoadBalancer externes IPv6 ne nécessitent pas cette migration) :

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

  2. Identifiez le service LoadBalancer externe que vous souhaitez basculer vers un équilibreur de charge réseau passthrough externe régional 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 le résultat de la commande, notez l'adresse IPv4 externe de l'équilibreur de charge indiquée après LoadBalancer Ingress.

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

    • Il est préférable de disposer du fichier manifeste du service d'origine que vous avez appliqué au cluster par le passé. Par exemple, vous pouvez l'avoir dans un dépôt de contrôle de code source.

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

      • Exécutez la commande suivante pour obtenir une copie YAML du fichier manifeste du service qui représente 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 :
          • L'annotation kubectl.kubernetes.io/last-applied-configuration
          • Toutes les annotations commençant par service.kubernetes.io
        • creationTimestamp
        • finalizers
        • resourceVersion
        • uid
    • Assurez-vous que le fichier manifeste inclut le champ spec.loadBalancerClass défini sur la valeur networking.gke.io/l4-regional-external. Si vous effectuez une migration à partir d'un équilibreur de charge réseau passthrough externe régional basé sur un pool cible, vous devez ajouter le champ.

    Enregistrez le fichier manifeste et notez l'emplacement où vous l'avez enregistré. Le reste de cette procédure fait référence au chemin d'accès où vous avez enregistré le fichier manifeste sous le nom 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 bien é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 du service MANIFEST_FILE_PATH :

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

    Pour en savoir plus sur cette annotation, consultez 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 les problèmes que vous pouvez rencontrer lorsque vous configurez un service LoadBalancer externe basé sur un service de backend.

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

Si vous ne définissez pas la valeur 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 la valeur externalTrafficPolicy: Local.

Erreur lors de la création d'un équilibreur de charge IPv6 au niveau Standard

Si un service LoadBalancer externe IPv6 affiche un événement SyncExternalLoadBalancerFailed avec le message Network tier Standard is not supported for IPv6 External Load Balancer, supprimez l'annotation cloud.google.com/network-tier: Standard du fichier manifeste du service. Les services LoadBalancer externes IPv6 ne sont compatibles qu'avec le niveau Premium.

Erreurs lors de la configuration de l'utilisation de vos propres adresses IPv6 (BYOIPv6)

Lorsque vous configurez l'utilisation de vos propres adresses IPv6 (BYOIPv6) pour un service LoadBalancer externe, vous pouvez voir des événements d'avertissement SyncExternalLoadBalancerFailed lorsque vous exécutez la commande kubectl describe service SERVICE_NAME. Le message d'événement commence par Error ensuring Resource for L4 External LoadBalancer, err:, suivi de l'une des erreurs suivantes :

  • networking.gke.io/ip-collection-v6 is currently only supported for IPv6-only Services : assurez-vous que votre fichier manifeste de service spécifie spec.ipFamilyPolicy: SingleStack et spec.ipFamilies: ["IPv6"].
  • static IPv6 address "ADDRESS_NAME" is a BYOIP address from IP collection "SUB_PREFIX", which is currently only supported for IPv6-only Services : assurez-vous que votre fichier manifeste de service spécifie spec.ipFamilyPolicy: SingleStack et spec.ipFamilies: ["IPv6"]. Cette erreur indique que le service est à double pile ou IPv4, mais qu'il fait référence à une adresse BYOIPv6 statique.
  • cannot specify both networking.gke.io/load-balancer-subnet ("SUBNET") and networking.gke.io/ip-collection-v6 ("SUB_PREFIX") for LoadBalancer : supprimez l'annotation networking.gke.io/load-balancer-subnet du fichier manifeste Service lorsque vous utilisez l'annotation networking.gke.io/ip-collection-v6 .
  • invalid networking.gke.io/ip-collection-v6 "VALUE": expected projects/PROJECT/regions/REGION/publicDelegatedPrefixes/NAME ou invalid networking.gke.io/ip-collection-v6 "VALUE": the public delegated prefix must be in the cluster region REGION : définissez l'annotation sur l'URL complète de la ressource ou sur le chemin d'accès partiel de la ressource (projects/PROJECT_ID/regions/REGION/publicDelegatedPrefixes/SUB_PREFIX_NAME) d'un sous-préfixe dans la même région que votre cluster. Un nom de sous-préfixe brut n'est pas accepté.
  • reserved address ("ADDRESS_NAME") is not valid, err: ipCollection mismatch, expected "SUB_PREFIX_A", actual: "SUB_PREFIX_B" : assurez-vous que l'annotation networking.gke.io/ip-collection-v6 correspond au préfixe délégué public que vous avez utilisé pour réserver l'adresse IPv6 statique, ou omettez l'annotation networking.gke.io/ip-collection-v6 lorsque vous utilisez l'annotation networking.gke.io/load-balancer-ip-addresses.
  • googleapi: Error 403: Required 'compute.publicDelegatedPrefixes.use' permission for 'SUB_PREFIX', forbidden : accordez le rôle Administrateur d'adresses IP publiques Compute (roles/compute.publicIpAdmin) à l'agent de service GKE (service-PROJECT_NUMBER@container-engine-robot.iam.gserviceaccount.com) sur le projet propriétaire du préfixe délégué public. GKE a besoin de cette autorisation chaque fois qu'il synchronise le service. Ne supprimez donc pas le rôle après la création du service par GKE.

Étapes suivantes