Équilibrage de charge natif en conteneurs via Ingress

Autopilot Standard

Cette page explique comment utiliser l'équilibrage de charge natif en conteneurs dans Google Kubernetes Engine (GKE). L'équilibrage de charge natif en conteneurs permet aux équilibreurs de charge de cibler directement les pods Kubernetes et de répartir le trafic de manière homogène entre ceux-ci.

Pour en savoir plus sur les avantages, les exigences et les limites de l'équilibrage de charge natif en conteneurs, consultez la page Équilibrage de charge natif en conteneurs.

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

• Assurez-vous de disposer d'un cluster de VPC natif existant. Si nécessaire, créez un cluster. Les clusters GKE sont de VPC natif par défaut.

Utiliser l'équilibrage de charge natif en conteneurs

Les sections suivantes présentent les étapes de configuration de l'équilibrage de charge natif en conteneurs sur GKE.

Créer un déploiement

L'exemple de déploiement suivant, neg-demo-app, exécute une seule instance d'un serveur HTTP conteneurisé. Nous vous recommandons d'utiliser des charges de travail qui font appel au retour d'informations via la disponibilité des pods.

Utiliser le retour d'informations via la disponibilité des pods

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: neg-demo-app # Label for the Deployment
  name: neg-demo-app # Name of Deployment
spec:
  selector:
    matchLabels:
      run: neg-demo-app
  template: # Pod template
    metadata:
      labels:
        run: neg-demo-app # Labels Pods from this Deployment
    spec: # Pod specification; each Pod created by this Deployment has this specification
      containers:
      - image: registry.k8s.io/serve_hostname:v1.4 # Application to run in Deployment's Pods
        name: hostname # Container name
        ports:
        - containerPort: 9376
          protocol: TCP
  

Utiliser un délai codé en dur

apiVersion: apps/v1
kind: Deployment
metadata:
  labels:
    run: neg-demo-app # Label for the Deployment
  name: neg-demo-app # Name of Deployment
spec:
  minReadySeconds: 60 # Number of seconds to wait after a Pod is created and its status is Ready
  selector:
    matchLabels:
      run: neg-demo-app
  template: # Pod template
    metadata:
      labels:
        run: neg-demo-app # Labels Pods from this Deployment
    spec: # Pod specification; each Pod created by this Deployment has this specification
      containers:
      - image: registry.k8s.io/serve_hostname:v1.4 # Application to run in Deployment's Pods
        name: hostname # Container name
      # Note: The following line is necessary only on clusters running GKE v1.11 and lower.
      # For details, see https://cloud.google.com/kubernetes-engine/docs/how-to/container-native-load-balancing#align_rollouts
        ports:
        - containerPort: 9376
          protocol: TCP
      terminationGracePeriodSeconds: 60 # Number of seconds to wait for connections to terminate before shutting down Pods
  

Dans ce déploiement, chaque conteneur exécute un serveur HTTP. En réponse, le serveur HTTP renvoie le nom d'hôte du serveur d'applications (le nom du pod sur lequel le serveur est exécuté).

Enregistrez ce fichier manifeste sous le nom neg-demo-app.yaml, puis créez le déploiement :

kubectl apply -f neg-demo-app.yaml

Créer un service pour un équilibreur de charge natif en conteneurs

Après avoir créé un déploiement, vous devez regrouper ses pods dans un service.

L'exemple de service suivant, neg-demo-svc, cible le déploiement que vous avez créé dans la section précédente :

apiVersion: v1
kind: Service
metadata:
  name: neg-demo-svc # Name of Service
spec: # Service's specification
  type: ClusterIP
  selector:
    run: neg-demo-app # Selects Pods labelled run: neg-demo-app
  ports:
  - name: http
    port: 80 # Service's port
    protocol: TCP
    targetPort: 9376

Remarque : Le service est exposé sur le port 80 et redirige le trafic vers le port 9376, le targetPort. Le targetPort correspond à un containerPort dans un pod de diffusion. Il est également possible d'utiliser un service de type NodePort avec l'équilibrage de charge natif en conteneurs. Un service de type ClusterIP est recommandé, sauf si vous avez expressément besoin du nodePort fourni par un service NodePort. Les services LoadBalancer ne sont pas utilisables en tant que backends Ingress.

L'équilibreur de charge n'est pas créé tant que vous n'avez pas créé une entrée pour le service.

Enregistrez ce fichier manifeste sous le nom neg-demo-svc.yaml, puis créez le service :

kubectl apply -f neg-demo-svc.yaml

Créer un objet Ingress pour le service

L'exemple d'entrée suivant, neg-demo-ing, cible le service que vous avez créé :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: neg-demo-ing
spec:
  defaultBackend:
    service:
      name: neg-demo-svc # Name of the Service targeted by the Ingress
      port:
        number: 80 # Should match the port used by the Service

Enregistrez ce fichier manifeste sous le nom neg-demo-ing.yaml, puis créez l'objet Ingress :

kubectl apply -f neg-demo-ing.yaml

La création de cette entrée entraîne celle d'un équilibreur de charge d'application au sein du projet ainsi que celle d'un groupe de points de terminaison réseau (NEG) dans chacune des zones où le cluster est exécuté. Les points de terminaison des NEG et ceux du service sont synchronisés.

Vérifier l'objet Ingress

Après avoir déployé une charge de travail, regroupé ses pods dans un service et créé une entrée pour le service, vous devez vérifier que l'entrée a correctement provisionné l'équilibreur de charge natif en conteneurs.

Récupérez l'état de l'objet Ingress :

kubectl describe ingress neg-demo-ing

Le résultat inclut les événements ADD et CREATE :

Events:
Type     Reason   Age                From                     Message
----     ------   ----               ----                     -------
Normal   ADD      16m                loadbalancer-controller  default/neg-demo-ing
Normal   Service  4s                 loadbalancer-controller  default backend set to neg-demo-svc:32524
Normal   CREATE   2s                 loadbalancer-controller  ip: 192.0.2.0

Tester l'équilibreur de charge

Dans les sections suivantes, nous expliquons comment tester le fonctionnement d'un équilibreur de charge natif en conteneurs.

Accéder à l'adresse IP de l'entrée

Attendez plusieurs minutes que l'équilibreur de charge d'application soit configuré.

Vous pouvez vérifier le fonctionnement de l'équilibreur de charge natif en conteneurs en accédant à l'adresse IP de l'entrée.

Pour obtenir l'adresse IP de l'entrée, exécutez la commande suivante :

kubectl get ingress neg-demo-ing

Dans le résultat de la commande, l'adresse IP de l'entrée est affichée dans la colonne ADDRESS. Accédez à l'adresse IP dans un navigateur Web.

Vérifier l'état de santé du service de backend

Vous pouvez également vérifier l'état de santé du service de backend de l'équilibreur de charge.

1. Obtenez la liste des services de backend qui s'exécutent dans votre projet :

   gcloud compute backend-services list
   

   Enregistrez le nom du service de backend qui inclut le nom du Service (par exemple neg-demo-svc).

2. Obtenez l'état de santé du service de backend :

   gcloud compute backend-services get-health BACKEND_SERVICE_NAME --global
   

   Remplacez BACKEND_SERVICE_NAME par le nom du service de backend.

Tester l'objet Ingress

Un autre moyen vous permet de vérifier que l'équilibreur de charge fonctionne : effectuer un scaling de l'exemple de déploiement, envoyer des requêtes test à l'entrée et vérifier que le bon nombre d'instances dupliquées répond.

1. Effectuez le scaling du déploiement neg-demo-app d'une instance à deux instances :

   kubectl scale deployment neg-demo-app --replicas 2
   

   Cette commande peut prendre plusieurs minutes.

2. Vérifiez que le déploiement est terminé :

   kubectl get deployment neg-demo-app
   

   Le résultat doit inclure deux instances dupliquées disponibles :

   NAME           DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
   neg-demo-app   2         2         2            2           26m
   

3. Récupérez l'adresse IP de l'objet Ingress :

   kubectl describe ingress neg-demo-ing
   

   Si cette commande renvoie une erreur 404, attendez quelques minutes que l'équilibreur de charge démarre, puis réessayez.

4. Comptez le nombre de réponses distinctes de l'équilibreur de charge :

   for i in `seq 1 100`; do \
     curl --connect-timeout 1 -s IP_ADDRESS && echo; \
   done  | sort | uniq -c
   

   Remplacez IP_ADDRESS par l'adresse IP d'entrée.

   Le résultat ressemble à ce qui suit :

   44 neg-demo-app-7f7dfd7bc6-dcn95
   56 neg-demo-app-7f7dfd7bc6-jrmzf
   

   Dans ce résultat, le nombre de réponses distinctes est identique au nombre d'instances dupliquées, ce qui indique que tous les pods backend diffusent du trafic.

Effectuer un nettoyage

Une fois les tâches de cette page terminées, procédez comme suit pour supprimer les ressources afin d'éviter que des frais inutiles ne vous soient facturés sur votre compte :

Supprimer le cluster

gcloud

gcloud container clusters delete neg-demo-cluster

Console

1. Accédez à la page Google Kubernetes Engine dans la console Google Cloud .

   Accéder à Google Kubernetes Engine

2. Sélectionnez neg-demo-cluster, puis cliquez sur Supprimer.

3. Lorsque vous êtes invité à confirmer votre choix, cliquez sur Supprimer.

Étapes suivantes

• Découvrez comment utiliser l'équilibrage de charge natif en conteneurs via des NEG zonaux autonomes.
• Documentez-vous plus avant sur les clusters de VPC natif.
• En savoir plus sur la configuration d'entrée
• Découvrez comment utiliser des certificats SSL gérés par Google.