![](https://cdn.qwiklabs.com/assets/labs/start_lab-f45aca49782d4033c3ff688160387ac98c66941d.png)
Before you begin
- Labs create a Google Cloud project and resources for a fixed time
- Labs have a time limit and no pause feature. If you end the lab, you'll have to restart from the beginning.
- On the top left of your screen, click Start lab to begin
Create a Kubernetes cluster and launch Nginx container
/ 25
Create Monolith pods and service
/ 25
Allow traffic to the monolith service on the exposed nodeport
/ 5
Adding Labels to Pods
/ 20
Creating Deployments (Auth, Hello and Frontend)
/ 25
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.
Dans cet atelier, vous allez apprendre à effectuer les tâches suivantes :
kubectl
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 :
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 :
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.
Si nécessaire, copiez le nom d'utilisateur ci-dessous et collez-le dans la boîte de dialogue Se connecter.
Vous trouverez également le nom d'utilisateur dans le panneau Détails concernant l'atelier.
Cliquez sur Suivant.
Copiez le mot de passe ci-dessous et collez-le dans la boîte de dialogue Bienvenue.
Vous trouverez également le mot de passe dans le panneau Détails concernant l'atelier.
Cliquez sur Suivant.
Accédez aux pages suivantes :
Après quelques instants, la console Cloud s'ouvre dans cet onglet.
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.
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 :
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.
Cliquez sur Autoriser.
Vous devez à présent obtenir le résultat suivant :
Résultat :
Résultat :
Exemple de résultat :
gcloud
, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.
gcloud container clusters get-credentials io
pour vous réauthentifier.
L'exemple se présente de la façon suivante :
Maintenant que vous avez le code, il est temps d'essayer Kubernetes !
Pour commencer à utiliser Kubernetes, le plus simple est de saisir la commande kubectl create
.
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.
kubectl get pods
pour afficher le conteneur "nginx" en cours d'exécution :kubectl expose
: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".
kubectl get services
: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é.
Et voilà ! Kubernetes offre un wokflow facile à utiliser et prêt à l'emploi grâce aux commandes d'exécution et d'exposition kubectl
.
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.
Maintenant que vous avez découvert Kubernetes, vous pouvez vous intéresser aux composants et aux abstractions.
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.
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".
Vous obtenez le fichier de configuration ouvert comme résultat :
Quelques éléments méritent votre attention :
kubectl
:kubectl get pods
pour afficher tous les pods exécutés dans l'espace de noms par défaut :kubectl describe
pour obtenir plus d'informations sur ce pod :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 !
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".
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
.
Dans le deuxième terminal, exécutez la commande suivante pour configurer le transfert de port :
curl
:Et voilà. Votre conteneur vous salue chaleureusement ("hello") !
curl
pour découvrir ce qui se passe lorsque vous appelez un point de terminaison sécurisé :Ah, il y a un petit problème !
password
pour vous connecter.La connexion entraîne l'affichage d'un jeton JWT.
Lorsque vous êtes invité à indiquer le mot de passe de l'hôte, saisissez de nouveau le mot de passe ultra-secret password
.
Utilisez cette commande pour copier le jeton, puis utilisez celui-ci pour appeler le point de terminaison sécurisé à l'aide de curl
:
Vous devez recevoir une réponse de l'application vous indiquant que tout est rentré dans l'ordre.
kubectl logs
pour afficher les journaux du pod monolith
.-f
pour obtenir un flux des journaux en temps réel :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) :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 :ping
: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.
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 à :
Au préalable, vous devez créer un pod sécurisé capable de gérer le trafic HTTPS.
~/orchestrate-with-kubernetes/kubernetes
: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.
Résultat :
* 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).
kubectl create
pour créer le service monolith à partir du fichier de configuration du service monolith :Résultat :
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.
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.
gcloud compute firewall-rules
pour autoriser le trafic vers le service monolith sur le port exposé du nœud :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.
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.
curl
: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 :
Indice : Le problème est lié aux étiquettes. Vous le résoudrez dans la prochaine section.
À 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.
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.
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.Il y en a un !
Ça y est ! Mission accomplie.
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.
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.
Vous allez décomposer l'application monolith en trois parties distinctes :
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.
Résultat :
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).
kubectl create
pour créer le service auth :EXTERNAL-IP
est à l'état d'attente.Vous obtenez la réponse "hello" !
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.
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.
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 2025 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.
Ce contenu n'est pas disponible pour le moment
Nous vous préviendrons par e-mail lorsqu'il sera disponible
Parfait !
Nous vous contacterons par e-mail s'il devient disponible
One lab at a time
Confirm to end all existing labs and start this one