Esercizio - Usare i dati OpenTelemetry in un'applicazione nativa del cloud

Completato

In questo esercizio si ottiene una migliore visibilità di tutti i dati generati da OpenTelemetry nell'app. Completare l'aggiunta della funzionalità di diagnostica al servizio Store. Una volta completato, si aggiungono Prometheus e Grafana ai servizi eShopLite e si osservano alcune delle metriche acquisite. Il passaggio successivo consiste nell'aggiungere Zipkin e visualizzare le tracce distribuite. Infine, si aggiunge Application Insights all'app e lo si usa per visualizzare i dati.

Aggiungere Prometheus e Grafana

Prometheus e Grafana forniscono immagini Docker che semplificano l'aggiunta ai progetti. Tali file sono inclusi nel file docker-compose.yml , nella radice della soluzione.

1. Nel riquadro EXPLORER selezionare il file docker-compose.yml .

2. Aggiungere questo YAML alla fine del file:

     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
   

Il yaml docker precedente aggiunge due nuovi servizi, Prometheus e Grafana. La sezione Prometheus configura un contenitore per rispondere sulla porta 9090. Mappa la cartella prometheus considerando un file prometheus.yml. La sezione Grafana configura un contenitore per rispondere sulla porta 3000. Mappa tre cartelle all'interno di una cartella grafana.

Configurare Prometheus

Prometheus deve essere configurato in modo che sappia dove raccogliere le metriche. Aggiungere un file prometheus.yml alla cartella prometheus .

1. Nel riquadro EXPLORER fare clic con il pulsante destro del mouse sulla cartella dotnet-observability e quindi scegliere Nuova cartella.

2. Nel campo nome immettere prometheus.

3. Nel riquadro EXPLORER fare clic con il pulsante destro del mouse sulla cartella prometheus e quindi scegliere Nuovo file.

4. Nel campo nome immettere prometheus.yml.

5. Nell'editor di file immettere il codice YAML seguente:

   global:
     scrape_interval: 1s
   
   scrape_configs:
     - job_name: 'products'
       static_configs:
         - targets: ['backend:8080']
     - job_name: 'store'
       static_configs:
         - targets: ['frontend:8080']
   

   Il file YAML precedente configura Prometheus per eseguire la raccolta delle metriche dai servizi back-end e front-end. Poiché l'app è in esecuzione in Docker, i nomi host sono i nomi dei servizi.

6. Selezionare CTRL+S per salvare il file.

Configurare Grafana

Grafana deve essere configurato in modo che sappia dove raccogliere le metriche.

1. Nel riquadro EXPLORER fare clic con il pulsante destro del mouse sulla cartella dotnet-observability e quindi scegliere Nuova cartella.

2. Nel campo nome immettere grafana.

3. Fare clic con il pulsante destro del mouse sulla cartella grafana e quindi scegliere Nuova cartella.

4. Nel campo nome immettere l'origine dati.

5. Fare clic con il pulsante destro del mouse sulla cartella grafana e quindi scegliere Nuova cartella.

6. Nel campo nome immettere dashboard.

7. Espandere la cartella grafana , fare clic con il pulsante destro del mouse sulla cartella origine dati e quindi scegliere Nuovo file.

8. Nel campo nome immettere datasource.yml.

9. Nella scheda editor immettere il codice YAML seguente:

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

   Il codice YAML precedente configura Grafana per l'uso di Prometheus come origine dati.

10. Selezionare CTRL+S per salvare il file.

Aggiornare l'app ASP.NET Core per esporre le metriche per Prometheus

Il progetto di diagnostica è ora configurato solo per esporre le metriche alla console. Aggiorni il progetto per esporre le metriche a Prometheus.

1. Nel riquadro TERMINALE nella parte inferiore passare alla cartella Diagnostica .

2. Eseguire questo comando:

   cd .\eShopLite\Diagnostics\ 
   

3. Rimuovere il OpenTelemetry.Exporter.Console pacchetto:

   dotnet remove package OpenTelemetry.Exporter.Console
   

4. Aggiungere il pacchetto OpenTelemetry.Exporter.Prometheus.AspNetCore:

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

5. Nel riquadro EXPLORER espandere la cartella Diagnostica e quindi selezionare DiagnosticServiceCollectionExtensions.cs.

6. Sostituire l'utilità di esportazione della console .AddConsoleExporter(); con questo codice:

   .AddPrometheusExporter();
   

7. Nella parte inferiore del file, prima dell'ultimo }, aggiungere questo codice:

   public static void MapObservability(this IEndpointRouteBuilder routes)
   {
     routes.MapPrometheusScrapingEndpoint();
   }
   

   Questo codice aggiunge un endpoint di raccolta dati Prometheus a ogni servizio che lo include nella loro app. In questo modo Prometheus può raccogliere le metriche da http://service/metrics.

8. Selezionare CTRL+S per salvare il file.

Esporre le metriche nel servizio Store

L'app è attualmente configurata solo per esporre le metriche per il servizio Prodotti . L'app viene aggiornata per esporre anche le metriche per il servizio Store .

1. Nel riquadro EXPLORER , in ESPLORA SOLUZIONI fare clic con il pulsante destro del mouse sul progetto Store e quindi scegliere Aggiungi riferimento progetto.

2. Selezionare Diagnostica.

3. Nel riquadro EXPLORER espandere la cartella Store e quindi selezionare Program.cs.

4. Nel commento // Add observability code heredel codice aggiungere una chiamata al metodo Diagnostics:

   builder.Services.AddObservability("Store", builder.Configuration);
   

5. Prima del app.Run() metodo, aggiungere questo codice:

   app.MapObservability();
   

   Questo metodo aggiunge l'endpoint di scraping Prometheus al servizio Store .

6. Selezionare CTRL+S per salvare il file.

7. Nel riquadro EXPLORER espandere la cartella Product e quindi selezionare Program.cs.

8. Prima del app.Run() metodo, aggiungere questo codice:

   app.MapObservability();
   

   Questo metodo aggiunge l'endpoint di raccolta dati Prometheus al servizio Products.

9. Selezionare CTRL+S per salvare il file.

Testare le nuove funzionalità di osservabilità

È ora possibile testare le nuove funzionalità di osservabilità aggiunte all'app.

1. Nel riquadro TERMINALE nella parte inferiore passare alla cartella dotnet-observability/eShopLite .

   cd ..
   

2. Aggiornare i contenitori delle app.

   dotnet publish /p:PublishProfile=DefaultContainer 
   

3. Passare alla cartella dotnet-observability e avviare l'app con Docker:

   cd ..
   docker compose up
   

4. Nella scheda PORTE selezionare Apri nel browser per Prometheus (9090). Se si esegue localmente in Visual Studio Code, aprire un browser e, in una nuova scheda, passare all'app http://localhost:9090Prometheus .

5. Nel menu in alto selezionare Stato e quindi Selezionare Destinazioni.

   

   Verranno visualizzati i servizi Prodotti e Store elencati come UP.

6. Nella scheda PORTE selezionare Apri nel browser per Grafana (3000). Se si esegue localmente in Visual Studio Code, aprire un browser e, in una nuova scheda, passare all'app http://localhost:3000Grafana .

7. Immettere il nome utente admin.

8. Immettere la password grafana.

9. Selezionare Crea il primo dashboard.

10. Selezionare Importa dashboard.

11. In una nuova scheda passare a GitHub e aprire il file JSON del dashboard di ASP.NET Core .

12. Copiare il file Raw.

13. Incollare il codice JSON nella casella di testo Importa tramite modello JSON del dashboard .

14. Selezionare Carica.

15. Nel menu a tendina Origine dati Prometheus, selezionare Prometheus.

16. Selezionare Importa.

    

    Verrà visualizzato un dashboard che mostra le metriche per i servizi Prodotti e Store . Selezionare il Lavoro per passare da un servizio all'altro.

17. Nel riquadro TERMINALE selezionare CTRL+C per arrestare l'app.

Aggiungere Zipkin

È ora possibile estendere le funzionalità di traccia dell'app aggiungendo Zipkin. Come in precedenza, si aggiunge un contenitore Zipkin all'app e lo si configura per la connessione all'agente di raccolta OpenTelemetry. Poi aggiungi l'esportatore Zipkin OpenTelemetry nella tua app.

1. Nel riquadro EXPLORER selezionare il file docker-compose.yml all'interno della cartella dotnet-observability .

2. Aggiungere prometheus e zipkin in depends_on per il frontend.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Aggiungere prometheus nella depends_on per il backend.

    depends_on: 
      - prometheus
   

4. Aggiungere variabili di ambiente per Zipkin a BOTHfrontend e backend:

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

   I due servizi dovrebbero avere un aspetto simile al seguente:

   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    
   

5. Aggiungere questo YAML alla fine del file:

     zipkin:
       image: openzipkin/zipkin
       ports:
         - 9411:9411
   

   Il codice YAML precedente aggiunge un contenitore Zipkin all'app. Configura il contenitore Zipkin per rispondere sulla porta 9411.

6. Selezionare CTRL+S per salvare il file.

7. Nel riquadro TERMINALE passare alla cartella Diagnostica .

   cd ./eShopLite/Diagnostics/
   

8. Aggiungere i pacchetti di esportazione Zipkin.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

9. Nel riquadro EXPLORER espandere la cartella Diagnostica e quindi selezionare DiagnosticServiceCollectionExtensions.cs.

10. Nella parte inferiore dei provider di traccia aggiungere 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");
                  });
    });
    

11. Selezionare CTRL+S per salvare il file.

12. Nel riquadro TERMINALE nella parte inferiore passare alla cartella dotnet-observability/eShopLite .

    cd ..
    

13. Aggiornare i contenitori delle app.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

14. Passare alla cartella dotnet-observability e avviare l'app con Docker:

    cd ..
    docker compose up
    

15. Nella scheda PORTE selezionare Apri nel browser per Prometheus (9090). Se si esegue localmente in Visual Studio Code, aprire una nuova scheda del browser e passare all'app http://localhost:9411Zipkin .

16. Scegliere Dipendenze dal menu.

    

17. Nel riquadro TERMINALE selezionare CTRL+C per arrestare l'app.

Aggiungere Application Insights

L'ultimo passaggio consiste nell'aggiungere Application Insights all'app.

Creare la risorsa di Application Insights in Azure

1. Nel riquadro TERMINALE accedere ad Azure.

   az login --use-device-code
   

2. Visualizzare la sottoscrizione di Azure selezionata.

   az account show -o table
   

   Se è selezionata la sottoscrizione errata, selezionare quella corretta usando il comando az account set .

3. Aggiungere l'estensione per Application Insights.

   az extension add -n application-insights
   

4. Creare una risorsa di Application Insights.

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

   Dovrebbe essere visualizzato questo output:

   {
     "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"
   }
   

   Dal codice JSON restituito in precedenza copiare connectionString, escluso ". Per esempio:

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

5. Nel riquadro EXPLORER selezionare il file docker-compose.yml .

6. Aggiungere una variabile di ambiente usata dal progetto di diagnostica per connettersi ad Application Insights. Aggiungere questo YAML al servizio 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/
   

   Sostituire la stringa di connessione precedente con quella copiata dall'interfaccia della riga di comando di Azure.

7. Ripetere questi passaggi per il servizio Prodotti . Il file YAML finale avrà un aspetto simile al seguente:

     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/
   
   

8. Selezionare CTRL+S per salvare il file.

9. Nel riquadro TERMINALE passare alla cartella Diagnostica .

   cd .\eShopLite\Diagnostics\ 
   

10. Aggiungere il pacchetto di esportazione di Application Insights.

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

11. Nel riquadro ESPLORA selezionare la cartella Diagnostica e quindi selezionare DiagnosticServiceCollectionExtensions.cs.

12. Nella parte superiore del file aggiungere questa using istruzione:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Dopo var otelBuilder = services.AddOpenTelemetry();, aggiungere questo codice:

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

14. Selezionare CTRL+S per salvare il file.

15. Nel riquadro TERMINALE nella parte inferiore passare alla cartella dotnet-observability/eShopLite .

    cd ..
    

16. Aggiornare i contenitori delle app.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

17. Passare alla cartella dotnet-observability e avviare l'app con Docker:

    cd ..
    docker compose up
    

18. Accedere al portale di Azure con le stesse credenziali usate per accedere all'interfaccia della riga di comando di Azure.

19. Nel portale di Azure selezionare Gruppi di risorse.

20. Selezionare il gruppo di risorse eShopLite .

21. Selezionare la risorsa eShopLiteInsights di Application Insights.

22. Selezionare il dashboard dell'applicazione.

    

23. Per vedere le modifiche alle metriche, vai all'app eShopLite e modifica lo stock. Aggiornare quindi il dashboard di Application Insights.

24. Nel riquadro TERMINALE premere CTRL+C per arrestare l'app.