GSP021

Présentation

Kubernetes est un projet Open Source (disponible sur kubernetes.io) qui peut s'exécuter sur de nombreux environnements différents : ordinateurs portables, clusters multinœuds haute disponibilité, clouds publics, déploiements sur site, machines virtuelles ou solutions Bare Metal.

Pour cet atelier, l'utilisation d'un environnement géré comme Kubernetes Engine vous permet de vous consacrer à la découverte de Kubernetes plutôt que d'avoir à configurer l'infrastructure sous-jacente. Kubernetes Engine est un environnement géré destiné au déploiement d'applications conteneurisées. Il regroupe les innovations les plus récentes pour améliorer la productivité des développeurs, optimiser l'utilisation des ressources, automatiser les opérations et exploiter la flexibilité de l'Open Source, le tout dans le but d'accélérer vos temps de production.

Remarque : App est un exemple d'application 12 facteurs hébergé sur GitHub. Dans cet atelier, vous travaillerez avec les images Docker suivantes :

kelseyhightower/monolith : image "monolith" qui comprend les services auth et hello

kelseyhightower/auth : microservice auth qui génère les jetons JWT pour les utilisateurs authentifiés

kelseyhightower/hello : microservice hello qui salue les utilisateurs authentifiés

nginx : interface pour les services auth et hello

Objectifs

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

• Provisionner un cluster Kubernetes complet à l'aide de Kubernetes Engine
• Déployer et gérer des conteneurs Docker avec kubectl
• Décomposer une application en microservices à l'aide des déploiements et services Kubernetes

Préparation

Avant de cliquer sur le bouton "Démarrer l'atelier"

Lisez ces instructions. Les ateliers sont minutés, et vous ne pouvez pas les mettre en pause. Le minuteur, qui démarre lorsque vous cliquez sur Démarrer l'atelier, indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique vous permet de suivre vous-même les activités dans un véritable environnement cloud, et non dans un environnement de simulation ou de démonstration. Nous vous fournissons des identifiants temporaires pour vous connecter à Google Cloud le temps de l'atelier.

Pour réaliser cet atelier :

• vous devez avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;

Remarque : Ouvrez une fenêtre de navigateur en mode incognito/navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le temporaire étudiant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

• vous disposez d'un temps limité ; une fois l'atelier commencé, vous ne pouvez pas le mettre en pause.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier afin d'éviter que des frais supplémentaires ne vous soient facturés.

Démarrer l'atelier et se connecter à la console Google Cloud

1. Cliquez sur le bouton Démarrer l'atelier. Si l'atelier est payant, un pop-up s'affiche pour vous permettre de sélectionner un mode de paiement. Sur la gauche, vous trouverez le panneau Détails concernant l'atelier, qui contient les éléments suivants :

   • Le bouton Ouvrir la console Google Cloud
   • Le temps restant
   • Les identifiants temporaires que vous devez utiliser pour cet atelier
   • Des informations complémentaires vous permettant d'effectuer l'atelier

2. Cliquez sur Ouvrir la console Google Cloud (ou effectuez un clic droit et sélectionnez Ouvrir le lien dans la fenêtre de navigation privée si vous utilisez le navigateur Chrome).

   L'atelier lance les ressources, puis ouvre la page Se connecter dans un nouvel onglet.

   Conseil : Réorganisez les onglets dans des fenêtres distinctes, placées côte à côte.

   Remarque : Si la boîte de dialogue Sélectionner un compte s'affiche, cliquez sur Utiliser un autre compte.

3. Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.

   {{{user_0.username | "Username"}}}

   Vous trouverez également le nom d'utilisateur dans le panneau Détails concernant l'atelier.

4. Cliquez sur Suivant.

5. Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.

   {{{user_0.password | "Password"}}}

   Vous trouverez également le mot de passe dans le panneau Détails concernant l'atelier.

6. Cliquez sur Suivant.

   Important : Vous devez utiliser les identifiants fournis pour l'atelier. Ne saisissez pas ceux de votre compte Google Cloud. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.

7. Accédez aux pages suivantes :

   • Acceptez les conditions d'utilisation.
   • N'ajoutez pas d'options de récupération ni d'authentification à deux facteurs (ce compte est temporaire).
   • Ne vous inscrivez pas à des essais gratuits.

Après quelques instants, la console Cloud s'ouvre dans cet onglet.

Remarque : Pour afficher un menu contenant la liste des produits et services Google Cloud, cliquez sur le menu de navigation en haut à gauche.

Activer Cloud Shell

Cloud Shell est une machine virtuelle qui contient de nombreux outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Cloud Shell vous permet d'accéder via une ligne de commande à vos ressources Google Cloud.

1. Cliquez sur Activer Cloud Shell  en haut de la console Google Cloud.

Une fois connecté, vous êtes en principe authentifié et le projet est défini sur votre ID_PROJET. Le résultat contient une ligne qui déclare YOUR_PROJECT_ID (VOTRE_ID_PROJET) pour cette session :

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

gcloud est l'outil de ligne de commande pour Google Cloud. Il est préinstallé sur Cloud Shell et permet la complétion par tabulation.

2. (Facultatif) Vous pouvez lister les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

3. Cliquez sur Autoriser.

4. Vous devez à présent obtenir le résultat suivant :

Résultat :

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Facultatif) Vous pouvez lister les ID de projet à l'aide de cette commande :

gcloud config list project

Résultat :

[core] project = <ID_Projet>

Exemple de résultat :

[core] project = qwiklabs-gcp-44776a13dea667a6 Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

Google Kubernetes Engine

1. Dans l'environnement Cloud Shell, saisissez la commande suivante pour définir la zone :

gcloud config set compute/zone {{{project_0.default_zone|Zone}}}

2. Démarrez le cluster que vous utiliserez dans cet atelier :

gcloud container clusters create io --zone {{{project_0.default_zone|Zone}}} Vous êtes automatiquement authentifié auprès du cluster lorsque vous le créez. Si vous perdez la connexion à Cloud Shell pour une raison quelconque, exécutez la commande gcloud container clusters get-credentials io pour vous réauthentifier. Remarque : La création du cluster peut prendre du temps, car Kubernetes Engine provisionne quelques machines virtuelles en arrière-plan pour vous.

Tâche 1 : Obtenir l'exemple de code

1. Copiez le code source depuis la ligne de commande Cloud Shell :

gsutil cp -r gs://spls/gsp021/* .

2. Accédez au répertoire requis pour cet atelier :

cd orchestrate-with-kubernetes/kubernetes

3. Affichez les fichiers pour voir vos éléments de travail :

ls

L'exemple se présente de la façon suivante :

deployments/ /* Deployment manifests */ ... nginx/ /* nginx config files */ ... pods/ /* Pod manifests */ ... services/ /* Services manifests */ ... tls/ /* TLS certificates */ ... cleanup.sh /* Cleanup script */

Maintenant que vous avez le code, il est temps d'essayer Kubernetes !

Tâche 2 : Démonstration rapide de Kubernetes

Pour commencer à utiliser Kubernetes, le plus simple est de saisir la commande kubectl create.

1. Utilisez-la pour lancer une instance unique du conteneur "nginx" :

kubectl create deployment nginx --image=nginx:1.10.0

Kubernetes a créé un déploiement. Nous aborderons les déploiements plus en détail ultérieurement. Pour l'instant, retenez simplement qu'ils permettent aux pods de continuer à fonctionner, même si les nœuds sur lesquels ils s'exécutent sont défaillants.

Dans Kubernetes, tous les conteneurs sont exécutés dans un pod.

2. Utilisez la commande kubectl get pods pour afficher le conteneur "nginx" en cours d'exécution :

kubectl get pods

3. Lorsque le conteneur "nginx" est en cours d'exécution, vous pouvez l'exposer hors de Kubernetes à l'aide de la commande kubectl expose :

kubectl expose deployment nginx --port 80 --type LoadBalancer

Que s'est-il passé ? En arrière-plan, Kubernetes a créé un équilibreur de charge externe avec une adresse IP publique associée. Les clients qui appellent cette adresse IP publique sont redirigés vers les pods en arrière-plan. Ici, il s'agit du pod "nginx".

4. À présent, affichez les services à l'aide de la commande kubectl get services :

kubectl get services Remarque : Le remplissage du champ ExternalIP pour votre service peut prendre plusieurs secondes. C'est normal. Il vous suffit d'exécuter de nouveau la commande kubectl get services toutes les quelques secondes jusqu'à ce que le champ soit renseigné.

5. Ajoutez l'adresse IP externe à cette commande pour appeler le conteneur "nginx" à distance :

curl http://<External IP>:80

Et voilà ! Kubernetes offre un wokflow facile à utiliser et prêt à l'emploi grâce aux commandes d'exécution et d'exposition kubectl.

Tester la tâche terminée

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer le cluster Kubernetes et à déployer le conteneur "nginx", vous verrez une note d'évaluation s'afficher.

Créer un cluster Kubernetes et lancer le conteneur "nginx"

Maintenant que vous avez découvert Kubernetes, vous pouvez vous intéresser aux composants et aux abstractions.

Tâche 3 : Pods

Les pods sont au cœur de Kubernetes.

Ils représentent et contiennent un ou plusieurs conteneurs. En principe, si vous disposez de plusieurs conteneurs présentant une forte interdépendance, ils sont contenus dans un seul pod.

Cet exemple montre un pod comprenant les conteneurs "monolith" et "nginx".

Les pods disposent également de volumes. Les volumes sont des disques de données qui ont la même durée de vie que les pods et qui peuvent être utilisés par les conteneurs de ce pod. Les pods offrent un espace de noms partagé pour leurs contenus. Ainsi, les deux conteneurs de notre exemple de pod peuvent communiquer l'un avec l'autre, et ils partagent les volumes associés.

Les pods partagent également un espace de noms réseau. Cela signifie qu'il existe une adresse IP par pod.

Examinons à présent les pods d'un peu plus près.

Tâche 4 : Créer des pods

Les pods peuvent être créés à l'aide de fichiers de configuration de pods. Prenons quelques minutes pour examiner le fichier de configuration du pod "monolith".

1. Accédez au répertoire suivant :

cd ~/orchestrate-with-kubernetes/kubernetes

2. Exécutez la commande suivante :

cat pods/monolith.yaml

Vous obtenez le fichier de configuration ouvert comme résultat :

apiVersion: v1 kind: Pod metadata: name: monolith labels: app: monolith spec: containers: - name: monolith image: kelseyhightower/monolith:1.0.0 args: - "-http=0.0.0.0:80" - "-health=0.0.0.0:81" - "-secret=secret" ports: - name: http containerPort: 80 - name: health containerPort: 81 resources: limits: cpu: 0.2 memory: "10Mi"

Quelques éléments méritent votre attention :

• Votre pod est constitué d'un conteneur ("monolith").
• Vous transmettez quelques arguments au conteneur lorsqu'il démarre.
• Vous ouvrez le port 80 pour le trafic HTTP.

3. Créez le pod "monolith" à l'aide de kubectl :

kubectl create -f pods/monolith.yaml

4. Examinez vos pods. Utilisez la commande kubectl get pods pour afficher tous les pods exécutés dans l'espace de noms par défaut :

kubectl get pods Remarque : Le pod "monolith" peut mettre quelques secondes à démarrer et à s'exécuter. L'image du conteneur "monolith" doit être extraite de Docker Hub pour que vous puissiez exécuter le pod.

5. Une fois que le pod "monolith" est en cours d'exécution, utilisez la commande kubectl describe pour obtenir plus d'informations sur ce pod :

kubectl describe pods monolith

De nombreuses informations sur le pod "monolith" s'affichent, dont l'adresse IP du pod et le journal des événements. Ces informations vous seront utiles lors d'éventuelles procédures de dépannage.

Kubernetes permet de créer facilement des pods en les décrivant dans des fichiers de configuration et de consulter facilement des informations à leur sujet lorsqu'ils sont en cours d'exécution. Vous êtes désormais capable de créer tous les pods requis par votre déploiement !

Tâche 5 : Interagir avec des pods

Une adresse IP privée est allouée par défaut aux pods. Ils ne sont pas accessibles depuis l'extérieur du cluster. Utilisez la commande kubectl port-forward pour mapper un port local sur un port situé à l'intérieur du pod "monolith".

Remarque : À partir de maintenant, vous devez travailler dans plusieurs onglets Cloud Shell afin d'établir la communication entre les pods. Lorsqu'une commande doit être exécutée dans une deuxième ou troisième fenêtre de shell, cela est indiqué dans les instructions de cette commande.

1. Ouvrez un autre terminal Cloud Shell. Vous disposez désormais de deux terminaux : un pour exécuter la commande kubectl port-forward et un pour exécuter des commandes curl.

2. Dans le deuxième terminal, exécutez la commande suivante pour configurer le transfert de port :

kubectl port-forward monolith 10080:80

3. Vous pouvez commencer à communiquer avec votre pod dans le premier terminal à l'aide de la commande curl :

curl http://127.0.0.1:10080

Et voilà. Votre conteneur vous salue chaleureusement ("hello") !

4. Utilisez à présent la commande curl pour découvrir ce qui se passe lorsque vous appelez un point de terminaison sécurisé :

curl http://127.0.0.1:10080/secure

Ah, il y a un petit problème !

5. Essayez de vous connecter pour recevoir un jeton d'authentification émis par le pod "monolith" :

curl -u user http://127.0.0.1:10080/login

6. Lorsque l'invite de connexion s'affiche, utilisez le mot de passe ultra-secret password pour vous connecter.

La connexion entraîne l'affichage d'un jeton JWT.

7. Cloud Shell ne permet pas de copier de longues chaînes correctement. Vous devez donc créer une variable d'environnement pour le jeton.

TOKEN=$(curl http://127.0.0.1:10080/login -u user|jq -r '.token')

8. Lorsque vous êtes invité à indiquer le mot de passe de l'hôte, saisissez de nouveau le mot de passe ultra-secret password.

9. Utilisez cette commande pour copier le jeton, puis utilisez celui-ci pour appeler le point de terminaison sécurisé à l'aide de curl :

curl -H "Authorization: Bearer $TOKEN" http://127.0.0.1:10080/secure

Vous devez recevoir une réponse de l'application vous indiquant que tout est rentré dans l'ordre.

10. Utilisez la commande kubectl logs pour afficher les journaux du pod monolith.

kubectl logs monolith

11. Ouvrez un troisième terminal et utilisez l'option -f pour obtenir un flux des journaux en temps réel :

kubectl logs -f monolith

12. Si vous utilisez la commande curl dans le premier terminal pour interagir avec le pod "monolith", vous pouvez voir que les journaux sont mis à jour (dans le troisième terminal) :

curl http://127.0.0.1:10080

13. Utilisez la commande kubectl exec pour exécuter un shell interactif dans le pod "monolith". Cela peut vous être utile lorsque vous souhaitez résoudre des problèmes à partir d'un conteneur :

kubectl exec monolith --stdin --tty -c monolith -- /bin/sh

14. Par exemple, avec un shell dans le conteneur "monolith", vous pouvez tester la connectivité externe à l'aide de la commande ping :

ping -c 3 google.com

15. Veillez à vous déconnecter lorsque vous cessez d'utiliser ce shell interactif.

exit

Comme vous pouvez le voir, interagir avec les pods est aussi simple que d'utiliser la commande kubectl. Si vous devez appeler un conteneur à distance ou obtenir un shell de connexion, Kubernetes vous fournit tout ce dont vous avez besoin.

Tâche 6 : Services

Les pods ne sont pas conçus pour être persistants. Ils peuvent être arrêtés ou démarrés pour plusieurs raisons (si les vérifications d'activité ou d'aptitude échouent, par exemple), ce qui entraîne un problème :

Que se passe-t-il si vous souhaitez communiquer avec un ensemble de pods ? En cas de redémarrage, il se peut qu'une adresse IP différente leur soit allouée.

C'est là que les services entrent en jeu. Ils fournissent des points de terminaison stables pour les pods.

Les services utilisent des étiquettes pour déterminer les pods qu'ils gèrent. Si les pods disposent des étiquettes adéquates, ils sont automatiquement sélectionnés et exposés par les services.

Le niveau d'accès fourni par un service à un ensemble de pods dépend du type de service. À l'heure actuelle, il existe trois types de services :

• ClusterIP (interne) est le type de service par défaut qui n'est visible qu'au sein du cluster.
• NodePort attribue une adresse IP accessible en externe à chaque nœud du cluster.
• LoadBalancer ajoute un équilibreur de charge (provenant du fournisseur de services cloud) qui transfère le trafic du service aux nœuds contenus dans celui-ci.

Vous allez maintenant apprendre à :

• créer un service ;
• utiliser des sélecteurs d'étiquettes pour exposer un ensemble limité de pods en externe.

Tâche 7 : Créer un service

Au préalable, vous devez créer un pod sécurisé capable de gérer le trafic HTTPS.

1. Si vous avez changé de répertoire, veillez à bien revenir au répertoire ~/orchestrate-with-kubernetes/kubernetes :

cd ~/orchestrate-with-kubernetes/kubernetes

2. Examinez le fichier de configuration du service monolith :

cat pods/secure-monolith.yaml

3. Créez le type de pod "secure-monolith" et ses données de configuration :

kubectl create secret generic tls-certs --from-file tls/ kubectl create configmap nginx-proxy-conf --from-file nginx/proxy.conf kubectl create -f pods/secure-monolith.yaml

Vous disposez désormais d'un pod sécurisé. Vous allez maintenant exposer le pod "secure-monolith" en externe. Pour ce faire, créez un service Kubernetes.

4. Examinez le fichier de configuration du service monolith :

cat services/monolith.yaml

Résultat :

kind: Service apiVersion: v1 metadata: name: "monolith" spec: selector: app: "monolith" secure: "enabled" ports: - protocol: "TCP" port: 443 targetPort: 443 nodePort: 31000 type: NodePort Points à noter :

* Un sélecteur est utilisé pour trouver et exposer automatiquement tous les pods dotés des étiquettes "app: monolith" et "secure: enabled".

* Vous devez à présent exposer le port du nœud de sorte que le trafic externe du port 31000 soit transféré vers nginx (sur le port 443).

5. Utilisez la commande kubectl create pour créer le service monolith à partir du fichier de configuration du service monolith :

kubectl create -f services/monolith.yaml

Résultat :

service/monolith created

Tester la tâche terminée

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer les pods et le service monolith, vous verrez une note d'évaluation s'afficher.

Créer des pods et le service monolith

Vous utilisez un port pour exposer le service. En d'autres termes, des conflits de ports risquent de se produire si une autre application essaie de s'associer au port 31000 sur l'un de vos serveurs.

En temps normal, c'est Kubernetes qui gère l'affectation de ce port. Mais pour cet atelier, vous avez choisi un port afin de simplifier la configuration ultérieure des vérifications de l'état.

6. Utilisez la commande gcloud compute firewall-rules pour autoriser le trafic vers le service monolith sur le port exposé du nœud :

gcloud compute firewall-rules create allow-monolith-nodeport \ --allow=tcp:31000

Tester la tâche terminée

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer la règle de pare-feu autorisant le trafic TCP sur le port 31000, vous verrez une note d'évaluation s'afficher.

Autoriser le trafic vers le service monolith sur le port de nœud exposé

Maintenant que la configuration est terminée, vous devez pouvoir appeler le service secure-monolith depuis l'extérieur du cluster sans utiliser le transfert de port.

1. Commencez par récupérer une adresse IP externe pour l'un des nœuds.

gcloud compute instances list

2. Essayez à présent d'appeler le service secure-monolith à l'aide de la commande curl :

curl -k https://<EXTERNAL_IP>:31000

Petit problème… La requête a expiré. Que se passe-t-il ?

Remarque : Il est temps de tester rapidement vos connaissances.

Utilisez les commandes suivantes pour répondre aux questions ci-dessous :

kubectl get services monolith

kubectl describe services monolith

Questions :

Pourquoi ne parvenez-vous pas à obtenir une réponse du service monolith ?

De combien de points de terminaison dispose le service monolith ?

Quelles étiquettes doivent être associées à un pod pour que ce dernier soit sélectionné par le service monolith ?

Indice : Le problème est lié aux étiquettes. Vous le résoudrez dans la prochaine section.

Tâche 8 : Ajouter des étiquettes à un pod

À l'heure actuelle, le service monolith ne dispose d'aucun point de terminaison. Pour résoudre un problème de ce type, vous pouvez par exemple utiliser la commande kubectl get pods avec une requête d'étiquette.

1. Vous pouvez voir que plusieurs pods en cours d'exécution portent l'étiquette "monolith".

kubectl get pods -l "app=monolith"

2. Qu'en est-il des étiquettes "app=monolith" et "secure=enabled" ?

kubectl get pods -l "app=monolith,secure=enabled"

Vous remarquerez que cette requête d'étiquette ne renvoie aucun résultat. Tout semble indiquer que vous devez ajouter l'étiquette "secure=enabled" à certains pods.

3. Utilisez la commande kubectl label pour ajouter l'étiquette secure=enabled manquante au pod "secure-monolith". Vous pouvez ensuite vérifier et constater que les étiquettes ont été mises à jour.

kubectl label pods secure-monolith 'secure=enabled' kubectl get pods secure-monolith --show-labels

4. Maintenant que les étiquettes des pods sont correctes, affichez la liste des points de terminaison sur le service monolith :

kubectl describe services monolith | grep Endpoints

Il y en a un !

5. Testez-le en appelant de nouveau l'un des nœuds.

gcloud compute instances list curl -k https://<EXTERNAL_IP>:31000

Ça y est ! Mission accomplie.

Tester la tâche terminée

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à ajouter les étiquettes aux pods "monolith", vous verrez une note d'évaluation s'afficher.

Ajouter des étiquettes à un pod

Tâche 9 : Déployer des applications avec Kubernetes

L'objectif de cet atelier est de vous préparer au scaling et à la gestion des conteneurs en production. C'est là que les déploiements entrent en jeu. Il s'agit d'une méthode déclarative permettant de veiller à ce que le nombre de pods en cours d'exécution corresponde au nombre de pods souhaité (spécifié par l'utilisateur).

Le principal avantage des déploiements est de supprimer les tâches de bas niveau de la gestion des pods. Ils utilisent des ensembles d'instances répliquées en arrière-plan pour gérer le démarrage et l'arrêt des pods. Lorsque c'est nécessaire, les déploiements gèrent la mise à jour et le scaling des pods. Ils gèrent également le redémarrage des pods en cas d'arrêt.

Prenons un exemple simple :

Les pods sont conditionnés par la durée de vie du nœud sur lequel ils sont créés. Dans l'exemple ci-dessus, Node3 s'est arrêté (en entraînant également l'arrêt d'un pod). Vous n'avez pas eu à créer manuellement un pod et à lui trouver un nœud. Votre déploiement s'est chargé de créer un pod et de le démarrer sur Node2.

Plutôt pratique !

Il est temps de mettre à profit toutes vos nouvelles connaissances sur les pods et services pour décomposer l'application monolith en services plus petits à l'aide de déploiements.

Tâche 10 : Créer des déploiements

Vous allez décomposer l'application monolith en trois parties distinctes :

• auth génère des jetons JWT pour les utilisateurs authentifiés.
• hello salue les utilisateurs authentifiés.
• frontend achemine le trafic vers les services auth et hello.

Vous êtes prêt à créer des déploiements, un pour chaque service. Une fois que ce sera fait, vous définirez des services internes pour les déploiements auth et hello, ainsi qu'un service externe pour le déploiement frontend. Une fois ces services définis, vous pourrez interagir avec les microservices de la même manière qu'avec monolith, à ceci près que vous pourrez faire évoluer et déployer chaque partie indépendamment.

1. Commencez par examiner le fichier de configuration de déploiement du service auth.

cat deployments/auth.yaml

Résultat :

apiVersion: apps/v1 kind: Deployment metadata: name: auth spec: selector: matchlabels: app: auth replicas: 1 template: metadata: labels: app: auth track: stable spec: containers: - name: auth image: "kelseyhightower/auth:2.0.0" ports: - name: http containerPort: 80 - name: health containerPort: 81 ...

Le déploiement crée une instance répliquée, et vous utilisez la version 2.0.0 du conteneur "auth".

En exécutant la commande kubectl create pour créer le déploiement auth, vous créez un pod conforme aux données du fichier manifeste du déploiement. Vous pouvez donc faire évoluer le nombre de pods en modifiant le nombre spécifié dans le champ "replicas" (instances répliquées).

2. Poursuivez en créant l'objet de déploiement :

kubectl create -f deployments/auth.yaml

3. Vous devez maintenant créer un service pour votre déploiement auth. Utilisez la commande kubectl create pour créer le service auth :

kubectl create -f services/auth.yaml

4. Procédez de la même façon pour créer et exposer le déploiement hello :

kubectl create -f deployments/hello.yaml kubectl create -f services/hello.yaml

5. Répétez l'opération encore une fois pour créer et exposer le déploiement frontend :

kubectl create configmap nginx-frontend-conf --from-file=nginx/frontend.conf kubectl create -f deployments/frontend.yaml kubectl create -f services/frontend.yaml Remarque : Le déploiement frontend nécessite une étape supplémentaire, car vous devez stocker certaines données de configuration avec le conteneur.

6. Pour interagir avec le service frontend, capturez son adresse IP externe, puis appelez-le avec curl :

kubectl get services frontend Remarque : La génération d'une adresse IP externe peut prendre quelque temps. Exécutez de nouveau la commande ci-dessus si la colonne EXTERNAL-IP est à l'état d'attente. curl -k https://<EXTERNAL-IP>

Vous obtenez la réponse "hello" !

Tester la tâche terminée

Cliquez sur Vérifier ma progression ci-dessous pour valider votre progression dans l'atelier. Si vous avez réussi à créer les déploiements auth, hello et frontend, vous verrez une note d'évaluation s'afficher.

Créer des déploiements (auth, hello et frontend)

Félicitations !

Félicitations ! Vous avez développé une application multiservice à l'aide de Kubernetes. Les compétences que vous avez acquises lors de cet atelier vous permettront de déployer des applications complexes sur Kubernetes avec un ensemble de déploiements et de services.

Étapes suivantes et informations supplémentaires

• Vous pouvez vous tenir informé de l'actualité de Kubernetes sur X et sur le blog de la communauté.
• N'oubliez pas que Kubernetes est un projet Open Source (http://kubernetes.io/) hébergé sur GitHub. Vos commentaires et contributions sont donc toujours utiles.

Formations et certifications Google Cloud

Les formations et certifications Google Cloud vous aident à tirer pleinement parti des technologies Google Cloud. Nos cours portent sur les compétences techniques et les bonnes pratiques à suivre pour être rapidement opérationnel et poursuivre votre apprentissage. Nous proposons des formations pour tous les niveaux, à la demande, en salle et à distance, pour nous adapter aux emplois du temps de chacun. Les certifications vous permettent de valider et de démontrer vos compétences et votre expérience en matière de technologies Google Cloud.

Dernière mise à jour du manuel : 29 avril 2024

Dernier test de l'atelier : 29 avril 2024

Copyright 2024 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.