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

  • 15 minuter

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 duprometheus.

  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.

    Screenshot that shows the configured Prometheus app showing the health of the eShopLite app.

    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.

    Screenshot that shows an ASP.NET dashboard in Grafana.

    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_onbackend.

     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 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.

    Screenshot that shows Zipkin showing the dependencies of the eShopLite app Store sending requests to the Products service.

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

    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 anslutningssträng 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.

    Screenshot that shows Application Insights showing the health of the eShopLite app.

  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.