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

Autopilot Standard

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, vous devez connaître les concepts suivants :

Équilibreur de charge réseau passthrough externe basé sur un service de backend

En tant qu'administrateur de cluster, vous pouvez créer un Service LoadBalancer externe afin que les clients extérieurs au cluster puissent envoyer des paquets aux pods du service. Le schéma suivant illustre deux équilibreurs de charge réseau passthrough externes basés sur un service de backend, créés pour deux services LoadBalancer externes (store-v1-lb-svc et store-v2-lb-svc). Les deux équilibreurs de charge distribuent les paquets aux nœuds du cluster, et les nœuds acheminent les paquets vers les pods de diffusion.

Services LoadBalancer externes fournis par des équilibreurs de charge réseau passthrough externes basés sur un service de backend régional

Ce guide vous explique comment configurer un service LoadBalancer externe nommé store-v1-lb-svc en suivant ces étapes :

Créez un cluster avec le module complémentaire HttpLoadBalancing activé.
Créez un service qui inclut l'annotation cloud.google.com/l4-rbs. Cette annotation indique à GKE de créer un équilibreur de charge réseau passthrough externe basé sur un service de backend qui utilise un service de backend régional.
Vérifiez que l'équilibreur de charge transmet correctement les paquets aux pods du service store-v1-lb-svc. Vérifiez également que GKE a créé les composants de l'équilibreur de charge réseau passthrough externe basé sur un service de backend :
- Règle de transfert
- Service de backend régional
- Groupe d'instances
- Vérification d'état
- Règles de pare-feu VPC
Supprimez le service LoadBalancer externe store-v1-lb-svc.

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.

Configurer votre cluster

Créer un cluster

Utilisez gcloud CLI pour créer un cluster compatible avec la création d'équilibreurs de charge réseau passthrough externes basés sur un service de backend :

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, qui doit être 1.24.9 ou ultérieure.
COMPUTE_LOCATION : région Compute Engine du cluster.

Le module complémentaire HttpLoadBalancing est activé par défaut sur votre nouveau cluster. Ce module complémentaire est nécessaire pour que le plan de contrôle puisse créer et gérer des équilibreurs de charge réseau passthrough externes basés sur un service de backend.

Mettre à niveau un cluster existant

Utilisez gcloud CLI pour mettre à jour un cluster existant de manière à pouvoir prendre en charge la création d'équilibreurs de charge réseau passthrough externes basés sur un service de backend.

Mettez à niveau votre plan de contrôle vers GKE version 1.24.9 ou une version ultérieure :
```
gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION
```
Remplacez les éléments suivants :
- CLUSTER_NAME : nom du cluster
- VERSION : version de GKE, qui doit être 1.24.9 ou ultérieure. La version doit être une version mineure valide dans la version disponible de votre cluster. Pour en savoir plus, consultez la section Mettre à jour manuellement le plan de contrôle.
- COMPUTE_LOCATION : emplacement Compute Engine du nouveau cluster.

Créer 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: 2
  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 deux 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

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
  externalTrafficPolicy: Cluster
  selector:
    app: store
  ports:
  - name: tcp-port
    protocol: TCP
    port: 8080
    targetPort: 8080
```
Ce Service LoadBalancer externe utilise la externalTrafficPolicy par défaut de 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 utilisez un cluster à double pile IPv4/IPv6, ajoutez les éléments spec.ipFamilyPolicy et ipFamilies pour définir la façon dont GKE alloue les adresses IP au service. Tenez compte des conditions suivantes lorsque vous utilisez les spécifications ipFamilyPolicy et ipFamilies :
- Lorsque vous créez un équilibreur de charge réseau passthrough externe basé sur un service de backend, GKE ajoute automatiquement l'annotation cloud.google.com/l4-rbs aux nouveaux services créés sur les clusters IPv4/IPv6 à double pile. Toutefois, si vous ajoutez l'annotation cloud.google.com/l4-rbs: "enabled" aux fichiers manifestes de service existants, les services LoadBalancer qui existent déjà dans le cluster continuent d'utiliser des équilibreurs de charge réseau passthrough externes basés sur un pool cible, qui sont de type IPv4 seulement. Pour en savoir plus, consultez la section Regroupement de nœuds.
- GKE peut allouer des services LoadBalancer à pile unique (IPv4 seulement ou IPv6 seulement) ou à double pile. Un service LoadBalancer à double pile est mis en œuvre avec deux règles de transfert d'équilibreur de charge réseau passthrough externe distinctes : une pour gérer le trafic TCP sur IPv4 et une autre pour gérer le trafic TCP sur IPv6. Pour en savoir plus, consultez la section Services.
Appliquez le fichier manifeste au cluster :
```
kubectl apply -f store-v1-lb-svc.yaml
```
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érifier le Service LoadBalancer externe et ses composants

Vérifiez votre service LoadBalancer et son ensemble d'annotations décrivant ses ressources Google 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/l4-rbs: enabled
                          service.kubernetes.io/backend-service: k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
                          service.kubernetes.io/firewall-rule: k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
                          service.kubernetes.io/firewall-rule-for-hc: k8s2-c086604n-l4-shared-hc-fw
                          service.kubernetes.io/healthcheck: k8s2-c086604n-l4-shared-hc
                          service.kubernetes.io/tcp-forwarding-rule: a683373f85bfe433ba929a50ca8d72e2
Selector:                 app=store
Type:                     LoadBalancer
IP Family Policy:         SingleStack
IP Families:              IPv4
IP:                       10.44.196.160
IPs:                      10.44.196.160
LoadBalancer Ingress:     35.193.28.231
Port:                     tcp-port  8080/TCP
TargetPort:               8080/TCP
NodePort:                 tcp-port  32466/TCP
Endpoints:                10.48.0.5:8080,10.48.2.8:8080
Session Affinity:         None
External Traffic Policy:  Cluster
Events:
  Type    Reason                Age                   From                     Message
  ----    ------                ----                  ----                     -------
  Normal  ADD                   2m42s                 loadbalancer-controller  default/store-v1-lb-svc
  Normal  EnsuringLoadBalancer  102s (x2 over 2m42s)  service-controller       Ensuring load balancer
  Normal  Annotations           102s                  loadbalancer-controller  map[cloud.google.com/l4-rbs:enabled kubectl.kubernetes.io/last-applied-configuration:{"apiVersion":"v1","kind":"Service","metadata":{"annotations":
{"cloud.google.com/l4-rbs":"enabled"},"name":"store-v1-lb-svc","namespace":"default"}
,"spec":{"externalTrafficPolicy":"Cluster","ports":
[{"name":"tcp-port","port":8080,"protocol":"TCP","targetPort":8080}],
"selector":{"app":"store"},"type":"LoadBalancer"}}
] -> map[cloud.google.com/l4-rbs:enabled
kubectl.kubernetes.io/last-applied-configuration:{"apiVersion":"v1","kind":
"Service","metadata":{"annotations":{"cloud.google.com/l4-rbs":"enabled"},
"name":"store-v1-lb-svc","namespace":"default"},"spec":{"externalTrafficPolicy"
:"Cluster","ports":[{"name":"tcp-port","port":8080,"protocol":"TCP","targetPort"
:8080}],"selector":{"app":"store"},"type":"LoadBalancer"}}
service.kubernetes.io/backend-service:k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
service.kubernetes.io/firewall-rule:k8s2-c086604n-default-store-v1-lb-svc-aip4ty1x
service.kubernetes.io/firewall-rule-for-hc:k8s2-c086604n-l4-shared-hc-fw
service.kubernetes.io/healthcheck:k8s2-c086604n-l4-shared-hc
service.kubernetes.io/tcp-forwarding-rule:a683373f85bfe433ba929a50ca8d72e2]
Normal  SyncLoadBalancerSuccessful  16s (x3 over 102s)  loadbalancer-controller  Successfully ensured L4 External LoadBalancer resources

Plusieurs champs indiquent qu'un équilibreur de charge réseau passthrough externe 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 ressource Google Cloud créée comme partie intégrante de l'équilibreur de charge ou pour assurer sa compatibilité.
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 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 d'é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.

Supprimer le Service LoadBalancer externe et ses composants

Supprimez le Service LoadBalancer externe store-v1-lb-svc.

kubectl delete service store-v1-lb-svc

GKE supprime les ressources suivantes :

La règle de transfert de l'équilibreur de charge.
Le service de backend de l'équilibreur de charge.
La vérification de l'état de l'équilibreur de charge.
Les règles de pare-feu VPC nécessaires pour l'équilibreur de charge et son trafic de vérification d'état.
Les backends de groupes d'instances zonaux non gérés, uniquement si GKE n'a pas besoin de les utiliser comme backends pour d'autres équilibreurs de charge créés par le cluster.

Étapes suivantes

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.