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

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 (recommandé) ou de navigation privée pour effectuer cet atelier. Vous éviterez ainsi les conflits entre votre compte personnel et le compte temporaire de participant, qui pourraient entraîner des frais supplémentaires facturés sur votre compte personnel.

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

Remarque : Utilisez uniquement le compte de participant pour cet atelier. Si vous utilisez un autre compte Google Cloud, des frais peuvent être facturés à ce compte.

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, une boîte de dialogue 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 sans frais.

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

Remarque : Pour accéder aux produits et services Google Cloud, cliquez sur le menu de navigation ou saisissez le nom du service ou du produit dans le champ Recherche.

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.

2. Passez les fenêtres suivantes :

   • Accédez à la fenêtre d'informations de Cloud Shell.
   • Autorisez Cloud Shell à utiliser vos identifiants pour effectuer des appels d'API 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 l'ID_PROJET pour cette session :

Your Cloud Platform project in this session is set to {{{project_0.project_id | "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.

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

gcloud auth list

4. Cliquez sur Autoriser.

Résultat :

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} 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 = {{{project_0.project_id | "PROJECT_ID"}}} Remarque : Pour consulter la documentation complète sur gcloud, dans Google Cloud, accédez au guide de présentation de la gcloud CLI.

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.

PROJECT=$(gcloud config get-value project) REGION={{{ project_0.default_region | "REGION" }}} ZONE={{{ project_0.default_zone | "ZONE" }}} CLUSTER=gke-load-test TARGET=${PROJECT}.appspot.com gcloud config set compute/region $REGION gcloud config set compute/zone $ZONE

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 :

gsutil -m cp -r gs://spls/gsp182/distributed-load-testing-using-kubernetes .

2. Accédez au répertoire :

cd distributed-load-testing-using-kubernetes/

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

gcloud builds submit --tag gcr.io/$PROJECT/locust-tasks:latest docker-image/.

Exemple de résultat :

ID CREATE_TIME DURATION SOURCE IMAGES STATUS 47f1b8f7-0b81-492c-aa3f-19b2b32e515d xxxxxxx 51S gs://project_id_cloudbuild/source/1554261539.12-a7945015d56748e796c55f17b448e368.tgz gcr.io/project_id/locust-tasks (+1 more) SUCCESS

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 :

gcloud app deploy sample-webapp/app.yaml

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

Please choose the region where you want your App Engine application located:

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.

Please enter your numeric choice: 10 Remarque : Vous aurez besoin de l'URL de l'exemple d'application Web déployée avec les déploiements locust-master et locust-worker. Cette URL est déjà stockée dans la variable TARGET.

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 :

gcloud container clusters create $CLUSTER \ --zone $ZONE \ --num-nodes=5

Exemple de résultat :

NAME: gke-load-test LOCATION: {{{ project_0.default_zone | "ZONE" }}} MASTER_VERSION: 1.11.7-gke.12 MASTER_IP: 34.66.156.246 MACHINE_TYPE: n1-standard-1 NODE_VERSION: 1.11.7-gke.12 NUM_NODES: 5 STATUS: RUNNING

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 :

ports: - name: loc-master-web containerPort: 8089 protocol: TCP - name: loc-master-p1 containerPort: 5557 protocol: TCP - name: loc-master-p2 containerPort: 5558 protocol: TCP

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.

sed -i -e "s/\[TARGET_HOST\]/$TARGET/g" kubernetes-config/locust-master-controller.yaml sed -i -e "s/\[TARGET_HOST\]/$TARGET/g" kubernetes-config/locust-worker-controller.yaml sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kubernetes-config/locust-master-controller.yaml sed -i -e "s/\[PROJECT_ID\]/$PROJECT/g" kubernetes-config/locust-worker-controller.yaml

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

kubectl apply -f kubernetes-config/locust-master-controller.yaml

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

kubectl get pods -l app=locust-master

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

kubectl apply -f kubernetes-config/locust-master-service.yaml

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 :

kubectl get svc locust-master

Exemple de résultat :

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE locust-master LoadBalancer 10.59.244.88 35.222.161.198 8089:30865/TCP,5557:30707/TCP,5558:31327/TCP 1m

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 :

apiVersion: "apps/v1" kind: "Deployment" metadata: name: locust-worker labels: name: locust-worker spec: replicas: 5 selector: matchLabels: app: locust-worker template: metadata: labels: app: locust-worker spec: ...

Déployer locust-worker

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

kubectl apply -f kubernetes-config/locust-worker-controller.yaml

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 :

kubectl get pods -l app=locust-worker

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 :

kubectl scale deployment/locust-worker --replicas=20

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

kubectl get pods -l app=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 :

EXTERNAL_IP=$(kubectl get svc locust-master -o yaml | grep ip: | awk -F": " '{print $NF}') echo http://$EXTERNAL_IP:8089

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.