Indietro

Prossima

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. A tale scopo, si aggiungono Prometheus e Grafana ai servizi eShopLite e si esaminano 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. Sono inclusi nel file docker-compose.yml, nella radice della soluzione.

1. Nel riquadro ESPLORA RISORSE di Visual Studio Code 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 file yaml di Docker precedente aggiunge due nuovi servizi, Prometheus e Grafana. La sezione Prometheus configura un contenitore per rispondere alla porta 9090. Esegue il mapping della cartella Prometheus che prevede un file prometheus.yml. La sezione Grafana configura un contenitore per rispondere alla porta 3000. Esegue il mapping di 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. In Visual Studio Code, nel riquadro ESPLORA RISORSE fare clic con il pulsante destro del mouse sulla cartella dotnet-observability e quindi selezionare Nuova cartella.

2. Nel campo del nome immettere prometheus.

3. Nel riquadro Esplora risorse fare clic con il pulsante destro del mouse sulla cartella Prometheus e quindi selezionare 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 codice YAML precedente configura Prometheus per scorporare le metriche dal back-end e i servizi 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. In Visual Studio Code, nel riquadro ESPLORA RISORSE fare clic con il pulsante destro del mouse sulla cartella dotnet-observability e quindi selezionare 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 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 selezionare 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. Aggiornare il progetto per esporre le metriche a Prometheus.

1. In Visual Studio Code, nel riquadro TERMINALE nella parte inferiore passare alla cartella diagnostica.

2. Eseguire questo comando:

   cd .\eShopLite\Diagnostics\ 
   

3. Rimuovere il pacchetto OpenTelemetry.Exporter.Console :

   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 ESPLORA RISORSE 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 aggiungere il codice seguente prima dell'ultimo }:

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

   Questo codice aggiunge un endpoint di scorporo Prometheus a ogni servizio che include questo con l'app. In questo modo Prometheus può scorporare 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 dello Store.

1. Nel riquadro ESPLORA RISORSE, in ESPLORA SOLUZIONIfare clic con il pulsante destro del mouse sul progetto Store e quindi selezionare Aggiungi riferimento al progetto.

2. Selezionare Diagnostica.

3. Nel riquadro ESPLORA RISORSE, espandere la cartella Store e quindi selezionare Program.cs.

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

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

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

   app.MapObservability();
   

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

6. Selezionare Ctrl+S per salvare il file.

7. Nel riquadro ESPLORA RISORSE, espandere la cartella Prodotto e quindi selezionare Program.cs.

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

   app.MapObservability();
   

   Questo metodo aggiunge l'endpoint di scorporo Prometheus al servizio Prodotti.

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 Prometheus http://localhost:9090.

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 Grafana http://localhost:3000.

7. Immettere il nome utente amministratore.

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 dashboard ASP.NET Core.

12. Copiare il file on elaborato.

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

14. Seleziona Carica.

15. Nell'elenco a discesa origine dati Prometheus selezionare Prometheus.

16. Selezionare Importa.

    

    Verrà visualizzato un dashboard che mostra le metriche per i servizi Prodotti e Store. Selezionare il processo da modificare tra i due servizi.

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 connettersi all'agente di raccolta OpenTelemetry. Aggiungere quindi l'utilità di esportazione Zipkin OpenTelemetry all'app.

1. Nel riquadro ESPLORA RISORSE di Visual Studio Code selezionare il file docker-compose.ymlall'interno della cartella dotnet-observability.

2. Aggiungere prometheus e zipkin nel depends_on per l' frontend.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Aggiungere prometheus nel depends_on per il backend.

    depends_on: 
      - prometheus
   

4. Aggiungere variabili di ambiente per Zipkin SIA in frontend sia in 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 alla 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 ESPLORA RISORSE 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 Zipkin http://localhost:9411.

16. Nel menu selezionare Dipendenze.

    

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 di Visual Studio Code 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": "fb6e1af0-7556-469d-a31f-85e4550c8fde",
     "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/7eebce2a-0884-4df2-8d1d-2a3c051e47fe/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": "7eebce2a-0884-4df2-8d1d-2a3c051e47fe",
     "type": "microsoft.insights/components"
   }
   

   Dal codice JSON precedente restituito copiare il connectionString, escluso ". Ad 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 ESPLORA RISORSE di Visual Studio Code 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 servizioProdotti. Il codice YAML finale avrà un aspetto simile a questo:

     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 RISORSE selezionare la cartella Diagnostica e quindi selezionare DiagnosticServiceCollectionExtensions.cs.

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

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Di seguito 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 Application Insights.

22. Selezionare il dashboard dell'applicazione .

    

23. Per visualizzare le modifiche apportate alle metriche, passare all'app eShopLite e modificare le scorte. Aggiornare quindi il dashboard di Application Insights.

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

Continua