Base de connaissances > Workshop > DevOps #6 - Observability > Labs 4 - APM

Labs 4 - APM

Objectif : Dans ce laboratoire, vous apprendrez comment il est facile d’utiliser APM pour instrumenter les applications afin de collecter des informations détaillées sur les performances ainsi que les erreurs et les envoyer à votre déploiement Elasticsearch. Vous explorerez également l’application APM Kibana et verrez avec quelle facilité vous pouvez surveiller les performances des applications.

Avant de commencer, examinez l’architecture que vous mettez en œuvre à travers les étapes du laboratoire, comme décrit dans l’image ci-dessous.

Vous avez déjà votre déploiement Elasticsearch en cours d’exécution avec le serveur APM configuré pour y envoyer des données et Kibana pour en extraire des données. Dans les étapes suivantes, vous allez instrumenter Petclinic pour ensuite explorer le traçage distribué à travers l’application APM dans Kibana. Petclinic est une application de démonstration composée de plusieurs applications et services différents. Le frontend est une application React qui s’exécute sur le navigateur du client. Le frontend est servi par un serveur backend Node.js qui écoute sur le port 4000. Le serveur backend envoie par proxy toutes les requêtes du frontend au noyau applicatif, afin qu’il puisse les traiter. Le noyau de l’application est une mise en œuvre de l’API REST qui se connecte aux bases de données. Il est implémenté avec le framework Spring et écoute sur le port 8080. Pour surveiller cette architecture, vous utiliserez l’agent Java pour le noyau de l’application, l’agent Node.js pour le serveur backend et l’agent RUM pour le frontend.

Tout d’abord, vous devez obtenir le point de terminaison du serveur APM et le jeton secret d’Elastic Cloud, afin de pouvoir configurer les agents APM pour envoyer des données à votre déploiement. Vous pouvez accéder à ces informations en cliquant sur APM & Fleet dans la navigation latérale de votre déploiement d’observabilité.

Copiez le point de terminaison du serveur APM et le jeton secret quelque part, car vous en aurez besoin dans les prochaines étapes du laboratoire.

Ensuite, vous allez démarrer le noyau de l’application. Pour ce faire, ouvrez un nouveau terminal.
L’étape suivante consisterait à télécharger la dernière version du fichier jar de l’agent, mais l’environnement de laboratoire dispose déjà de la version dont vous avez besoin pour exécuter les travaux pratiques.

ls petclinic/elastic-apm-agent-1.21.0.jar

Utilisez la commande suivante pour démarrer le noyau de l’application Petclinic. Avant de l’exécuter, remplacez APM_SERVER_ENDPOINT et APM_SERVER_TOKEN par le point de terminaison et le jeton secret du serveur APM que vous avez copiés de votre déploiement d’observabilité.

java -javaagent:/home/elastic/petclinic/elastic-apm-agent-1.21.0.jar \
  -Delastic.apm.service_name=petclinic-spring \
  -Delastic.apm.server_urls=APM_SERVER_ENDPOINT:443 \
  -Delastic.apm.secret_token=APM_SERVER_TOKEN \
  -Delastic.apm.environment=production \
  -Delastic.apm.application_packages=org.springframework.samples.petclinic \
  -jar /home/elastic/petclinic/spring-petclinic-1.5.16.jar

Notez que vous n’avez pas besoin de déclarer une dépendance à l’agent dans votre application, mais vous devez seulement télécharger l’agent et ajouter l’indicateur -javaagent avec le chemin vers l’agent jar lors du démarrage de votre application. Vous devez également spécifier le paramètre elastic.apm.service_name comme étant le nom du service qui apparaîtra dans l’application APM, tandis que elastic.apm.server_urls est le paramètre qui définit l’endroit où le serveur APM est exécuté et elastic.apm.secret_token fournit les informations d’identification pour accéder au serveur APM. Les paramètres elastic.apm.environment et elastic.apm.application_packages sont facultatifs, bien que le premier facilite la navigation dans les données APM à partir d’un environnement spécifique lorsque vous en avez plusieurs, tandis que le second aide l’application APM à réduire les cadres de pile du code de la bibliothèque et à mettre en évidence les cadres de pile provenant de votre application.

Après avoir remplacé le point de terminaison du serveur APM et le jeton secret, la ligne de commande doit ressembler à ce qui suit :

java -javaagent:/home/elastic/petclinic/elastic-apm-agent-1.21.0.jar \
  -Delastic.apm.service_name=petclinic-spring \
  -Delastic.apm.server_urls=https://eff3c852b8824329a0f648d6769c2bcc.apm.europe-west1.gcp.cloud.es.io:443 \
  -Delastic.apm.secret_token=5bj8AYcnS7DSrlqVr9 \
  -Delastic.apm.environment=production \
  -Delastic.apm.application_packages=org.springframework.samples.petclinic \
  -jar /home/elastic/petclinic/spring-petclinic-1.5.16.jar

Ensuite, vous allez démarrer le backend de l’application qui sert le frontend. Pour ce faire, ouvrez une nouvelle fenêtre de terminal.
Accédez au répertoire petclinic/frontend :

cd petclinic/frontend

Le serveur backend et le frontend ont déjà installé les agents Node.js et RUM, respectivement. Cela signifie que vous devez seulement vous assurer que leurs configurations sont correctes avant de démarrer le serveur backend. Vérifiez donc comment l’agent Node.js est requis et démarré en haut du fichier principal bin/www.

head bin/www

Vous devriez voir les configurations suivantes :

#!/usr/bin/env node
const settings = require('../config')
var apm = require('elastic-apm-node').start({
  serviceName: settings.apm_service_name,
  serviceVersion: settings.apm_service_version,
  serverUrl: settings.apm_server,
  ....

Notez comment le fichier config.js est utilisé pour définir les paramètres serviceName, serviceVersion, et serverUrl pour l’agent Node.js.

Vous devez également spécifier le secretToken, afin que l’agent Node.js puisse accéder au serveur APM qui fonctionne sur votre déploiement en nuage. Editez bin/www et ajoutez la ligne suivante à l’objet de configuration.

 secretToken: settings.apm_server_token,

Après avoir modifié le haut du fichier bin/www, il devrait ressembler à ceci :

#!/usr/bin/env node
const settings = require('../config')
var apm = require('elastic-apm-node').start({
  serviceName: settings.apm_service_name,
  serviceVersion: settings.apm_service_version,
  serverUrl: settings.apm_server,
  secretToken: settings.apm_server_token,
  ...

Vérifiez les configurations définies par le fichier config.js.

cat config.js

Vous devriez voir la déclaration d’objet suivante :

var config = {
  apm_server: process.env.ELASTIC_APM_SERVER_URL || 'http://localhost:8200',
  apm_server_js: process.env.ELASTIC_APM_SERVER_JS_URL || 'http://localhost:8200',
  apm_service_name: process.env.ELASTIC_APM_SERVICE_NAME || 'petclinic-node',
  apm_client_service_name: process.env.ELASTIC_APM_CLIENT_SERVICE_NAME || 'petclinic-react',
  apm_service_version: process.env.ELASTIC_APM_SERVICE_VERSION || '1.0.0',
  api_server: process.env.API_SERVER || 'http://localhost:8080',
  api_prefix: process.env.API_PREFIX || '/petclinic/api',
  address_server: process.env.ADDRESS_SERVER || 'http://localhost:5000',
  distributedTracingOrigins: process.env.DISTRIBUTED_TRACINGS_ORIGINS || 'http://petclinic-client:3000,http://petclinic-server:8000,http://localhost:4000,http://localhost:8080,http://localhost:8081'
}

Notez comment les définitions apm_service_name, apm_service_version et apm_server sont liées à la configuration de l’agent Node.js dans l’étape précédente. Vous allez modifier ce fichier de configuration dans les étapes suivantes pour vous assurer que les agents Node.js et RUM peuvent atteindre votre serveur APM.

Commencez par modifier config.js pour ajouter apm_server_token à la déclaration de l’objet comme suit. Notez que vous devez remplacer APM_SERVER_TOKEN par le jeton secret que vous avez copié de votre observability-deployment.

apm_server_token: process.env.ELASTIC_APM_SECRET_TOKEN || 'APM_SERVER_TOKEN',

Après avoir modifié config.js, la déclaration d’objet devrait ressembler à ceci :

var config = {
  apm_server_token: process.env.ELASTIC_APM_SECRET_TOKEN || '5bj8AYcnS7DSrlqVr9',
  apm_server: process.env.ELASTIC_APM_SERVER_URL || 'http://localhost:8200',
  apm_server_js: process.env.ELASTIC_APM_SERVER_JS_URL || 'http://localhost:8200',
  apm_service_name: process.env.ELASTIC_APM_SERVICE_NAME || 'petclinic-node',
  apm_client_service_name: process.env.ELASTIC_APM_CLIENT_SERVICE_NAME || 'petclinic-react',
  apm_service_version: process.env.ELASTIC_APM_SERVICE_VERSION || '1.0.0',
  api_server: process.env.API_SERVER || 'http://localhost:8080',
  api_prefix: process.env.API_PREFIX || '/petclinic/api',
  address_server: process.env.ADDRESS_SERVER || 'http://localhost:5000',
  distributedTracingOrigins: process.env.DISTRIBUTED_TRACINGS_ORIGINS || 'http://petclinic-client:3000,http://petclinic-server:8000,http://localhost:4000,http://localhost:8080,http://localhost:8081'
}

Ensuite, éditez config.js et modifiez apm_server pour utiliser le point de terminaison de votre serveur APM avec le port 443 au lieu de http://localhost:8200. Après avoir fait cela, vous avez configuré les paramètres qui permettent à l’agent Node.js de communiquer avec le serveur APM exécuté sur votre déploiement.

Après avoir modifié config.js, la déclaration d’objet devrait ressembler à ceci :

var config = {
  apm_server_token: process.env.ELASTIC_APM_SECRET_TOKEN || '5bj8AYcnS7DSrlqVr9',
  apm_server: process.env.ELASTIC_APM_SERVER_URL || 'https://eff3c852b8824329a0f648d6769c2bcc.apm.europe-west1.gcp.cloud.es.io:443',
  apm_server_js: process.env.ELASTIC_APM_SERVER_JS_URL || 'http://localhost:8200',
  apm_service_name: process.env.ELASTIC_APM_SERVICE_NAME || 'petclinic-node',
  apm_client_service_name: process.env.ELASTIC_APM_CLIENT_SERVICE_NAME || 'petclinic-react',
  apm_service_version: process.env.ELASTIC_APM_SERVICE_VERSION || '1.0.0',
  api_server: process.env.API_SERVER || 'http://localhost:8080',
  api_prefix: process.env.API_PREFIX || '/petclinic/api',
  address_server: process.env.ADDRESS_SERVER || 'http://localhost:5000',
  distributedTracingOrigins: process.env.DISTRIBUTED_TRACINGS_ORIGINS || 'http://petclinic-client:3000,http://petclinic-server:8000,http://localhost:4000,http://localhost:8080,http://localhost:8081'
}

Ensuite, éditez config.js et modifiez apm_server_js pour utiliser le point de terminaison de votre serveur APM avec le port 443 au lieu de http://localhost:8200. Après avoir fait cela, vous configurez l’agent RUM à partir de public/index.js pour collecter les données APM dans le navigateur du client et les envoyer à votre serveur APM.

IMPORTANT : Notez qu’il y a deux configurations : apm_server et apm_server_js. La première est utilisée par le serveur backend, tandis que la seconde est utilisée par le frontend. Il y a deux configurations différentes parce que les agents Node.js et RUM peuvent accéder au serveur APM par des points d’accès différents. En particulier, le frontend s’exécutera sur le navigateur du client et doit savoir comment atteindre le serveur APM par une adresse publique. Notez également que le jeton secret n’est pas applicable à l’agent RUM, car il n’y a aucun moyen de l’empêcher d’être exposé publiquement.

Après avoir modifié config.js, la déclaration d’objet devrait ressembler à ceci :

var config = {
  apm_server_token: process.env.ELASTIC_APM_SECRET_TOKEN || '5bj8AYcnS7DSrlqVr9',
  apm_server: process.env.ELASTIC_APM_SERVER_URL || 'https://eff3c852b8824329a0f648d6769c2bcc.apm.europe-west1.gcp.cloud.es.io:443',
  apm_server_js: process.env.ELASTIC_APM_SERVER_JS_URL || 'https://eff3c852b8824329a0f648d6769c2bcc.apm.europe-west1.gcp.cloud.es.io:443',
  apm_service_name: process.env.ELASTIC_APM_SERVICE_NAME || 'petclinic-node',
  apm_client_service_name: process.env.ELASTIC_APM_CLIENT_SERVICE_NAME || 'petclinic-react',
  apm_service_version: process.env.ELASTIC_APM_SERVICE_VERSION || '1.0.0',
  api_server: process.env.API_SERVER || 'http://localhost:8080',
  api_prefix: process.env.API_PREFIX || '/petclinic/api',
  address_server: process.env.ADDRESS_SERVER || 'http://localhost:5000',
  distributedTracingOrigins: process.env.DISTRIBUTED_TRACINGS_ORIGINS || 'http://petclinic-client:3000,http://petclinic-server:8000,http://localhost:4000,http://localhost:8080,http://localhost:8081'
}

Démarrer le backend pour servir le frontend :

npm start

Notez que les agents RUM et Node.js sont déjà déclarés comme dépendants des applications frontale et dorsale, respectivement. Les paramètres apm_client_service_name et apm_service_name présents dans le fichier config.js définissent le nom du service tel qu’il apparaîtra dans l’application APM.

Maintenant que les trois microservices sont en cours d’exécution, accédez à la page Web de Petclinic et vous devriez voir la page d’accueil suivante :

Cliquez sur FIND OWNERS et VETERINARIANS pour générer des données de performance à envoyer au serveur APM.
Cliquez sur ERROR pour générer des erreurs qui seront envoyées au serveur APM. Assurez-vous que vous obtenez le statut 404 et le message d’erreur No message available comme suit :

Si vous n’obtenez pas cette erreur, cliquez sur HOME et cliquez à nouveau sur ERROR jusqu’à ce que vous obteniez cette erreur.

Lancez l’application APM pour commencer à explorer les données collectées.

Pour lancer l’application APM, accédez à APM & Fleet via le menu de navigation de votre déploiement d’observabilité et cliquez sur le lien Ouvrir juste à côté de l’étiquette APM. Vous pouvez également lancer APM via la page principale de votre déploiement.

Après avoir lancé l’application APM, vous accédez à l’aperçu des services.

Maintenant, cliquez sur Service Map pour vérifier l’architecture Petclinic. Notez comment il décrit que petclinic-react se connecte à petclinic-node qui se connecte à petclinic-spring, qui est connecté à la base de données.

Cliquez sur petclinic-react pour obtenir des mesures de haut niveau comme la latence moyenne et le débit moyen.

Cliquez sur Détails du service pour explorer la santé globale du front-end en vérifiant les métriques sur les transactions, les erreurs et l’infrastructure.

Ensuite, cliquez sur l’aperçu des transactions et sélectionnez le type de transaction http-request pour explorer les requêtes du frontend.

Ensuite, cliquez sur GET /api/vets pour explorer le traçage distribué et voir comment les applications et les services interagissent entre eux.

Ensuite, cliquez sur l’aperçu des erreurs pour explorer les erreurs de l’application.

Ensuite, cliquez sur l’erreur “Aucun message disponible” pour voir la trace de la pile qui indique l’origine de l’erreur.

Enfin, cliquez sur la transaction GET /api/error pour voir les erreurs associées et comment elles se sont propagées parmi les services.

Résumé : Dans ce laboratoire, vous avez appris comment il est facile de configurer des agents APM pour collecter des informations de trace et des erreurs afin de les indexer dans Elasticsearch. Vous avez également exploré l’application APM Kibana et vu avec quelle facilité vous pouvez surveiller les performances des applications.