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

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 i de eShopLite tjänsterna och tittar på några av de mått 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 roten för lösningen.

1. I explorer-fönstret väljer du 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 kartlägger mappen prometheus och förväntar sig en fil som heter prometheus.yml. 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. Högerklicka på mappen dotnet-observability i explorer-fönstret och välj 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']
   

   Den föregående YAML konfigurerar Prometheus för att hämta metrik från serverdelstjänsterna och klientdelstjänsterna . Eftersom appen körs i Docker är värdnamnen tjänstnamnen.

6. Spara filen genom att välja Ctrl+S .

Konfigurera Grafana

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

1. Högerklicka på mappen dotnet-observability i explorer-fönstret och välj sedan Ny mapp.

2. I namnfältet anger du grafana.

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

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

5. Högerklicka på mappen grafana 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 välja 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. Gå till mappen Diagnostik i terminalfönstret längst ned.

2. Kör det här kommandot:

   cd .\eShopLite\Diagnostics\ 
   

3. Ta bort OpenTelemetry.Exporter.Console-paketet:

   dotnet remove package OpenTelemetry.Exporter.Console
   

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

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

5. Expandera mappen Diagnostiki 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 innan den sista }längst ned i filen:

   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 hämta metrik från http://service/metrics.

8. Spara filen genom att välja 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 under SOLUTION EXPLORER i explorer-fönstret 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. Innan metoden app.Run() 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 välja Ctrl+S .

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

8. Innan metoden app.Run() 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 välja 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 Appen Prometheus http://localhost:9090på en ny flik.

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

   

   Du bör se Produkter och Store-tjänster listade 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ändarnamnet admin.

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 explorer-fönstret väljer du 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 i depends_on för backend.

    depends_on: 
      - prometheus
   

4. Lägg till miljövariabler för Zipkin i BÅDEfrontend 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 välja 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 Diagnostiki 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 välja 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 terminalfönstret .

   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 följande 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 explorer-fönstret väljer du 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 den föregående anslutningssträngen 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 välja 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. Efter var otelBuilder = services.AddOpenTelemetry();lägger du till den här koden:

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

14. Spara filen genom att välja 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 applikationspanelen .

    

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

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