GSP182

Présentation

Dans cet atelier, vous allez apprendre à utiliser Kubernetes Engine pour déployer un framework de tests de charge distribués. Le framework a recours à plusieurs conteneurs afin de créer un trafic de tests de charge pour une API simple basée sur REST. Bien que cette solution teste une application Web simple, le même modèle peut être utilisé pour créer des scénarios de test de charge plus complexes, tels que des applications de jeu ou de l'Internet des objets (IoT). Cette solution présente l'architecture générale d'un framework de test de charge basé sur des conteneurs.

Système soumis aux tests

Pour les besoins de cet atelier, le système soumis aux tests est une petite application Web déployée sur Google App Engine. L'application expose les points de terminaison de base de type REST pour enregistrer les requêtes HTTP POST entrantes (les données entrantes ne sont pas conservées).

Exemples de charges de travail

L'application que vous allez déployer a été élaborée sur la base du composant de service de backend présent dans de nombreux déploiements de l'Internet des objets (IoT). Les appareils s'enregistrent d'abord auprès du service, puis commencent à créer des rapports de métriques ou de relevés de capteur, tout en se réenregistrant périodiquement auprès du service.

L'interaction courante des composants de service de backend est semblable à ceci :

Pour modéliser cette interaction, vous allez utiliser Locust, un outil de tests de charge distribués basé sur Python, capable de distribuer des requêtes sur plusieurs chemins d'accès cibles. Par exemple, Locust peut distribuer des requêtes sur les chemins d'accès cibles /login et /metrics.

La charge de travail est basée sur l'interaction décrite ci-dessus et est modélisée en tant qu'ensemble de tâches dans Locust. Pour se rapprocher des clients du monde réel, chaque tâche Locust est pondérée. Par exemple, l'enregistrement se produit tous les milliers de requêtes client.

Solutions de calcul basées sur des conteneurs

• L'image du conteneur Locust est une image Docker contenant le logiciel Locust.

• Un cluster de conteneurs se compose d'au moins un maître de cluster et de plusieurs nœuds de calcul appelés « nœuds ». Ces machines maîtres et nœuds exécutent le système d’orchestration de cluster Kubernetes. Pour plus d'informations sur les clusters, consultez la documentation de Kubernetes Engine

• Un pod est un ensemble d'un ou de plusieurs conteneurs déployés ensemble sur un même hôte, ainsi que l'unité de calcul la plus petite pouvant être définie, déployée et gérée. Certains pods ne contiennent qu'un seul conteneur. Par exemple, dans cet atelier, chacun des conteneurs Locust s'exécute dans son propre pod.

• Un contrôleur de déploiement fournit des mises à jour déclaratives pour les Pods et les ReplicaSets. Cet atelier comprend deux déploiements : l'un pour locust-master et l'autre pour locust-worker.

Services

Un pod spécifique peut disparaître pour plusieurs raisons : par exemple, en cas de défaillance des nœuds ou d'une interruption volontaire des nœuds pour effectuer des opérations de mises à jour ou de maintenance. Cela signifie que l'adresse IP d'un pod ne fournit pas une interface suffisamment fiable. Une approche plus fiable serait d'utiliser une représentation abstraite de cette interface qui ne change jamais, même si le pod sous-jacent disparaît et est remplacé par un nouveau pod avec une adresse IP différente. Un service Kubernetes Engine fournit ce type d'interface abstraite en définissant un ensemble logique de pods et une stratégie permettant d'y accéder.

Dans cet atelier, plusieurs services représentent des pods ou des ensembles de pods. Par exemple, il existe un service pour le pod du serveur DNS, un autre service pour le pod maître Locust et un service représentant les 10 pods de nœuds de calcul Locust.

Le schéma ci-dessous illustre le contenu des nœuds maîtres et des nœuds de calcul :

Points abordés

• Créer un système soumis aux tests, c'est-à-dire, une petite application Web déployée sur Google App Engine
• Utiliser Kubernetes Engine pour déployer un framework de tests de charge distribués
• Créer un trafic de test de charge pour une API REST simple

Prérequis

• Bonne connaissance des services Google Cloud App Engine et Kubernetes Engine
• Bonne connaissance des éditeurs de texte Linux standards tels que Vim, Emacs ou nano

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) ;

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

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 :

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 :

3. Cliquez sur Autoriser.

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

Résultat :

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

Résultat :

Exemple de résultat :

Tâche 1 : Définir le projet et la zone

• Définissez les variables d'environnement pour l'ID du projet, la région et la zone que vous voulez utiliser pour cet atelier.

Tâche 2 : Obtenir l'exemple de code et créer une image Docker pour l'application

1. Récupérez le code source à partir du dépôt à l'aide de l'instruction suivante :

2. Accédez au répertoire :

3. Créez une image Docker et enregistrez-la dans Container Registry :

Exemple de résultat :

Cliquez sur Vérifier ma progression pour valider l'objectif. Obtenir l'exemple de code et créer une image Docker pour l'application

Tâche 3 : Déployer l'application Web

Le dossier sample-webapp contient une application simple en Python sur Google App Engine, qui correspond au "système soumis aux tests".

• Pour déployer l'application sur votre projet, utilisez la commande gcloud app deploy :

Après avoir exécuté la commande, vous serez invité à effectuer les actions suivantes :

Dans la liste des régions, vous pouvez choisir , car nous avons sélectionné la région pour ce projet. Par exemple, pour choisir us-central, saisissez "10" comme entrée pour l'invite de commande.

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer l'application Web

Tâche 4 : Déployer un cluster Kubernetes

• Créez d'abord le cluster Google Kubernetes Engine à l'aide de la commande gcloud illustrée ci-dessous :

Exemple de résultat :

Cliquez sur Vérifier ma progression pour valider l'objectif. Déployer un cluster Kubernetes

Tâche 5 : Nœud maître de tests de charge

Le premier composant du déploiement est le nœud maître Locust, qui constitue le point d'entrée permettant d'exécuter des tâches de tests de charge décrites ci-dessus. Le nœud maître Locust est déployé avec une seule instance dupliquée, car un seul nœud maître est nécessaire.

La configuration du déploiement du nœud maître spécifie plusieurs éléments, y compris les ports qui doivent être exposés par le conteneur (8089 pour l'interface Web, ainsi que 5557 et 5558 pour la communication avec les nœuds de calcul). Ces informations servent ensuite à la configuration des nœuds de calcul Locust.

L'extrait de code suivant contient la configuration pour les ports :

Tâche 6 : Déployer locust-master

1. Remplacez [TARGET_HOST] et [PROJECT_ID] dans locust-master-controller.yaml et locust-worker-controller.yaml par le point de terminaison déployé et l'ID de projet respectivement.

2. Déployez le nœud maître Locust :

3. Pour vérifier que le pod locust-master est créé, exécutez la commande suivante :

4. Déployez ensuite le service locust-master-service :

Cette étape présente le pod avec un nom DNS interne (locust-master), ainsi que les ports 8089, 5557 et 5558. Lors de cette étape, la directive type: LoadBalancer dans locust-master-service.yaml indiquera à Google Kubernetes Engine de créer une règle de transfert Compute Engine à partir d'une adresse IP publiquement disponible dans le pod locust-master.

5. Pour afficher la règle de transfert que vous venez de créer, exécutez la commande suivante :

Exemple de résultat :

Cliquez sur Vérifier ma progression pour valider l'objectif. Nœud maître de tests de charge

Tâche 7 : Nœuds de calcul de tests de charge

Le composant suivant du déploiement comprend les nœuds de calcul Locust, qui exécutent les tâches de tests de charge décrites ci-dessus. Les nœuds de calcul Locust sont déployés par un seul contrôleur de réplication, qui crée plusieurs pods. Les pods sont répartis dans le cluster Kubernetes. Chaque pod utilise des variables d'environnement afin de contrôler des informations de configuration importantes, telles que le nom d'hôte du système soumis aux tests et le nom d'hôte du nœud maître Locust.

Une fois les nœuds de calcul Locust déployés, vous pouvez revenir à l'interface Web du nœud maître Locust et constater que le nombre d'esclaves correspond au nombre de nœuds de calcul déployés.

L'extrait de code suivant contient la configuration du déploiement pour le nom, les étiquettes et le nombre d'instances répliquées :

Déployer locust-worker

1. Déployez maintenant locust-worker-controller :

2. Le contrôleur locust-worker-controller est configuré pour déployer 5 pods locust-worker. Pour vérifier qu'ils ont été déployés, exécutez la commande suivante :

Pour faire évoluer le nombre d'utilisateurs simulés, une augmentation du nombre de pods de nœuds de calcul Locust est nécessaire. Pour augmenter le nombre de pods déployés par le déploiement, Kubernetes offre la possibilité de redimensionner les déploiements sans les redéployer.

3. La commande suivante permet de faire passer le pool de pods de nœuds de calcul Locust à 20 pods :

4. Pour vérifier que les pods ont été lancés et sont prêts, obtenez la liste des pods locust-worker :

Le schéma suivant illustre la relation entre le nœud maître Locust et les nœuds de calcul Locust :

Cliquez sur Vérifier ma progression pour valider l'objectif. Nœuds de calcul de tests de charge

Tâche 8 : Lancer des tests

1. Pour lancer les tests Locust, obtenez l'adresse IP externe à l'aide de la commande suivante :

2. Cliquez sur le lien et accédez à l'interface Web du nœud maître Locust.

L'interface Web du nœud maître Locust vous permet d'exécuter les tâches de tests de charge sur le système soumis aux tests.

3. Pour commencer, indiquez le nombre total d'utilisateurs à simuler et le taux auquel chaque utilisateur doit être généré.

4. Cliquez ensuite sur "Start swarming" (Démarrer le travail en essaim) pour commencer la simulation. Par exemple, vous pouvez spécifier 300 pour le nombre d'utilisateurs et 10 pour le taux.

5. Cliquez sur Start swarming (Démarrer le travail en essaim).

À mesure que le temps passe et que les utilisateurs apparaissent, les statistiques commencent à regrouper les métriques de simulation, telles que le nombre de requêtes et le nombre de requêtes par seconde.

6. Pour arrêter la simulation, cliquez sur Stop (Arrêter). Les résultats complets peuvent être téléchargés sous forme d'une feuille de calcul.

Félicitations !

Vous avez utilisé Kubernetes Engine pour déployer un framework de tests de charge distribués.

Terminer votre quête

Cet atelier d'auto-formation fait partie de la quête Google Cloud Solutions I: Scaling Your Infrastructure. Une quête est une série d'ateliers associés qui constituent un parcours de formation. Si vous terminez une quête, vous obtenez un badge 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 à n'importe quelle quête contenant cet atelier pour obtenir immédiatement les crédits associés. Découvrez toutes les quêtes disponibles dans le catalogue Google Cloud Skills Boost.

Atelier suivant

Continuez sur votre lancée en suivant le prochain atelier ou l'un des ateliers Google Cloud Skills Boost suivants :

• Livraison continue avec Jenkins dans Kubernetes Engine
• Déployer Memcached sur Kubernetes Engine

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 modification du manuel : 12 octobre 2023

Dernier test de l'atelier : 12 octobre 2023

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.