arrow_back

Orchestrer le cloud avec Kubernetes

Orchestrer le cloud avec Kubernetes

1 heure 15 minutes 1 crédit

GSP021

Google Cloud – Ateliers adaptés au rythme de chacun

Présentation

Dans cet atelier, vous allez apprendre à :

  • 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.

Kubernetes est axé sur les applications. Dans cette partie, vous utiliserez un exemple d'application appelé "app" pour réaliser les exercices pratiques.

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

9f35a311fce0abdc.png

Kubernetes est un projet Open Source (disponible sur kubernetes.io) qui peut être exécuté sur de nombreux environnements différents : ordinateurs portables, clusters multinœuds haute disponibilité, clouds publics, déploiements sur site, machines virtuelles ou serveurs physiques.

Pour cet atelier, l'utilisation d'un environnement géré comme Kubernetes Engine vous permet de vous familiariser avec Kubernetes plutôt que d'avoir à configurer une infrastructure sous-jacente.

Configuration et prérequis

Configuration de Qwiklabs

Avant de cliquer sur le bouton Start Lab (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 Start Lab (Démarrer l'atelier), indique combien de temps les ressources Google Cloud resteront accessibles.

Cet atelier pratique Qwiklabs 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. Des identifiants temporaires vous sont fournis pour vous permettre de vous connecter à Google Cloud le temps de l'atelier.

Conditions requises

Pour réaliser cet atelier, vous devez :

  • avoir accès à un navigateur Internet standard (nous vous recommandons d'utiliser Chrome) ;
  • disposer de suffisamment de temps pour réaliser l'atelier en une fois.

Remarque : Si vous possédez déjà votre propre compte ou projet Google Cloud, veillez à ne pas l'utiliser pour réaliser cet atelier.

Remarque : Si vous utilisez un appareil Chrome OS, exécutez cet atelier dans une fenêtre de navigation privée.

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
    • 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. 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 inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue Se connecter. Cliquez sur Suivant.

  4. Copiez le mot de passe inclus dans le panneau Détails concernant l'atelier et collez-le dans la boîte de dialogue de bienvenue. Cliquez sur Suivant.

    Important : Vous devez utiliser les identifiants fournis dans le panneau de gauche. Ne saisissez pas vos identifiants Google Cloud Skills Boost. Remarque : Si vous utilisez votre propre compte Google Cloud pour cet atelier, des frais supplémentaires peuvent vous être facturés.
  5. 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 aux essais offerts.

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

Remarque : Vous pouvez afficher le menu qui contient la liste des produits et services Google Cloud en cliquant sur le menu de navigation en haut à gauche. Icône du menu de navigation

Activer Google Cloud Shell

Google Cloud Shell est une machine virtuelle qui contient des outils pour les développeurs. Elle comprend un répertoire d'accueil persistant de 5 Go et s'exécute sur Google Cloud. Google Cloud Shell offre un accès en ligne de commande à vos ressources GCP.

  1. Dans la console GCP, dans la barre d'outils située en haut à droite, cliquez sur le bouton Ouvrir Cloud Shell.

    Icône Cloud Shell

  2. Cliquez sur Continue (Continuez):

    cloudshell_continue

Il faut quelques instants pour mettre en service et se connecter à l'environnement. Lorsque vous êtes connecté, vous êtes déjà authentifié et le projet est défini sur votre PROJECT_ID. Par exemple:

Terminal Cloud Shell

gcloud est l'outil de ligne de commande associé à Google Cloud Platform. Pré-installé sur Cloud Shell, il est également compatible avec la saisie semi-automatique via la touche de tabulation.

Vous pouvez répertorier les noms des comptes actifs à l'aide de cette commande :

gcloud auth list

Résultat :

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

Pour répertorier les ID de projet, exécutez la commande suivante :

gcloud config list project
	

Résultat :

[core]
project = <ID_Projet>
	

Exemple de résultat :

[core]
project = qwiklabs-gcp-44776a13dea667a6
	

Google Kubernetes Engine

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

gcloud config set compute/zone us-central1-b

Après avoir défini la zone, démarrez un cluster que vous utiliserez dans cet atelier :

gcloud container clusters create io

Remarque : La création du cluster peut prendre du temps, car Kubernetes Engine provisionne quelques machines virtuelles en arrière-plan pour vous.

Obtenir l'exemple de code

Clonez le dépôt GitHub à partir de la ligne de commande de Cloud Shell :

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

Accédez au répertoire requis pour ce laboratoire:

cd orchestrate-with-kubernetes/kubernetes

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

ls

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

deployments/  /* Fichiers manifestes de déploiement */
  ...
nginx/        /* Fichiers de configuration nginx */
  ...
pods/         /* Fichiers manifestes du pod */
  ...
services/     /* Fichiers manifestes des services */
  ...
tls/          /* Certificats TLS */
  ...
cleanup.sh    /* Script de nettoyage */

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

Démonstration rapide de Kubernetes

Pour commencer à utiliser Kubernetes, le plus simple est de saisir la commande kubectl create. 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. Les déploiements seront traités plus en détail ultérieurement. Pour l'instant, retenez simplement qu'ils permettent aux pods de continuer à fonctionner, même en cas d'échec des nœuds sur lesquels ils sont exécutés.

Dans Kubernetes, tous les conteneurs sont exécutés dans un pod. Utilisez la commande kubectl get pods pour afficher le conteneur "nginx" en cours d'exécution :

kubectl get pods

Une fois que 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".

Maintenant, affichez les services à l'aide de la commande de services kubectl get :

kubectl get services

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

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

curl http://<External IP>:80

Et voilà ! Kubernetes offre un flux de travail facile à utiliser et prêt à l'emploi à l'aide des commandes d'exécution et d'exposition kubectl.

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) ci-dessous pour vérifier votre progression dans l'atelier. Si le cluster Kubernetes et le déploiement du conteneur "nginx" ont correctement été créés, vous recevez une note d'évaluation.

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

Maintenant que vous avez découvert Kubernetes, vous pouvez observer chacun des composants et des abstractions.

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, ceux-ci sont contenus dans un seul pod.

fb02d86798243fcb.png

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 en réseau. Cela signifie qu'il existe une adresse IP par pod.

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

Créer des pods

Les pods peuvent être créés à l'aide de fichiers de configuration de pods. Prenons un moment pour examiner le fichier de configuration du pod "monolith". Pour ce faire, exécutez la commande suivante :

cat pods/monolith.yaml

Le résultat affiche le fichier de configuration ouvert :

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 lors de son démarrage.
  • Vous ouvrez le port 80 pour le trafic http.

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

kubectl create -f pods/monolith.yaml

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 démarrage du pod "monolith" peut prendre quelques secondes. L'image du conteneur "monolith" doit être extraite de Docker Hub pour que l'on puisse exécuter le pod.

Lorsque le pod est en cours d'exécution, utilisez la commande kubectl describe pour obtenir plus d'informations sur le pod "monolith" :

kubectl describe pods monolith

De nombreuses informations sur le pod "monolith" s'affichent, telles que 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 en partageant 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 !

Interagir avec des pods

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

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

Ouvrez deux terminaux Cloud Shell. L'un pour exécuter la commande kubectl port-forward et l'autre pour émettre des commandes curl.

Dans le second terminal, exécutez la commande suivante pour configurer le transfert de port :

kubectl port-forward monolith 10080:80

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

curl http://127.0.0.1:10080

Mission accomplie. Votre conteneur vous salue chaleureusement ("hello") !

Utilisez à présent la commande curl pour découvrir ce qu'il 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 !

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

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

La connexion entraîne l'affichage d'un jeton JWT. Étant donné que Cloud Shell n'est pas capable de copier de longues chaînes correctement, créez une variable d'environnement pour le jeton.

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

Saisissez le mot de passe top-secret "password" à nouveau lorsque vous y êtes invité.

Utilisez cette commande pour effectuer la copie et utilisez le jeton 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 devriez désormais recevoir une réponse de l'application vous indiquant que tout est rentré dans l'ordre.

Utilisez la commande kubectl logs pour afficher les journaux relatifs au pod monolith.

kubectl logs monolith

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

kubectl logs -f monolith

Maintenant, 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

Utilisez la commande kubectl exec pour exécuter une interface système interactive au sein du pod "monolith". Cette opération 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

Par exemple, lorsqu'une interface système se trouve dans le conteneur "monolith", vous pouvez tester la connectivité externe avec la commande ping :

ping -c 3 google.com

Veillez à vous déconnecter lorsque vous cessez d'utiliser cette interface système interactive.

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 une interface de connexion, Kubernetes vous fournit tout ce dont vous avez besoin.

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 tests de vivacité ou de disponibilité échouent, par exemple), ce qui entraîne un problème :

Que se passe-t-il si vous souhaitez communiquer avec un ensemble de pods ? Lors du 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.

393e02e1d49f3b37.png

Les services utilisent des libellés pour déterminer les pods qu'ils gèrent. Si les pods sont correctement libellés, 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 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 de libellés pour exposer un ensemble limité de pods en externe.

Créer un service

Avant de commencer à créer des services, créez tout d'abord un pod sécurisé capable de gérer le trafic https.

Si vous avez modifié les répertoires, veillez à bien revenir au répertoire ~/orchestrate-with-kubernetes/kubernetes :

cd ~/orchestrate-with-kubernetes/kubernetes

Examinez le fichier de configuration du service "monolith" :

cat pods/secure-monolith.yaml

Créez les pods "secure-monolith" et leurs 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é. Il est temps d'exposer le pod "secure-monolith" en externe. Pour ce faire, créez un service Kubernetes.

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

Éléments à noter :

  1. Un sélecteur est utilisé pour trouver et exposer automatiquement tous les pods disposant des libellés app: monolith et secure: enabled.
  2. Vous devez à présent exposer le port du nœud, car c'est ainsi que le trafic externe du port 31000 est transféré à "nginx" (sur le port 443).

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 Check my progress (Vérifier ma progression) ci-dessous pour vérifier votre progression dans l'atelier. Si les pods et le service "monolith" ont correctement été créés, vous recevez une note d'évaluation.

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.

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

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

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) ci-dessous pour vérifier votre progression dans l'atelier. Si la règle du pare-feu permettant d'autoriser le trafic TCP sur le port 31000 a correctement été créée, vous recevez une note d'évaluation.

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

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

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

gcloud compute instances list

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

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

Mince. La requête a expiré. Où est le problème ?

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" ?
  • Quels libellés doivent être associés à un pod pour que ce dernier soit sélectionné par le service "monolith" ?

Indice : Le problème est en lien avec les libellés. Vous le résoudrez dans la prochaine section.

Ajouter des libellés à 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 de libellé.

Nous pouvons observer que plusieurs pods s'exécutent avec le libellé "monolith".

kubectl get pods -l "app=monolith"

Qu'en est-il des libellés "app=monolith" et "secure=enabled" ?

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

Remarquez que cette requête de libellé ne renvoie aucun résultat. Il semblerait que vous deviez ajouter le libellé "secure=enabled" aux pods.

Utilisez la commande kubectl label pour ajouter le libellé secure=enabled manquant au pod "secure-monolith". Vous pouvez ensuite vérifier et observer que les libellés ont été mis à jour.

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

Maintenant que vos pods sont correctement libellés, consultez la liste des points de terminaison sur le service "monolith" :

kubectl describe services monolith | grep Endpoints

Il y en a un !

Testez-le en appelant à 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 Check my progress (Vérifier ma progression) ci-dessous pour vérifier votre progression dans l'atelier. Si le libellé a correctement été ajouté aux pods "monolith", vous recevez une note d'évaluation.

Ajouter des libellés à un pod

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 désiré (spécifié par l'utilisateur).

f96989028fa7d280.pngLes déploiements permettent, et c'est leur principal avantage, de supprimer les tâches de bas niveau dans la gestion des pods. Ils utilisent des Replica Sets (Ensembles d'instances dupliquées) 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.

Voici un exemple rapide :

b2e31eed284e4cfe.png

Les pods sont liés à la durée de vie du nœud sur lequel ils sont créés. Dans l'exemple ci-dessus, "Node3" s'est arrêté (entraînant également l'arrêt d'un pod). Plutôt que de créer manuellement un pod et de lui trouver un nœud, votre déploiement a créé un pod qui a démarré 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.

Créer des déploiements

Nous allons 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.

Nous sommes prêts à créer des déploiements, un pour chaque service. Ensuite, nous définirons 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.

Commencez par examiner le fichier de configuration de déploiement "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 dupliquée, et nous utilisons la version 2.0.0 du conteneur "auth".

L'exécution de la commande kubectl create pour créer le déploiement "auth" crée 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 des instances dupliquées.

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

kubectl create -f deployments/auth.yaml

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

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

Et 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

Le déploiement "frontend" nécessite une étape supplémentaire, car vous devez stocker quelques données de configuration avec le conteneur.

Interagissez avec "frontend" en capturant son adresse IP externe, puis en l'appelant à l'aide de la commande "curl" :

kubectl get services frontend

Remarque : la génération de l'adresse IP externe peut prendre une minute. Exécutez à nouveau la commande ci-dessus si l'état de la colonne EXTERNAL-IP est en attente.

curl -k https://<EXTERNAL-IP>

Vous obtenez la réponse "hello" !

Tester la tâche terminée

Cliquez sur Check my progress (Vérifier ma progression) ci-dessous pour vérifier votre progression dans l'atelier. Si les déploiements Auth, Hello et Frontend ont correctement été créés, vous recevez une note d'évaluation.

Création de déploiements (Auth, Hello et Frontend)

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.

ac89564fa3705b3a.png 6d0798e24a18671b.png

Terminer votre quête

Cet atelier d'auto-formation fait partie des quêtes Qwiklabs Cloud Architecture et Kubernetes in the Google Cloud. Une quête est une série d'ateliers associés qui constituent une formation. Si vous terminez cette quête, vous obtiendrez le badge ci-dessus attestant de votre réussite. Vous pouvez rendre publics les badges que vous recevez et ajouter leur lien dans votre CV en ligne ou sur vos comptes de réseaux sociaux. Inscrivez-vous à cette quête pour obtenir immédiatement les crédits associés à cet atelier si vous l'avez suivi. Découvrez les autres quêtes Qwiklabs disponibles.

Vous recherchez un laboratoire de défis pratique pour démontrer vos compétences Kubernetes et valider vos connaissances? Une fois cette quête terminée, terminez ce laboratoire de défis supplémentaire pour recevoir un badge numérique Google Cloud exclusif.

Atelier suivant

Poursuivez votre quête avec l'un des ateliers suivants :

Étapes suivantes et informations supplémentaires

Google Cloud Training & Certification

...helps you make the most of Google Cloud technologies. Our classes include technical skills and best practices to help you get up to speed quickly and continue your learning journey. We offer fundamental to advanced level training, with on-demand, live, and virtual options to suit your busy schedule. Certifications help you validate and prove your skill and expertise in Google Cloud technologies.

Dernière mise à jour du manuel : 30 août 2021
Dernier test de l'atelier : 30 août 2021

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.