Exercice - Utiliser des données OpenTelemetry dans une application native cloud

15 minutes

Dans cet exercice, vous bénéficiez d’une meilleure visibilité de toutes les données générées par OpenTelemetry dans votre application. Vous avez fini d’ajouter des fonctionnalités de diagnostic au service Store. Avec cela en place, vous ajoutez Prometheus et Grafana aux eShopLite services et examinez certaines des métriques capturées. L’étape suivante consiste à ajouter Zipkin et à afficher les traces distribuées. Enfin, vous ajoutez Application Insights à votre application et utilisez-la pour afficher les données.

Ajouter Prometheus et Grafana

Prometheus et Grafana fournissent des images Docker qui facilitent leur ajout à vos projets. Vous les incluez dans le fichier docker-compose.yml , à la racine de la solution.

Dans le volet EXPLORATEUR , sélectionnez le fichier docker-compose.yml .

Ajoutez ce YAML au bas du fichier :

  prometheus:
    image: prom/prometheus
    container_name: prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    ports:
      - 9090:9090
    restart: unless-stopped
    volumes:
      - ./prometheus:/etc/prometheus

  grafana:
    image: grafana/grafana
    container_name: grafana
    ports:
      - 3000:3000
    restart: unless-stopped
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=grafana
    volumes:
      - ./grafana/datasource:/etc/grafana/provisioning/datasources

Le yaml Docker précédent ajoute deux nouveaux services, Prometheus et Grafana. La section Prometheus configure un conteneur pour répondre sur le port 9090. Il mappe le dossier prometheus en attendant un fichier prometheus.yml . La section Grafana configure un conteneur pour répondre sur le port 3000. Il mappe trois dossiers à l’intérieur d’un dossier grafana .

Configurer Prometheus

Prometheus doit être configuré pour qu’il sache où collecter les métriques. Vous ajoutez un fichier prometheus.yml au dossier prometheus .

Dans le volet EXPLORATEUR , cliquez avec le bouton droit sur le dossier dotnet-observability , puis sélectionnez Nouveau dossier.
Dans le champ nom, entrez prometheus.
Dans le volet Explorateur , cliquez avec le bouton droit sur le dossier prometheus , puis sélectionnez Nouveau fichier.
Dans le champ nom, entrez prometheus.yml.
Dans l’éditeur de fichiers, entrez ce YAML :
```
global:
  scrape_interval: 1s

scrape_configs:
  - job_name: 'products'
    static_configs:
      - targets: ['backend:8080']
  - job_name: 'store'
    static_configs:
      - targets: ['frontend:8080']
```
Le YAML précédent configure Prometheus pour récupérer des métriques à partir des services back-end et front-end . À mesure que l’application s’exécute dans Docker, les noms d’hôtes sont les noms de service.
Sélectionnez Ctrl+S pour enregistrer le fichier.

Configurer Grafana

Grafana doit être configuré pour qu’il sache où collecter les métriques.

Dans le volet EXPLORATEUR , cliquez avec le bouton droit sur le dossier dotnet-observability , puis sélectionnez Nouveau dossier.
Dans le champ nom, entrez grafana.
Cliquez avec le bouton droit sur le dossier grafana , puis sélectionnez Nouveau dossier.
Dans le champ nom, entrez la source de données.
Cliquez avec le bouton droit sur le dossier grafana , puis sélectionnez Nouveau dossier.
Dans le champ nom, entrez tableau de bord.
Développez le dossier grafana , cliquez avec le bouton droit sur le dossier de source de données , puis sélectionnez Nouveau fichier.
Dans le champ nom, entrez datasource.yml.

Sous l’onglet Éditeur, entrez ce YAML :

apiVersion: 1

datasources:
- name: Prometheus
  type: prometheus
  url: http://prometheus:9090 
  isDefault: true
  access: proxy
  editable: true

Le YAML précédent configure Grafana pour utiliser Prometheus comme source de données.

Sélectionnez Ctrl+S pour enregistrer le fichier.

Mettez à jour votre application ASP.NET Core pour exposer des métriques pour Prometheus

À présent, le projet de diagnostics est configuré uniquement pour exposer des métriques à la console. Vous mettez à jour le projet pour exposer des métriques à Prometheus à la place.

Dans le volet TERMINAL en bas, accédez au dossier Diagnostics .
Exécutez cette commande :
```
cd .\eShopLite\Diagnostics\ 
```

Supprimez le OpenTelemetry.Exporter.Console package :

dotnet remove package OpenTelemetry.Exporter.Console

Ajouter le package OpenTelemetry.Exporter.Prometheus.AspNetCore :

dotnet add package OpenTelemetry.Exporter.Prometheus.AspNetCore --prerelease

Dans le volet EXPLORATEUR , développez le dossier Diagnostics , puis sélectionnez DiagnosticServiceCollectionExtensions.cs.
Remplacez l’exportateur .AddConsoleExporter(); de console par ce code :
```
.AddPrometheusExporter();
```
En bas du fichier, avant le dernier }, ajoutez ce code :
```
public static void MapObservability(this IEndpointRouteBuilder routes)
{
  routes.MapPrometheusScrapingEndpoint();
}
```
Ce code ajoute un point de terminaison de récupération Prometheus à chaque service qui inclut cela avec leur application. Cela permet à Prometheus de récupérer des métriques à partir de http://service/metrics.
Sélectionnez Ctrl+S pour enregistrer le fichier.

Exposer des métriques dans le service Store

L’application est actuellement configurée uniquement pour exposer des métriques pour le service Products . Vous mettez également à jour l’application pour exposer des métriques pour le service Store .

Dans le volet EXPLORATEUR , sous l’Explorateur de solutions, cliquez avec le bouton droit sur le projet Store , puis sélectionnez Ajouter une référence de projet.
Sélectionnez Diagnostics.
Dans le volet EXPLORATEUR , développez le dossier Store , puis sélectionnez Program.cs.
Sous le commentaire // Add observability code here, ajoutez un appel à la méthode Diagnostics :
```
builder.Services.AddObservability("Store", builder.Configuration);
```
Avant la app.Run() méthode, ajoutez ce code :
```
app.MapObservability();
```
Cette méthode ajoute le point de terminaison de récupération Prometheus au service Store.
Sélectionnez Ctrl+S pour enregistrer le fichier.
Dans le volet EXPLORATEUR , développez le dossier Produit , puis sélectionnez Program.cs.
Avant la app.Run() méthode, ajoutez ce code :
```
app.MapObservability();
```
Cette méthode ajoute le point de terminaison de récupération Prometheus au service Product.
Sélectionnez Ctrl+S pour enregistrer le fichier.

Tester les nouvelles fonctionnalités d’observabilité

Vous testez maintenant les nouvelles fonctionnalités d’observabilité que vous avez ajoutées à l’application.

Dans le volet TERMINAL en bas, accédez au dossier dotnet-observability/eShopLite .
```
cd ..
```

Mettez à jour les conteneurs d’applications.

dotnet publish /p:PublishProfile=DefaultContainer

Accédez au dossier dotnet-observability et démarrez l’application avec Docker :
```
cd ..
docker compose up
```
Sous l’onglet PORTS, sélectionnez Ouvrir dans le navigateur pour Prometheus (9090). Si vous exécutez localement dans Visual Studio Code, ouvrez un navigateur et, sous un nouvel onglet, accédez à l’application http://localhost:9090Prometheus.
Dans le menu supérieur, sélectionnez État , puis sélectionnez Cibles.

Vous devez voir les Produits et les services Store répertoriés comme up.
Sous l’onglet PORTS , sélectionnez Ouvrir dans le navigateur pour Grafana (3000). Si vous exécutez localement dans Visual Studio Code, ouvrez un navigateur et, sous un nouvel onglet, accédez à l’application http://localhost:3000Grafana.
Entrez le nom d'utilisateur admin.
Entrez le mot de passe grafana.
Sélectionnez Créer votre premier tableau de bord.
Sélectionnez Importer un tableau de bord.
Sous un nouvel onglet, accédez à GitHub et ouvrez le fichier json du tableau de bord core ASP.NET .
Copiez le fichier Raw.
Collez le JSON dans la zone de texte Importer via le modèle JSON du tableau de bord.
Sélectionner Charger.
Dans la liste déroulante de la source de données Prometheus , sélectionnez Prometheus.
Cliquez sur Importer.

Vous devez voir un tableau de bord affichant des métriques pour les services Produits et Store . Sélectionnez le poste pour changer entre les deux prestations.
Dans le volet TERMINAL , sélectionnez Ctrl+C pour arrêter l’application.

Ajouter Zipkin

Vous étendez maintenant les fonctionnalités de suivi de l’application en ajoutant Zipkin. Comme vous l’avez fait précédemment, vous ajoutez un conteneur Zipkin à votre application et configurez-le pour vous connecter au collecteur OpenTelemetry. Ensuite, vous ajoutez l’exportateur Zipkin OpenTelemetry à votre application.

Dans le volet EXPLORATEUR , sélectionnez le fichier docker-compose.yml dans le dossier dotnet-observability .
Ajoutez prometheus et zipkin dans le depends_on pour le frontend.
```
depends_on: 
  - backend
  - prometheus
  - zipkin 
```
Ajouter prometheus dans le depends_on pour le backend.
```
 depends_on: 
   - prometheus
```

Ajoutez des variables d’environnement pour Zipkin à BOTHfrontend et backend:

environment: 
  - ZIPKIN_URL=http://zipkin:9411

Les deux services doivent ressembler à ceci :

frontend:
  image: storeimage
  build:
    context: .
    dockerfile: ./eShopLite/Store/Dockerfile
  environment: 
    - ProductEndpoint=http://backend:8080
    - ZIPKIN_URL=http://zipkin:9411
  ports:
    - "32000:8080"
  depends_on: 
    - backend
    - prometheus
    - zipkin

backend:
  image: productservice
  build: 
    context: .
    dockerfile: ./eShopLite/Products/Dockerfile
  environment: 
    - ZIPKIN_URL=http://zipkin:9411

  ports: 
    - "32001:8080"
  depends_on: 
    - prometheus

Ajoutez ce YAML au bas du fichier :
```
  zipkin:
    image: openzipkin/zipkin
    ports:
      - 9411:9411
```
Le YAML précédent ajoute un conteneur Zipkin à l’application. Il configure le conteneur Zipkin pour répondre sur le port 9411.
Sélectionnez Ctrl+S pour enregistrer le fichier.
Dans le volet TERMINAL , accédez au dossier Diagnostics .
```
cd ./eShopLite/Diagnostics/
```

Ajoutez les packages d’exportation Zipkin.

dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease

Dans le volet EXPLORATEUR , développez le dossier Diagnostics , puis sélectionnez DiagnosticServiceCollectionExtensions.cs.

En bas des fournisseurs de suivi, ajoutez Zipkin :

// add the tracing providers
.WithTracing(tracing =>
{
  tracing.SetResourceBuilder(resource)
              .AddAspNetCoreInstrumentation()
              .AddHttpClientInstrumentation()
              .AddSqlClientInstrumentation()
              .AddZipkinExporter(zipkin =>
              {
                var zipkinUrl = configuration["ZIPKIN_URL"] ?? "http://zipkin:9411";
                zipkin.Endpoint = new Uri($"{zipkinUrl}/api/v2/spans");
              });
});

Sélectionnez Ctrl+S pour enregistrer le fichier.
Dans le volet TERMINAL en bas, accédez au dossier dotnet-observability/eShopLite .
```
cd ..
```

Mettez à jour les conteneurs d’applications.

dotnet publish /p:PublishProfile=DefaultContainer

Accédez au dossier dotnet-observability et démarrez l’application avec Docker :
```
cd ..
docker compose up
```
Sous l’onglet PORTS, sélectionnez Ouvrir dans le navigateur pour Prometheus (9090). Si vous exécutez localement dans Visual Studio Code, ouvrez un nouvel onglet de navigateur et accédez à l’application http://localhost:9411Zipkin.
Dans le menu, sélectionnez Dépendances.
Dans le volet TERMINAL , sélectionnez Ctrl+C pour arrêter l’application.

Ajouter Application Insights

La dernière étape consiste à ajouter Application Insights à votre application.

Créer la ressource Application Insights dans Azure

Dans le volet TERMINAL , connectez-vous à Azure.
```
az login --use-device-code
```
Affichez votre abonnement Azure sélectionné.
```
az account show -o table
```
Si l’abonnement incorrect est sélectionné, sélectionnez le bon abonnement à l’aide de la commande az account set .
Ajoutez l’extension pour Application Insights.
```
az extension add -n application-insights
```

Créez une ressource Application Insights.

az monitor app-insights component create --app eShopLiteInsights --location eastus --kind web -g eShopLite

Vous devez voir cette sortie :

{
  "appId": "00001111-aaaa-2222-bbbb-3333cccc4444",
  "applicationId": "eShopLiteInsights",
  "applicationType": "web",
  "connectionString": "InstrumentationKey=00000000-0000-0000-0000-000000000000;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/",
  "creationDate": "2023-11-10T16:50:00.950726+00:00",
  "disableIpMasking": null,
  "etag": "\"3a02952a-0000-0100-0000-654e5f380000\"",
  "flowType": "Bluefield",
  "hockeyAppId": null,
  "hockeyAppToken": null,
  "id": "/subscriptions/aaaa0a0a-bb1b-cc2c-dd3d-eeeeee4e4e4e/resourceGroups/eShopLite/providers/microsoft.insights/components/eShopLiteInsights",
  "immediatePurgeDataOn30Days": null,
  "ingestionMode": "ApplicationInsights",
  "instrumentationKey": "00000000-0000-0000-0000-000000000000",
  "kind": "web",
  "location": "eastus",
  "name": "eShopLiteInsights",
  "privateLinkScopedResources": null,
  "provisioningState": "Succeeded",
  "publicNetworkAccessForIngestion": "Enabled",
  "publicNetworkAccessForQuery": "Enabled",
  "requestSource": "rest",
  "resourceGroup": "eShopLite",
  "retentionInDays": 90,
  "samplingPercentage": null,
  "tags": {},
  "tenantId": "aaaabbbb-0000-cccc-1111-dddd2222eeee",
  "type": "microsoft.insights/components"
}

À partir du JSON précédemment retourné, copiez le connectionString, à l’exclusion du « . ». Par exemple:

InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/

Dans le volet EXPLORATEUR , sélectionnez le fichier docker-compose.yml .
Vous ajoutez une variable d’environnement que le projet de diagnostic utilise pour vous connecter à Application Insights. Ajoutez ce YAML au service Store :
```
environment:
  - APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/
```
Remplacez la chaîne de connexion précédente par celle que vous avez copiée à partir d’Azure CLI.

Répétez ces étapes pour le service Produits . Le yaML final doit ressembler à ceci :

  frontend:
    image: storeimage
    build:
      context: .
      dockerfile: ./eShopLite/Store/Dockerfile
    environment: 
      - ProductEndpoint=http://backend:8080
      - ZIPKIN_URL=http://zipkin:9411
      - APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/
    ports:
      - "32000:8080"
    depends_on: 
      - backend
      - prometheus
      - zipkin

  backend:
    image: productservice
    build: 
      context: .
      dockerfile: ./eShopLite/Products/Dockerfile
    environment: 
      - ZIPKIN_URL=http://zipkin:9411
      - APPLICATIONINSIGHTS_CONNECTION_STRING=InstrumentationKey=b851fa75-85a2-42f7-bb6f-413725d9d8ba;IngestionEndpoint=https://eastus-2.in.applicationinsights.azure.com/;LiveEndpoint=https://eastus.livediagnostics.monitor.azure.com/

Sélectionnez Ctrl+S pour enregistrer le fichier.
Dans le volet TERMINAL , accédez au dossier Diagnostics .
```
cd .\eShopLite\Diagnostics\ 
```

Ajoutez le package d’exportateur Application Insights.

dotnet add package Azure.Monitor.OpenTelemetry.AspNetCore --prerelease

Dans le volet EXPLORER , sélectionnez le dossier Diagnostics , puis sélectionnez DiagnosticServiceCollectionExtensions.cs.
En haut du fichier, ajoutez cette using instruction :
```
using Azure.Monitor.OpenTelemetry.AspNetCore;
```

Après var otelBuilder = services.AddOpenTelemetry();, ajoutez ce code :

if (!string.IsNullOrEmpty(configuration["APPLICATIONINSIGHTS_CONNECTION_STRING"]))
{
  otelBuilder.UseAzureMonitor();
}

Sélectionnez Ctrl+S pour enregistrer le fichier.
Dans le volet TERMINAL en bas, accédez au dossier dotnet-observability/eShopLite .
```
cd ..
```

Mettez à jour les conteneurs d’applications.

dotnet publish /p:PublishProfile=DefaultContainer

Accédez au dossier dotnet-observability et démarrez l’application avec Docker :
```
cd ..
docker compose up
```
Connectez-vous au portail Azure avec les mêmes informations d’identification que celles que vous avez utilisées pour vous connecter à Azure CLI.
Dans le portail Azure, sélectionnez Groupes de ressources.
Sélectionnez le groupe de ressources eShopLite .
Sélectionnez la ressource Application Insights eShopLiteInsights.
Sélectionnez le tableau de bord d’application.
Pour afficher les modifications apportées aux métriques, accédez à l’application eShopLite et modifiez le stock. Actualisez ensuite le tableau de bord Application Insights.
Dans le volet TERMINAL , appuyez sur Ctrl+C pour arrêter l’application.

Commentaires

Cette page a-t-elle été utile ?