Configurer un équilibreur de charge d'application externe avec Ingress

Déployer une application Web

Le fichier manifeste suivant décrit un déploiement qui exécute l'exemple d'image de conteneur d'application Web sur un serveur HTTP sur le port 8080 :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web
  namespace: default
spec:
  selector:
    matchLabels:
      run: web
  template:
    metadata:
      labels:
        run: web
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:1.0
        imagePullPolicy: IfNotPresent
        name: web
        ports:
        - containerPort: 8080
          protocol: TCP

Appliquez la ressource au cluster :

kubectl apply -f web-deployment.yaml

Exposer votre déploiement dans votre cluster

Le fichier manifeste suivant décrit un service qui rend le déploiement web accessible depuis votre cluster de conteneurs :

apiVersion: v1
kind: Service
metadata:
  name: web
  namespace: default
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    run: web
  type: NodePort

1. Appliquez la ressource au cluster :

   kubectl apply -f web-service.yaml
   

   Lorsque vous créez un service de type NodePort avec cette commande, GKE le lance sur un port aléatoire élevé (par exemple, 32640), et ce, sur tous les nœuds du cluster.

2. Vérifiez que le service est créé et qu'un port de nœud est attribué :

   kubectl get service web
   

   Résultat :

   NAME      TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)          AGE
   web       NodePort   10.35.245.219   <none>        8080:32640/TCP   5m
   

   Dans l'exemple de résultat ci-dessus, le port de nœud du service web est 32640. Notez également qu’aucune adresse IP externe n’est attribuée à ce service. Les nœuds GKE n'étant pas accessibles en externe par défaut, la création de ce service ne rend pas votre application accessible depuis Internet.

Pour rendre votre application de serveur Web HTTP(S) publiquement accessible, vous devez créer une ressource Ingress.

Créer une ressource Ingress

Un ressource Ingress est une ressource Kubernetes qui regroupe tout un ensemble de règles et de configurations servant à rediriger le trafic HTTP(S) externe vers des services internes.

Sur GKE, la ressource Entrée est intégrée à l'aide de Cloud Load Balancing. Lorsque vous créez une ressource Ingress dans votre cluster, GKE crée un équilibreur de charge HTTP(S) et le configure pour acheminer le trafic vers votre application.

Le fichier manifeste suivant décrit une ressource Ingress qui dirige le trafic vers votre service web :

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: basic-ingress
spec:
  defaultBackend:
    service:
      name: web
      port:
        number: 8080

Appliquez la ressource au cluster :

kubectl apply -f basic-ingress.yaml

Lorsque vous déployez ce fichier manifeste, Kubernetes crée une ressource Ingress sur votre cluster. Le contrôleur d'entrée GKE crée et configure un équilibreur de charge HTTP(S) en fonction des informations de la ressource Ingress, en acheminant tout le trafic HTTP externe (sur le port 80) vers le service NodePort web que vous avez exposé.

Accéder à votre application

Trouvez l'adresse IP externe de l'équilibreur de charge desservant votre application en exécutant la commande suivante :

kubectl get ingress basic-ingress

NAME            HOSTS     ADDRESS         PORTS     AGE
basic-ingress   *         203.0.113.12    80        2m

Ouvrez l'adresse IP externe de votre application dans un navigateur et affichez une réponse HTTP en texte brut comme suit :

Hello, world!
Version: 1.0.0
Hostname: web-6498765b79-fq5q5

Vous pouvez accéder à l'équilibrage de charge sur la console Google Cloud pour inspecter les ressources réseau créées par le contrôleur d'entrée GKE.

(Facultatif) Configurer une adresse IP statique

Lorsque vous exposez un serveur Web sur un nom de domaine, l'adresse IP externe d'une application doit être une adresse IP statique qui ne change pas.

Par défaut, GKE attribue des adresses IP externes éphémères aux applications HTTP exposées via une ressource Ingress. Les adresses éphémères sont susceptibles de changer. Si vous prévoyez d'exécuter votre application pendant une longue période, vous devez utiliser une adresse IP statique externe.

Notez qu'une fois que vous avez configuré une adresse IP statique pour la ressource Ingress, la suppression de cette dernière ne supprime pas l'adresse IP statique qui lui est associée. Assurez-vous d'effectuer un nettoyage des adresses IP statiques que vous avez configurées lorsque vous ne prévoyez plus de les réutiliser.

Pour configurer une adresse IP statique, procédez comme suit :

1. Réservez une adresse IP externe statique nommée web-static-ip :

   gcloud

   gcloud compute addresses create web-static-ip --global
   

   Config Connector

   Remarque : Cette étape nécessite Config Connector. Suivez les instructions d'installation pour l'installer sur votre cluster.

   apiVersion: compute.cnrm.cloud.google.com/v1beta1
   kind: ComputeAddress
   metadata:
     name: web-static-ip
   spec:
     location: global

   Pour déployer ce fichier manifeste, téléchargez-le sur votre ordinateur sous le nom "compute-address.yaml", puis exécutez la commande suivante :

   kubectl apply -f compute-address.yaml

2. Le fichier manifeste basic-ingress-static.yaml ajoute une annotation sur la ressource Ingress pour utiliser la ressource d'adresse IP statique nommée web-static-ip :

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: basic-ingress
     annotations:
       kubernetes.io/ingress.global-static-ip-name: "web-static-ip"
   spec:
     defaultBackend:
       service:
         name: web
         port:
           number: 8080

   Affichez le fichier manifeste :

   cat basic-ingress-static.yaml
   

3. Appliquez la ressource au cluster :

   kubectl apply -f basic-ingress-static.yaml
   

4. Vérifiez l'adresse IP externe :

   kubectl get ingress basic-ingress
   

   Attendez que l'adresse IP de votre application change pour utiliser l'adresse IP réservée de la ressource web-static-ip.

   La mise à jour de la ressource Ingress existante, la reconfiguration de l'équilibreur de charge et la propagation des règles d'équilibrage de charge dans le réseau mondial peuvent prendre quelques minutes. Une fois cette opération terminée, le GKE libère l'adresse IP éphémère précédemment attribuée à l'application.

(Facultatif) Diffuser plusieurs applications sur un équilibreur de charge

Vous pouvez exécuter plusieurs services sur un même équilibreur de charge et sur une adresse IP publique en configurant des règles de routage sur la ressource Ingress. En hébergeant plusieurs services sur la même ressource Ingress, vous évitez de créer des équilibreurs de charge supplémentaires (qui sont des ressources facturables) pour chaque service exposé à Internet.

Le fichier manifeste suivant décrit un déploiement avec la version 2.0 de la même application Web :

apiVersion: apps/v1
kind: Deployment
metadata:
  name: web2
  namespace: default
spec:
  selector:
    matchLabels:
      run: web2
  template:
    metadata:
      labels:
        run: web2
    spec:
      containers:
      - image: us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0
        imagePullPolicy: IfNotPresent
        name: web2
        ports:
        - containerPort: 8080
          protocol: TCP

Appliquez la ressource au cluster :

kubectl apply -f web-deployment-v2.yaml

Le fichier manifeste suivant décrit un service qui expose web2 en interne au cluster sur un service NodePort appelé web2 :

apiVersion: v1
kind: Service
metadata:
  name: web2
  namespace: default
spec:
  ports:
  - port: 8080
    protocol: TCP
    targetPort: 8080
  selector:
    run: web2
  type: NodePort

Appliquez la ressource au cluster :

kubectl apply -f web-service-v2.yaml

Le fichier manifeste suivant décrit une ressource Ingress qui :

• achemine les requêtes dont le chemin d'accès commence par /v2/ vers le service web2 ;
• achemine toutes les autres requêtes vers le service web.

apiVersion: networking.k8s.io/v1
kind: Ingress
metadata:
  name: fanout-ingress
spec:
  rules:
  - http:
      paths:
      - path: /*
        pathType: ImplementationSpecific
        backend:
          service:
            name: web
            port:
              number: 8080
      - path: /v2/*
        pathType: ImplementationSpecific
        backend:
          service:
            name: web2
            port:
              number: 8080

Appliquez la ressource au cluster :

kubectl create -f fanout-ingress.yaml

Une fois la ressource Ingress déployée, exécutez la commande kubectl get ingress fanout-ingress pour connaître l'adresse IP publique du cluster.

Accédez ensuite à l'adresse IP pour vérifier que les deux applications sont accessibles sur le même équilibreur de charge :

• Accédez à http://<IP_ADDRESS>/ et vérifiez que la réponse contient Version: 1.0.0 (la requête étant acheminée vers le service web).
• Accédez à http://<IP_ADDRESS>/v2/ et vérifiez que la réponse contient Version: 2.0.0 (la demande étant acheminée vers le service web2).

Le seul caractère générique accepté pour le champ path d'une entrée est l'astérisque (*). Le caractère * doit être placé immédiatement après une barre oblique (/) et doit être le dernier caractère du modèle. Par exemple, /*, /foo/* et /foo/bar/* sont des modèles valides, mais ce n'est pas le cas de *, /foo/bar* et /foo/*/bar.

Un modèle plus restrictif a priorité sur un modèle moins restrictif. Si vous avez à la fois /foo/* et /foo/bar/*, alors /foo/bar/bat est considéré comme correspondant à /foo/bar/*.

Pour plus d'informations sur les restrictions en matière de chemin d'accès et la correspondance de modèle, consultez la documentation relative aux mappages d'URL.

(Facultatif) Surveiller la disponibilité et la latence de votre service

Les tests de disponibilité de Google Cloud surveillent les applications par boîte noire et du point de vue de l'utilisateur, en déterminant la latence et la disponibilité entre plusieurs adresses IP externes et l'adresse IP de l'équilibreur de charge. En comparaison, les vérifications d'état de Google Cloud effectuent une vérification interne des adresses IP du pod afin de déterminer la disponibilité au niveau de l'instance. Ces vérifications sont complémentaires et offrent une vue globale de l'état de l'application.

Vous pouvez créer un test de disponibilité à l'aide de Google Cloud Console, de l'API Cloud Monitoring ou des bibliothèques clientes Cloud Monitoring. Pour en savoir plus, consultez la page Gérer les tests de disponibilité. Si vous souhaitez créer un test de disponibilité à l'aide de la console Google Cloud, procédez comme suit :

1. Accédez à la page Services et entrées de la console Google Cloud.

   Accéder à la page Services et entrées

2. Cliquez sur le nom du service pour lequel vous souhaitez créer un test de disponibilité.

3. Cliquez sur Create Uptime Check (Créer un test de disponibilité).

4. Dans le volet Créer un test de disponibilité, saisissez un titre pour le test de disponibilité, puis cliquez sur Suivant pour accéder aux paramètres Cible.

   Les champs Cible du test de disponibilité sont automatiquement renseignés à l'aide des informations de l'équilibreur de charge de service.

   Pour accéder à une documentation complète sur tous les champs d'un test de disponibilité, consultez la section Créer un test de disponibilité.

5. Cliquez sur Suivant pour accéder aux paramètres de validation de la réponse.

6. Cliquez sur Suivant pour accéder à la section Alertes et notifications.

   Pour surveiller un test de disponibilité, vous pouvez créer une règle d'alerte ou afficher le tableau de bord des tests de disponibilité. Les règles d'alerte vous permettent d'être averti par e-mail ou via un autre canal en cas d'échec de votre test de disponibilité. Pour obtenir des informations générales sur les règles d'alerte, consultez la page Présentation des alertes.

   .

7. Cliquez sur Créer.

Remarques

Par défaut, la ressource Ingress effectue une vérification de l'état périodique à l'aide de la requête GET sur le chemin / pour déterminer l'intégrité de l'application. Elle attend une réponse HTTP 200. Utilisez un chemin de vérification de l'état personnalisé pour vérifier un chemin différent ou attendre un code de réponse différent.

L'entrée peut être utilisée dans le cadre de cas d'utilisation plus avancés, par exemple :

• Hébergement virtuel basé sur le nom : vous pouvez utiliser la ressource Ingress afin de réutiliser l'équilibreur de charge pour plusieurs noms de domaine et sous-domaines, et pour exposer plusieurs services sur une adresse IP unique et un seul équilibreur de charge. Consultez les exemples de fan-out simple et d'hébergement virtuel basé sur le nom pour apprendre à configurer la ressource Ingress pour ces tâches.

• Terminaison HTTPS : vous pouvez configurer l'objet Ingress pour qu'elle mette fin au trafic HTTPS à l'aide de l'équilibreur de charge Google Cloud.

Lorsqu'une ressource Ingress est supprimée, le contrôleur GKE Ingress effectue un nettoyage automatique des ressources associées (à l'exception des adresses IP statiques réservées).