Présentation

Dans cet atelier, vous allez créer deux déploiements de pods et travailler avec trois types de services différents, y compris la ressource Ingress. Vous découvrirez également comment les services Kubernetes dans GKE sont associés aux équilibreurs de charge réseau Google Cloud.

Objectifs

Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :

• Observer le fonctionnement d'un DNS Kubernetes
• Définir plusieurs types de service (ClusterIP, NodePort, LoadBalancer) dans des fichiers manifestes ainsi que des sélecteurs de libellés (afin de lier des pods libellés et des déploiements), déployer ces services dans un cluster et tester leur connectivité
• Déployer une ressource Ingress qui lie des clients à deux services distincts en fonction du chemin d'URL saisi
• Vérifier que les services type=LoadBalancer disposent d'un équilibreur de charge réseau Google Cloud

Préparation

Accéder à Qwiklabs

Pour chaque atelier, nous vous attribuons un nouveau projet Google Cloud et un nouvel ensemble de ressources pour une durée déterminée, sans frais.

1. Connectez-vous à Qwiklabs dans une fenêtre de navigation privée.

2. Vérifiez le temps imparti pour l'atelier (par exemple : 01:15:00) : vous devez pouvoir le terminer dans ce délai.
   Une fois l'atelier lancé, vous ne pouvez pas le mettre en pause. Si nécessaire, vous pourrez le redémarrer, mais vous devrez tout reprendre depuis le début.

3. Lorsque vous êtes prêt, cliquez sur Démarrer l'atelier.

4. Notez vos identifiants pour l'atelier (Nom d'utilisateur et Mot de passe). Ils vous serviront à vous connecter à Google Cloud Console.

5. Cliquez sur Ouvrir la console Google.

6. Cliquez sur Utiliser un autre compte, puis copiez-collez les identifiants de cet atelier lorsque vous y êtes invité.
   Si vous utilisez d'autres identifiants, des messages d'erreur s'afficheront ou des frais seront appliqués.

7. Acceptez les conditions d'utilisation et ignorez la page concernant les ressources de récupération des données.

Une fois la connexion initiale effectuée, le tableau de bord du projet s'affiche.

Ouvrir Cloud Shell

La plupart des tâches de cet atelier s'effectueront dans Cloud Shell.

1. Dans la barre de titre de la console Google Cloud, cliquez sur Activer Cloud Shell ().
2. Cliquez sur Continuer.

Une fois le provisionnement terminé, l'invite de commande Cloud Shell s'affiche.

Tâche 1 : Connexion au cluster GKE de l'atelier et test du DNS

Dans cette tâche, vous allez vous connecter au cluster GKE de l'atelier et créer un fichier manifeste de déploiement pour un ensemble de pods au sein du cluster, que vous utiliserez ensuite pour tester la résolution DNS des noms de pods et de services.

Se connecter au cluster GKE de l'atelier

1. Dans Cloud Shell, saisissez la commande suivante afin de créer des variables d'environnement pour la zone Google Cloud et le nom du cluster, qui serviront ensuite à créer le cluster de cet atelier :

export my_zone={{{project_0.default_zone | ZONE}}} export my_cluster=standard-cluster-1

2. Configurez la complétion par tabulation dans l'outil de ligne de commande kubectl :

source <(kubectl completion bash)

3. Configurez l'accès à votre cluster pour kubectl :

gcloud container clusters get-credentials $my_cluster --zone $my_zone

Tâche 2. Créer des pods et des services pour tester la résolution DNS

Vous allez créer un service appelé dns-demo associé à deux exemples de pods d'application nommés dns-demo-1 et dns-demo-2.

Cloner le dépôt du fichier source et déployer les exemples de pods d'application

Vous allez déployer des pods pour tester la connectivité réseau via les services Kubernetes à l'aide du fichier manifeste dns-demo.yaml disponible dans le dépôt source. Par la suite, ces pods vous permettront de tester la connectivité par le biais de différents services à partir des systèmes se trouvant dans votre cluster Kubernetes.

Vous testerez également la connectivité à partir d'adresses externes à l'aide de Cloud Shell. Pour ce faire, vous pouvez utiliser Cloud Shell, car il se trouve sur un réseau totalement distinct de vos réseaux de cluster Kubernetes.

apiVersion: v1 kind: Service metadata: name: dns-demo spec: selector: name: dns-demo clusterIP: None ports: - name: dns-demo port: 1234 targetPort: 1234 --- apiVersion: v1 kind: Pod metadata: name: dns-demo-1 labels: name: dns-demo spec: hostname: dns-demo-1 subdomain: dns-demo containers: - name: nginx image: nginx --- apiVersion: v1 kind: Pod metadata: name: dns-demo-2 labels: name: dns-demo spec: hostname: dns-demo-2 subdomain: dns-demo containers: - name: nginx image: nginx

1. Saisissez la commande suivante dans Cloud Shell pour cloner le dépôt dans l'environnement Cloud Shell de l'atelier :

git clone https://github.com/GoogleCloudPlatform/training-data-analyst

2. Créez un lien symbolique qui servira de raccourci vers le répertoire de travail :

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Passez au répertoire qui contient les exemples de fichiers de l'atelier :

cd ~/ak8s/GKE_Services/

4. Créez le service et les pods :

kubectl apply -f dns-demo.yaml

5. Vérifiez que les pods sont bien en cours d'exécution :

kubectl get pods

Le résultat doit ressembler à cet exemple.

Résultat :

NAME READY STATUS RESTARTS AGE dns-demo-1 1/1 Running 0 8s dns-demo-2 1/1 Running 0 8s

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer des pods et des services pour tester la résolution DNS

6. Pour accéder au cluster, ouvrez une session interactive bash que vous exécuterez depuis dns-demo-1 :

kubectl exec -it dns-demo-1 -- /bin/bash

Maintenant que vous êtes à l'intérieur d'un conteneur dans le cluster, les commandes suivantes seront exécutées dans ce contexte et serviront à tester la connectivité réseau en pinguant différentes cibles dans les tâches ultérieures. Toutefois, comme vous ne disposez d'aucun outil permettant de pinguer depuis ce conteneur, vous devez d'abord installer la commande ping.

7. Mettez à jour apt-get et installez un outil de ping :

apt-get update apt-get install -y iputils-ping

8. Pinguez dns-demo-2 :

ping dns-demo-2.dns-demo.default.svc.cluster.local

Ce ping doit fonctionner et renvoyer une adresse IP identique à celle que vous avez trouvée pour le pod dns-demo-2.

9. Appuyez sur Ctrl+C pour annuler la commande ping.
10. Pinguez le nom de domaine complet du service dns-demo plutôt qu'un pod spécifique du service :

ping dns-demo.default.svc.cluster.local

Ce ping doit aussi fonctionner, mais la réponse proviendra du nom de domaine complet d'un des pods demo-dns. Il peut s'agir de demo-dns-1 ou de demo-dns-2.

11. Appuyez sur Ctrl+C pour annuler la commande ping.

Le code des applications que vous déployez est exécuté à l'intérieur d'un conteneur du cluster et peut donc accéder à d'autres services via les noms de domaine complets de ces services à l'intérieur de ce cluster. Cette approche est plus simple que d'utiliser des adresses IP ou des noms de pods, car les noms de domaine complets sont moins susceptibles de changer.

12. Laissez ouverte le shell interactif de dns-demo-1.

Tâche 3 : Déployer un exemple de charge de travail et un service ClusterIP

Dans cette tâche, vous allez créer un fichier manifeste de déploiement pour un ensemble de pods du cluster, puis les exposer à l'aide d'un service ClusterIP.

Déployer un exemple d'application Web dans votre cluster Kubernetes Engine

Dans cette tâche, vous allez déployer un exemple d'image de conteneur d'application Web, qui écoute le serveur HTTP sur le port 8080 à l'aide du fichier manifeste suivant, créé dans le fichier manifeste hello-v1.yaml.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v1 spec: replicas: 3 selector: matchLabels: run: hello-v1 template: metadata: labels: run: hello-v1 name: hello-v1 spec: containers: - image: gcr.io/google-samples/hello-app:1.0 name: hello-v1 ports: - containerPort: 8080 protocol: TCP

1. Dans la barre de menu de Cloud Shell, cliquez sur l'icône représentant un signe plus () pour démarrer une nouvelle session Cloud Shell.

Une deuxième session Cloud Shell apparaît dans votre fenêtre Cloud Shell. Vous pouvez utiliser la barre de menu pour passer d'une session à l'autre.

2. Passez au deuxième onglet Cloud Shell et choisissez le répertoire qui contient les exemples de fichiers de l'atelier :

cd ~/ak8s/GKE_Services/

3. Pour créer un déploiement depuis le fichier hello-v1.yaml, exécutez la commande suivante :

kubectl create -f hello-v1.yaml

4. Pour afficher la liste des déploiements, exécutez la commande suivante :

kubectl get deployments

Le résultat doit ressembler à cet exemple.

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 14s

Définir des types de services dans le fichier manifeste

Dans cette tâche, vous allez déployer un service de type ClusterIP à l'aide de l'exemple de fichier manifeste hello-svc.yaml déjà créé.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: ClusterIP selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080

1. Pour déployer le service ClusterIP, exécutez la commande suivante :

kubectl apply -f ./hello-svc.yaml

Le fichier manifeste définit un service ClusterIP et l'applique aux pods qui correspondent au sélecteur. Ici, le fichier manifeste s'applique aux pods hello-v1 que vous avez déployés. Ce service sera automatiquement appliqué aux autres déploiements portant le libellé name: hello-v1.

2. Vérifiez que le service a bien été créé et que le cluster dispose d'une adresse IP :

kubectl get service hello-svc

Votre adresse IP ne sera pas nécessairement celle de l'exemple.

Résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc ClusterIP 10.11.253.203 80/TCP 20s

Aucune adresse IP externe n'est attribuée à ce service. Par défaut, les adresses IP du cluster Kubernetes ne sont pas accessibles en externe. Par conséquent, la création de ce service ne rend pas votre application accessible en dehors du cluster.

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer un exemple de charge de travail et un service ClusterIP

Tester votre application

1. Dans Cloud Shell, essayez d'ouvrir une session HTTP pour le nouveau service avec la commande suivante :

curl hello-svc.default.svc.cluster.local

La connexion doit échouer, parce que le service n'est pas exposé en dehors du cluster.

Résultat :

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Vous allez maintenant tester le service depuis le cluster en utilisant le shell interactif exécuté sur le pod dns-demo-1.

2. Revenez à la première fenêtre Cloud Shell, qui redirige le stdin et le stdout du pod dns-demo-1.
3. Installez curl pour pouvoir appeler des services Web depuis la ligne de commande :

apt-get install -y curl

4. Utilisez la commande suivante pour tester la connexion HTTP entre les pods :

curl hello-svc.default.svc.cluster.local

La connexion doit renvoyer une réponse semblable à la sortie ci-dessous. Votre nom d'hôte ne sera pas nécessairement celui de l'exemple.

Résultat :

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Cette connexion fonctionne, car le DNS interne du cluster Kubernetes Engine permet de résoudre le service ClusterIP.

Tâche 4 : Convertir le service ClusterIP pour utiliser NodePort

Dans cette tâche, vous allez convertir votre service ClusterIP en service NodePort, puis tester à nouveau l'accès au service depuis le cluster et en dehors.

Nous avons créé une version modifiée du fichier hello-svc.yaml, nommée hello-nodeport-svc.yaml, qui permet de passer du type de service ClusterIP au type NodePort.

apiVersion: v1 kind: Service metadata: name: hello-svc spec: type: NodePort selector: name: hello-v1 ports: - protocol: TCP port: 80 targetPort: 8080 nodePort: 30100

1. Revenez à la deuxième fenêtre Cloud Shell. Cette fenêtre n'est PAS connectée au stdin ni au stdout du pod dns-test.
2. Exécutez la commande suivante afin de déployer le fichier manifeste pour attribuer le type NodePort à hello-svc :

kubectl apply -f ./hello-nodeport-svc.yaml

Ce fichier manifeste redéfinit hello-svc comme service NodePort et attribue le port 30100 à tous les nœuds du cluster qui l'utilisent.

3. Saisissez la commande suivante pour vérifier que le type NodePort a été appliqué :

kubectl get service hello-svc

Votre adresse IP ne sera pas nécessairement celle de l'exemple.

Résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE hello-svc NodePort 10.11.253.203 80:30100/TCP 59m Remarque : Encore une fois, aucune adresse IP externe n'est attribuée à ce service.

Cliquez sur Vérifier ma progression pour valider l'objectif. Convertir le service pour utiliser NodePort

Tester votre application

1. Dans Cloud Shell, essayez d'ouvrir une session HTTP pour le nouveau service avec la commande suivante :

curl hello-svc.default.svc.cluster.local

La connexion doit échouer, parce que le service n'est pas exposé en dehors du cluster.

Résultat :

curl: (6) Could not resolve host: hello-svc.default.svc.cluster.local

Essayez de tester le service depuis un autre pod.

2. Revenez à la première fenêtre Cloud Shell, qui redirige le stdin et le stdout du pod dns-test.
3. Utilisez la commande suivante pour tester la connexion HTTP entre les pods :

curl hello-svc.default.svc.cluster.local

La connexion doit renvoyer une réponse semblable à la sortie ci-dessous. Votre nom d'hôte ne sera pas nécessairement celui de l'exemple.

Résultat :

root@dns-demo-1:/# curl hello-svc.default.svc.cluster.local Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-mp4vd root@dns-demo-1:/#

Cette connexion fonctionne, car le DNS interne du cluster GKE permet de résoudre le service ClusterIP.

Tâche 5 : Créer des adresses IP publiques statiques à l'aide de la mise en réseau Google Cloud

Réserver des adresses IP statiques de mise en réseau Google Cloud

1. Dans le menu de navigation de la console Google Cloud, accédez à Mise en réseau > Réseau VPC > Adresses IP.

2. Cliquez sur Réserver une adresse IP statique externe.

3. Saisissez regional-loadbalancer dans le champ Nom.

4. Consultez les options, mais conservez les autres paramètres par défaut. Notez que le type par défaut est Régional.

Remarque : La région par défaut doit correspondre à la région dans laquelle vous avez déployé votre cluster GKE. Si ce n'est pas le cas, modifiez la région affichée ici pour qu'elle corresponde à celle que vous avez utilisée pour créer votre cluster. Si vous avez accepté les paramètres par défaut de l'atelier, il doit s'agir de la région .

5. Cliquez sur Réserver.

6. Notez l'adresse IP externe appelée regional-loadbalancer. Vous l'utiliserez dans une tâche ultérieure.

7. Cliquez sur Réserver une adresse IP statique externe.

8. Saisissez global-ingress dans le champ Nom.

9. Attribuez-lui le type Global.

10. Conservez les autres paramètres par défaut.

11. Cliquez sur Réserver.

12. Notez l'adresse IP externe appelée global-ingress. Vous l'utiliserez dans une tâche ultérieure.

Cliquez sur Vérifier ma progression pour valider l'objectif. Créer des adresses IP publiques statiques à l'aide de la mise en réseau Google Cloud

Tâche 6 : Déployer un nouvel ensemble de pods et un service LoadBalancer

Vous allez à présent déployer un nouvel ensemble de pods exécutant une autre version de l'application, afin de différencier plus facilement les deux services. Vous exposerez ensuite les nouveaux pods en tant que service LoadBalancer, auquel vous accéderez depuis l'extérieur du cluster.

Un deuxième fichier manifeste de déploiement nommé hello-v2.yaml est mis à votre disposition. Il crée un déploiement pour exécuter la deuxième version de l'exemple d'application hello sur le port 8080.

apiVersion: apps/v1 kind: Deployment metadata: name: hello-v2 spec: replicas: 3 selector: matchLabels: run: hello-v2 template: metadata: labels: run: hello-v2 name: hello-v2 spec: containers: - image: gcr.io/google-samples/hello-app:2.0 name: hello-v2 ports: - containerPort: 8080 protocol: TCP

1. Revenez à la deuxième fenêtre Cloud Shell. Cette fenêtre n'est PAS connectée au stdin ni au stdout du pod dns-test.
2. Exécutez la commande suivante pour déployer le fichier manifeste permettant d'effectuer le déploiement de hello-v2 :

kubectl create -f hello-v2.yaml

3. Pour afficher la liste des déploiements, exécutez la commande suivante :

kubectl get deployments

Le résultat doit ressembler à cet exemple.

Résultat :

NAME READY UP-TO-DATE AVAILABLE AGE hello-v1 3/3 3 3 18m hello-v2 3/3 3 3 7s

Définir des types de services dans le fichier manifeste

Dans cette tâche, vous allez déployer un service LoadBalancer à partir de l'exemple de fichier manifeste hello-lb-svc.yaml déjà créé pour vous.

Vous utiliserez la commande sed pour remplacer l'adresse d'espace réservé 10.10.10.10 dans le fichier yaml de l'équilibreur de charge par l'adresse statique que vous avez réservée précédemment pour l'équilibreur de charge.

apiVersion: v1 kind: Service metadata: name: hello-lb-svc spec: type: LoadBalancer loadBalancerIP: 10.10.10.10 selector: name: hello-v2 ports: - protocol: TCP port: 80 targetPort: 8080

1. Vérifiez que vous vous trouvez bien dans la deuxième fenêtre Cloud Shell. Cette fenêtre n'est PAS connectée au stdin ni au stdout du pod dns-test.

2. Saisissez la commande suivante dans Cloud Shell pour enregistrer l'adresse IP statique régionale que vous avez précédemment créée dans une variable d'environnement :

   export STATIC_LB=$(gcloud compute addresses describe regional-loadbalancer --region {{{project_0.default_region | REGION}}} --format json | jq -r '.address')

3. Saisissez la commande suivante dans Cloud Shell pour remplacer l'adresse d'espace réservé par l'adresse IP statique régionale :

sed -i "s/10\.10\.10\.10/$STATIC_LB/g" hello-lb-svc.yaml

4. Saisissez la commande suivante dans Cloud Shell pour vérifier que l'adresse IP externe a été correctement remplacée :

cat hello-lb-svc.yaml

loadBalancerIP doit correspondre à l'adresse que vous avez précédemment enregistrée pour l'adresse IP statique réservée regional-loadbalancer.

5. Pour déployer le fichier manifeste du service LoadBalancer, exécutez la commande suivante :

kubectl apply -f ./hello-lb-svc.yaml

Ce fichier manifeste définit un service LoadBalancer qui déploie un équilibreur de charge réseau Google Cloud permettant d'accéder au service depuis l'extérieur. Ce service s'applique uniquement aux pods associés au sélecteur name: hello-v2.

6. Vérifiez que le service a été créé et qu'un port de nœud a bien été attribué :

kubectl get services

Votre adresse IP ne sera pas nécessairement celle de l'exemple.

Résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE dns-demo ClusterIP None 1234/TCP 1h hello-lb-svc LoadBalancer 10.11.253.48 35.184.45.240 80:30103/TCP 2m hello-svc NodePort 10.11.253.203 80:30100/TCP 1h kubernetes ClusterIP 10.11.240.1 443/TCP 2h

Comme vous pouvez le voir, le nouveau service LoadBalancer désigne l'adresse réservée regional-loadbalancer comme son adresse IP externe. Dans les environnements GKE, l'équilibreur de charge externe pour le type de service LoadBalancer est implémenté à l'aide d'un équilibreur de charge Google Cloud et créé en quelques minutes. Grâce à cette adresse IP externe, le service est accessible en dehors du cluster.

Confirmer la création d'un équilibreur de charge Google Cloud régional

1. Dans le menu de navigation de la console Google Cloud, accédez à Mise en réseau > Services réseau > Équilibrage de charge.

Vous devez voir un équilibreur de charge TCP listé avec un backend de pool cible et deux instances.

2. Cliquez sur le nom pour ouvrir la page d'informations.

Les détails doivent indiquer qu'il s'agit d'un équilibreur de charge TCP régional utilisant l'adresse IP statique que vous avez appelée regional-loadbalancer lorsque vous l'avez réservée précédemment.

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer un nouvel ensemble de pods et un service LoadBalancer

Tester votre application

1. Dans Cloud Shell, essayez d'ouvrir une session HTTP pour le nouveau service avec la commande suivante :

curl hello-lb-svc.default.svc.cluster.local

La connexion doit échouer, car le nom du service n'est pas exposé en dehors du cluster.

Résultat :

curl: (6) Could not resolve host: hello-lb-svc.default.svc.cluster.local

Cette erreur vient du fait que l'adresse IP externe n'est pas associée à ce nom d'hôte.

2. Réessayez d'établir la connexion, en utilisant l'adresse IP externe associée au service d'équilibrage de charge régional. Saisissez la commande suivante en remplaçant [external_IP] par l'adresse IP externe de votre service :

curl [external_IP]

Exemple :

curl 35.184.45.240

La connexion est établie, car l'adresse IP externe du service LoadBalancer est accessible en dehors de Google Cloud.

Remarque : Cela peut prendre jusqu'à cinq minutes.

Résultat :

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

3. Revenez à la première fenêtre Cloud Shell, qui redirige le stdin et le stdout du pod dns-demo-1.
4. Utilisez la commande suivante pour tester la connexion HTTP entre les pods :

curl hello-lb-svc.default.svc.cluster.local

La connexion doit renvoyer une réponse semblable à la sortie ci-dessous. Votre nom d'hôte sera différent de celui de l'exemple.

Résultat :

root@dns-demo-1:/# curl hello-lb-svc.default.svc.cluster.local Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-78ggz root@dns-demo-1:/#

Le nom DNS interne fonctionne au sein du pod et permet d'accéder à la deuxième version de l'application, comme lorsque vous utilisiez l'adresse IP externe en dehors du cluster.

5. Réessayez d'établir la connexion avec le pod en utilisant l'adresse IP externe associée au service. Saisissez la commande suivante en remplaçant [external_IP] par l'adresse IP externe de votre service :

curl [external_IP]

Exemple :

curl 35.184.45.240

Résultat :

root@dns-demo-1:/# curl 35.184.45.240 Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d root@dns-demo-1:/#

L'adresse IP externe peut aussi être utilisée depuis les pods exécutés dans le cluster. Dans ce cas, elle renvoie aussi à la deuxième version des applications.

6. Fermez la session de redirection de la console associée au pod avec la commande "exit" :

exit

Cette commande vous renvoie à l'invite de commande Cloud Shell.

Tâche 7 : Déployer une ressource Ingress

Dans votre cluster, l'application hello est liée à deux services, NodePort et LoadBalancer, qui hébergent respectivement la version 1.0 et la version 2.0 de l'application. Vous allez déployer une ressource Ingress qui va diriger le trafic des deux services en fonction de l'URL saisie par l'utilisateur.

Créer une ressource Ingress

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

Sur GKE, Ingress est implémenté via 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 router le trafic vers votre application.

Nous avons créé pour vous un fichier manifeste appelé hello-ingress.yaml qui permet de configurer une ressource Ingress.

apiVersion: networking.k8s.io/v1 kind: Ingress metadata: name: hello-ingress annotations: nginx.ingress.kubernetes.io/rewrite-target: / kubernetes.io/ingress.global-static-ip-name: "global-ingress" spec: rules: - http: paths: - path: /v1 pathType: ImplementationSpecific backend: service: name: hello-svc port: number: 80 - path: /v2 pathType: ImplementationSpecific backend: service: name: hello-lb-svc port: number: 80

Ce fichier de configuration définit une ressource Ingress qui sera associée à l'adresse IP statique global-ingress que vous avez créée lors d'une étape précédente. Cette ressource Ingress permettra de créer un équilibreur de charge HTTP(S) mondial qui dirigera le trafic vers vos services Web en fonction du chemin d'accès saisi.

L'annotation kubernetes.io/ingress.global-static-ip-name vous permet de spécifier une adresse IP réservée et nommée que la ressource Ingress utilisera lors de la création de l'équilibreur de charge HTTP(S) Google Cloud mondial pour la ressource Ingress.

• Pour déployer cette ressource Ingress, exécutez la commande suivante :

kubectl apply -f hello-ingress.yaml

Lorsque vous déployez ce fichier manifeste, Kubernetes crée une ressource Ingress sur votre cluster. Le contrôleur Ingress exécuté dans le cluster doit créer un équilibreur de charge HTTP(S) pour router tout le trafic HTTP externe (sur le port 80) vers le service Web NodePort et le service LoadBalancer que vous avez exposés.

Confirmer la création d'un équilibreur de charge HTTP(S) mondial

1. Dans le menu de navigation de la console Google Cloud, accédez à Mise en réseau > Services réseau > Équilibrage de charge. Un équilibreur de charge HTTP(S) devrait également être listé.

2. Cliquez sur le nom pour ouvrir la page d'informations. Les détails doivent indiquer qu'il s'agit d'un équilibreur HTTP(S) global utilisant l'adresse IP statique que vous avez appelée global-ingress lorsque vous l'avez réservée précédemment.

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer une ressource Ingress

Tester votre application

1. Pour obtenir l'adresse IP externe de l'équilibreur de charge utilisé par votre application, exécutez la commande suivante :

kubectl describe ingress hello-ingress

Résultat partiel :

Name: hello-ingress Namespace: default Address: 35.244.173.44 Default backend: default-http-backend:80 (10.8.2.5:8080) Rules: Host Path Backends ---- ---- -------- * /v1 hello-svc:80 () /v2 hello-lb-svc:80 () [...] ingress.kubernetes.io/backends:{"k8s-[...]"HEALTHY"[...]} [...] Events: Type Reason Age From Message ---- ------ --- ---- ------- Normal ADD 5m loadbalancer-controller default/hello-ingress Normal CREATE 5m loadbalancer-controller ip: 35.244.173.44 Remarque : L'activation de l'équilibreur de charge et la vérification de l'état peuvent prendre quelques minutes. L'adresse externe s'affichera une fois ces processus terminés.

Répétez la commande à quelques minutes d'intervalle pour vérifier que la ressource Ingress a bien été initialisée. Lorsque l'équilibreur de charge HTTP(S) Google Cloud global est créé et initialisé, la commande indique l'adresse IP externe qui correspond à l'adresse IP statique globale que vous avez réservée précédemment et que vous avez appelée global-ingress.

2. Saisissez la commande suivante, en remplaçant [external_IP] par l'adresse IP externe associée à la ressource Ingress. Pensez à ajouter /v1 au chemin de l'URL :

curl http://[external_IP]/v1

Exemple :

curl http://35.201.92.69/v1

Résultat :

Hello, world! Version: 1.0.0 Hostname: hello-v1-85b99869f-4rmqw

L'URL v1 configurée dans hello-ingress.yaml doit renvoyer au service NodePort hello-svc, qui achemine le trafic vers les pods de l'application v1.

Remarque : Il faudra peut-être quelques minutes à GKE pour définir des règles de transfert, en attendant que l'équilibreur de charge mondial configuré pour la ressource Ingress soit prêt à gérer le trafic vers votre application.

Tant que la configuration de l'équilibreur de charge n'a pas été propagée sur le réseau mondial, vous pouvez vous attendre à obtenir des erreurs de type HTTP 404 ou HTTP 500.

3. Vous allez maintenant tester le chemin de l'URL v2 depuis Cloud Shell. Saisissez la commande suivante, en remplaçant [external_IP] par l'adresse IP externe associée à la ressource Ingress. Pensez à ajouter /v2 au chemin de l'URL :

curl http://[external_IP]/v2

L'URL v2 configurée dans hello-ingress.yaml doit renvoyer au service LoadBalancer hello-lb-svc, qui achemine le trafic vers les pods de l'application v2.

Exemple :

curl http://35.201.92.69/v2

Résultat :

Hello, world! Version: 2.0.0 Hostname: hello-v2-59c99d8b65-jrx2d

Inspecter les modifications apportées à vos ressources réseau dans la console Google Cloud

1. Dans le menu de navigation de la console Google Cloud, cliquez sur Mise en réseau > Services réseau > Équilibrage de charge.

Deux équilibreurs de charge sont désormais listés :

• Le premier équilibreur de charge régional pour le service hello-lb-svc. Il porte un nom de type UID et a été configuré pour équilibrer les charges du trafic du port TCP 80 vers les nœuds du cluster.

• Le deuxième est associé à un objet Ingress. Il s'agit d'un équilibreur de charge HTTP(S) complet dont les règles d'hôte et de chemin correspondent à la configuration de la ressource Ingress. hello-ingress apparaît dans son nom.

2. Cliquez sur l'équilibreur de charge dont le nom comporte l'expression hello-ingress.

Vous obtiendrez des informations récapitulatives sur les protocoles, les ports, les chemins et les services de backend de l'équilibreur de charge HTTP(S) Google Cloud global créé pour votre ressource Ingress.

Terminer l'atelier

Une fois l'atelier terminé, cliquez sur Terminer l'atelier. Google Cloud Skills Boost supprime les ressources que vous avez utilisées, puis efface le compte.

Si vous le souhaitez, vous pouvez noter l'atelier. Sélectionnez un nombre d'étoiles, saisissez un commentaire, puis cliquez sur Envoyer.

Le nombre d'étoiles correspond à votre degré de satisfaction :

• 1 étoile = très insatisfait(e)
• 2 étoiles = insatisfait(e)
• 3 étoiles = ni insatisfait(e), ni satisfait(e)
• 4 étoiles = satisfait(e)
• 5 étoiles = très satisfait(e)

Si vous ne souhaitez pas donner votre avis, vous pouvez fermer la boîte de dialogue.

Pour soumettre des commentaires, suggestions ou corrections, veuillez accéder à l'onglet Assistance.

Copyright 2020 Google LLC Tous droits réservés. Google et le logo Google sont des marques de Google LLC. Tous les autres noms d'entreprises et de produits peuvent être des marques des entreprises auxquelles ils sont associés.