Övning – Använda OpenTelemetry-data i ett molnbaserat program

Slutförd

I den här övningen får du bättre insyn i alla data som genereras av OpenTelemetry i din app. Du har lagt till diagnostikfunktionen i Store-tjänsten. Med det på plats lägger du till Prometheus och Grafana eShopLite i tjänsterna och tittar på några av måtten som samlas in. Nästa steg är att lägga till Zipkin och visa de distribuerade spårningarna. Slutligen lägger du till Application Insights i din app och använder den för att visa data.

Lägg till Prometheus och Grafana

Prometheus och Grafana tillhandahåller Docker-avbildningar som gör det enkelt att lägga till dem i dina projekt. Du inkluderar dem i filen docker-compose.yml i lösningens rot.

1. I Visual Studio Code går du till explorer-fönstret och väljer filen docker-compose.yml.

2. Lägg till den här YAML-filen längst ned i filen:

     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
   

Föregående Docker yaml lägger till två nya tjänster, Prometheus och Grafana. Avsnittet Prometheus konfigurerar en container för att svara på port 9090. Den mappar mappen prometheus som förväntar sig en prometheus.yml fil. Avsnittet Grafana konfigurerar en container för att svara på port 3000. Den mappar tre mappar i en grafana-mapp .

Konfigurera Prometheus

Prometheus måste konfigureras så att den vet var måtten ska samlas in. Du lägger till en prometheus.yml fil i mappen prometheus.

1. I Visual Studio Code högerklickar du på mappen dotnet-observability i explorer-fönstret och väljer sedan Ny mapp.

2. I namnfältet anger du prometheus.

3. Högerklicka på mappen prometheus i explorer-fönstret och välj sedan Ny fil.

4. I namnfältet anger du prometheus.yml.

5. I filredigeraren anger du följande YAML:

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

   Föregående YAML konfigurerar Prometheus för att skrapa mått från serverdels- och klientdelstjänsterna . Eftersom appen körs i Docker är värdnamnen tjänstnamnen.

6. Spara filen genom att trycka på Ctrl+S.

Konfigurera Grafana

Grafana måste konfigureras så att det vet var måtten ska samlas in.

1. I Visual Studio Code högerklickar du på mappen dotnet-observability i explorer-fönstret och väljer sedan Ny mapp.

2. I namnfältet anger du grafana.

3. Högerklicka på grafana-mappen och välj sedan Ny mapp.

4. I namnfältet anger du datakälla.

5. Högerklicka på grafana-mappen och välj sedan Ny mapp.

6. I namnfältet anger du instrumentpanelen.

7. Expandera grafana-mappen, högerklicka på mappen datakälla och välj sedan Ny fil.

8. I namnfältet anger du datasource.yml.

9. På redigeringsfliken anger du följande YAML:

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

   Föregående YAML konfigurerar Grafana att använda Prometheus som datakälla.

10. Spara filen genom att trycka på Ctrl+S.

Uppdatera din ASP.NET Core-app för att exponera mått för Prometheus

Nu är diagnostikprojektet bara konfigurerat för att exponera mått för konsolen. Du uppdaterar projektet för att exponera mått för Prometheus i stället.

1. I Visual Studio Code går du till mappen Diagnostik i terminalfönstret längst ned.

2. Kör följande kommando:

   cd .\eShopLite\Diagnostics\ 
   

3. OpenTelemetry.Exporter.Console Ta bort paketet:

   dotnet remove package OpenTelemetry.Exporter.Console
   

4. OpenTelemetry.Exporter.Prometheus.AspNetCore Lägg till paketet:

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

5. Expandera mappen Diagnostik i explorer-fönstret och välj sedan DiagnosticServiceCollectionExtensions.cs.

6. Ersätt konsolexportören .AddConsoleExporter(); med den här koden:

   .AddPrometheusExporter();
   

7. Lägg till den här koden längst ned i filen före den sista }:

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

   Den här koden lägger till en Prometheus-slutpunkt för skrapning till varje tjänst som innehåller detta med deras app. Detta gör att Prometheus kan skrapa mått från http://service/metrics.

8. Spara filen genom att trycka på Ctrl+S.

Exponera mått i Store-tjänsten

Appen är för närvarande endast konfigurerad för att exponera mått för produkttjänsten . Du uppdaterar appen så att även mått för Store-tjänsten exponeras.

1. Högerklicka på Store-projektet i EXPLORER-fönstret under SOLUTION EXPLORER och välj sedan Lägg till projektreferens.

2. Välj Diagnostik.

3. Expandera mappen Store i explorer-fönstret och välj sedan Program.cs.

4. Under kodkommenten // Add observability code herelägger du till ett anrop till metoden Diagnostik:

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

5. app.Run() Innan metoden lägger du till den här koden:

   app.MapObservability();
   

   Den här metoden lägger till Prometheus-skrapningsslutpunkten i Store-tjänsten .

6. Spara filen genom att trycka på Ctrl+S.

7. Expandera mappen Produkt i explorer-fönstret och välj sedan Program.cs.

8. app.Run() Innan metoden lägger du till den här koden:

   app.MapObservability();
   

   Den här metoden lägger till Prometheus-skrapningsslutpunkten i produkttjänsten .

9. Spara filen genom att trycka på Ctrl+S.

Testa de nya observerbarhetsfunktionerna

Nu testar du de nya observerbarhetsfunktionerna som du har lagt till i appen.

1. Gå till mappen dotnet-observability/eShopLite i terminalfönstret längst ned.

   cd ..
   

2. Uppdatera appcontainrarna.

   dotnet publish /p:PublishProfile=DefaultContainer 
   

3. Gå till mappen dotnet-observability och starta appen med Docker:

   cd ..
   docker compose up
   

4. På fliken PORTar väljer du Öppna i Webbläsare för Prometheus (9090). Om du kör lokalt i Visual Studio Code öppnar du en webbläsare och går till Prometheus-appen http://localhost:9090på en ny flik.

5. På den översta menyn väljer du Status och sedan Mål.

   

   Du bör se de produkter och store-tjänster som anges som UP.

6. På fliken PORTar väljer du Öppna i Webbläsare för Grafana (3000). Om du kör lokalt i Visual Studio Code öppnar du en webbläsare och går till Grafana-appen http://localhost:3000på en ny flik.

7. Ange användarnamnsadministratören.

8. Ange lösenordet grafana.

9. Välj Skapa din första instrumentpanel.

10. Välj Importera instrumentpanel.

11. På en ny flik går du till GitHub och öppnar json-filen ASP.NET Core-instrumentpanelen.

12. Kopiera Raw-filen.

13. Klistra in JSON i textrutan Importera via instrumentpanelens JSON-modell .

14. Välj Läs in.

15. I listrutan Prometheus-datakälla väljer du Prometheus.

16. Välj Importera.

    

    Du bör se en instrumentpanel som visar mått för produkterna och store-tjänsterna . Välj det jobb som ska ändras mellan de två tjänsterna.

17. I fönstret TERMINAL väljer du Ctrl+C för att stoppa appen.

Lägg till Zipkin

Nu utökar du spårningsfunktionerna i appen genom att lägga till Zipkin. Precis som tidigare lägger du till en Zipkin-container i din app och konfigurerar den för att ansluta till OpenTelemetry-insamlaren. Sedan lägger du till OpenTelemetry Zipkin-exportören i din app.

1. I Visual Studio Code går du till explorer-fönstret och väljer filen docker-compose.yml i mappen dotnet-observability.

2. Lägg till prometheus och zipkin i depends_on för frontend.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Lägg till prometheus för depends_on backend.

    depends_on: 
      - prometheus
   

4. Lägg till miljövariabler för Zipkin i BÅDE frontend och backend:

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

   De två tjänsterna bör se ut så här:

   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. Lägg till den här YAML-filen längst ned i filen:

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

   Föregående YAML lägger till en Zipkin-container i appen. Den konfigurerar Zipkin-containern så att den svarar på port 9411.

6. Spara filen genom att trycka på Ctrl+S.

7. I fönstret TERMINAL går du till mappen Diagnostik .

   cd ./eShopLite/Diagnostics/
   

8. Lägg till Zipkin-exportpaketen.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

9. Expandera mappen Diagnostik i explorer-fönstret och välj sedan DiagnosticServiceCollectionExtensions.cs.

10. Lägg till Zipkin längst ned i spårningsprovidrar:

    // 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. Spara filen genom att trycka på Ctrl+S.

12. Gå till mappen dotnet-observability/eShopLite i terminalfönstret längst ned.

    cd ..
    

13. Uppdatera appcontainrarna.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

14. Gå till mappen dotnet-observability och starta appen med Docker:

    cd ..
    docker compose up
    

15. På fliken PORTar väljer du Öppna i Webbläsare för Prometheus (9090). Om du kör lokalt i Visual Studio Code öppnar du en ny webbläsarflik och går till Zipkin-appen http://localhost:9411.

16. Välj Beroenden på menyn.

    

17. I fönstret TERMINAL väljer du Ctrl+C för att stoppa appen.

Lägga till Application Insights

Det sista steget är att lägga till Application Insights i din app.

Skapa Application Insights-resursen i Azure

1. Logga in på Azure i fönstret TERMINAL i Visual Studio Code.

   az login --use-device-code
   

2. Visa din valda Azure-prenumeration.

   az account show -o table
   

   Om fel prenumeration har valts väljer du rätt genom att använda kommandot az account set .

3. Lägg till tillägget för Application Insights.

   az extension add -n application-insights
   

4. Skapa en Application Insights-resurs.

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

   Du bör se dessa utdata:

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

   Från föregående returnerade JSON kopierar du connectionString, exklusive ". Till exempel:

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

5. I Visual Studio Code går du till explorer-fönstret och väljer filen docker-compose.yml.

6. Du lägger till en miljövariabel som diagnostikprojektet använder för att ansluta till Application Insights. Lägg till denna YAML i Store-tjänsten :

   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/
   

   Ersätt föregående niska veze med den som du kopierade från Azure CLI.

7. Upprepa de här stegen för produkttjänsten. Den slutliga YAML:en bör se ut så här:

     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. Spara filen genom att trycka på Ctrl+S.

9. I fönstret TERMINAL går du till mappen Diagnostik .

   cd .\eShopLite\Diagnostics\ 
   

10. Lägg till Application Insights-exporterpaketet.

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

11. I fönstret UTFORSKA väljer du mappen Diagnostik och väljer sedan DiagnosticServiceCollectionExtensions.cs.

12. Lägg till den här using instruktionen överst i filen:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Lägg till den här koden nedan var otelBuilder = services.AddOpenTelemetry();:

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

14. Spara filen genom att trycka på Ctrl+S.

15. Gå till mappen dotnet-observability/eShopLite i terminalfönstret längst ned.

    cd ..
    

16. Uppdatera appcontainrarna.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

17. Gå till mappen dotnet-observability och starta appen med Docker:

    cd ..
    docker compose up
    

18. Logga in på Azure-portalen med samma autentiseringsuppgifter som du använde för att logga in på Azure CLI.

19. I Azure-portalen väljer du Resursgrupper.

20. Välj resursgruppen eShopLite.

21. Välj resursen eShopLiteInsights Application Insights.

22. Välj programinstrumentpanelen.

    

23. Om du vill se ändringar i mått går du till eShopLite appen och ändrar lager. Uppdatera sedan Application Insights-instrumentpanelen.

24. I fönstret TERMINAL trycker du på Ctrl+C för att stoppa appen.