Cvičení – použití dat OpenTelemetry v nativní cloudové aplikaci

Dokončeno

V tomto cvičení získáte lepší přehled o všech datech generovaných aplikací OpenTelemetry. Do služby Store dokončíte přidání možnosti diagnostiky. S tím na místě přidáte Prometheus a Grafana k eShopLite službám a podíváte se na některé zaznamenávané metriky. Dalším krokem je přidání Zipkin a zobrazení distribuovaných sledování. Nakonec do aplikace přidáte Application Insights a použijete ji k zobrazení dat.

Přidejte Prometheus a Grafana

Prometheus a Grafana poskytují image Dockeru, které usnadňují jejich přidávání do vašich projektů. Zahrnete je do souboru docker-compose.yml v kořenovém adresáři řešení.

1. V podokně PRŮZKUMNÍK vyberte soubor docker-compose.yml .

2. Přidejte tento YAML do dolní části souboru:

     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
   

Předchozí yaml Dockeru přidá dvě nové služby, Prometheus a Grafana. Oddíl Prometheus nakonfiguruje kontejner tak, aby reagoval na portu 9090. Mapuje složku prometheus , která očekává prometheus.yml soubor. Oddíl Grafana konfiguruje kontejner tak, aby reagoval na portu 3000. Mapuje tři složky uvnitř složky Grafana .

Konfigurace nástroje Prometheus

Prometheus je potřeba nakonfigurovat tak, aby věděl, kam se mají metriky shromažďovat. Do složky prometheus přidáte soubor prometheus.yml.

1. V podokně PRŮZKUMNÍK klikněte pravým tlačítkem myši na složku dotnet-observability a pak vyberte Nová složka.

2. Do pole název zadejte prometheus.

3. V podokně PRŮZKUMNÍK klikněte pravým tlačítkem myši na složku prometheus a pak vyberte Nový soubor.

4. Do pole s názvem zadejte prometheus.yml.

5. V editoru souborů zadejte tento YAML:

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

   Předchozí YAML nakonfiguruje Prometheus tak, aby z back-end a front-end služeb sbíral metriky. Vzhledem k tomu, že aplikace běží v Dockeru, názvy hostitelů jsou názvy služeb.

6. Stisknutím kláves Ctrl+S soubor uložte.

Konfigurovat Grafanu

Grafana musí být nakonfigurovaná tak, aby věděla, kde se mají metriky shromažďovat.

1. V podokně PRŮZKUMNÍK klikněte pravým tlačítkem myši na složku dotnet-observability a pak vyberte Nová složka.

2. Do pole s názvem zadejte grafana.

3. Klikněte pravým tlačítkem myši na složku Grafana a pak vyberte Nová složka.

4. Do pole názvu zadejte zdroj dat.

5. Klikněte pravým tlačítkem myši na složku Grafana a pak vyberte Nová složka.

6. Do pole s názvem zadejte řídicí panel.

7. Rozbalte složku Grafana , klikněte pravým tlačítkem myši na složku zdroje dat a pak vyberte Nový soubor.

8. Do pole s názvem zadejte datasource.yml.

9. Na kartě editoru zadejte tento YAML:

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

   Předchozí YAML nakonfiguruje Grafana tak, aby jako zdroj dat používala Prometheus.

10. Stisknutím kláves Ctrl+S soubor uložte.

Aktualizace aplikace ASP.NET Core tak, aby zpřístupnil metriky pro Prometheus

Teď je projekt diagnostiky nakonfigurovaný tak, aby zpřístupnil metriky konzole. Projekt aktualizujete tak, aby místo toho zpřístupnil metriky pro Prometheus.

1. V podokně TERMINAL v dolní části přejděte do složky Diagnostika .

2. Spusťte tento příkaz:

   cd .\eShopLite\Diagnostics\ 
   

3. Odeberte balíček OpenTelemetry.Exporter.Console:

   dotnet remove package OpenTelemetry.Exporter.Console
   

4. Přidejte balíček OpenTelemetry.Exporter.Prometheus.AspNetCore:

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

5. V podokně PRŮZKUMNÍK rozbalte složku Diagnostika a vyberte DiagnosticServiceCollectionExtensions.cs.

6. Nahraďte vývozce konzoly .AddConsoleExporter(); tímto kódem:

   .AddPrometheusExporter();
   

7. Do dolní části souboru před poslední }přidejte tento kód:

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

   Tento kód přidá koncový bod pro výstřižky Prometheus do každé služby, která tuto službu zahrnuje s aplikací. Díky tomu může Prometheus sbírat metriky od http://service/metrics.

8. Stisknutím kláves Ctrl+S soubor uložte.

Zveřejnění metrik ve službě Store

Aplikace je aktuálně nakonfigurovaná jenom tak, aby zpřístupnila metriky pro službu Products . Aktualizujete aplikaci tak, aby zpřístupnila metriky také pro službu Store .

1. V podokně PRŮZKUMNÍK v části PRŮZKUMNÍK ŘEŠENÍ klikněte pravým tlačítkem myši na projekt Store a pak vyberte Přidat odkaz na projekt.

2. Vyberte Diagnostiku.

3. V podokně PRŮZKUMNÍK rozbalte složku Store a pak vyberte Program.cs.

4. Pod komentář kódu // Add observability code herepřidejte volání metody Diagnostiky:

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

5. Před metodu app.Run() přidejte tento kód:

   app.MapObservability();
   

   Tato metoda přidá endpoint pro scraping Prometheus do služby Store.

6. Stisknutím kláves Ctrl+S soubor uložte.

7. V podokně PRŮZKUMNÍK rozbalte složku Product (Produkt ) a pak vyberte Program.cs.

8. Před metodu app.Run() přidejte tento kód:

   app.MapObservability();
   

   Tato metoda přidá do služby Products koncový bod pro sběr dat Prometheus.

9. Stisknutím kláves Ctrl+S soubor uložte.

Testování nových funkcí pozorovatelnosti

Teď otestujete nové funkce pozorovatelnosti, které jste přidali do aplikace.

1. V podokně TERMINAL v dolní části přejděte do složky dotnet-observability/eShopLite .

   cd ..
   

2. Aktualizujte kontejnery aplikací.

   dotnet publish /p:PublishProfile=DefaultContainer 
   

3. Přejděte do složky dotnet-observability a spusťte aplikaci pomocí Dockeru:

   cd ..
   docker compose up
   

4. Na kartě PORTY vyberte Otevřít v prohlížeči pro Prometheus (9090). Pokud používáte Visual Studio Code místně, otevřete prohlížeč a na nové kartě přejděte na aplikaci Prometheus http://localhost:9090.

5. V horní nabídce vyberte Stav a pak vyberte Cíle.

   

   Měly by se zobrazit služby Produkty a Obchod zobrazené jako UP.

6. Na kartě PORTY vyberte Otevřít v prohlížeči pro Grafana (3000). Pokud spouštíte místně v editoru Visual Studio Code, otevřete prohlížeč a na nové kartě přejděte do aplikace Grafana http://localhost:3000.

7. Zadejte uživatelské jméno admin.

8. Zadejte heslo grafana.

9. Vyberte Vytvořit první řídicí panel.

10. Vyberte Importovat řídicí panel.

11. Na nové kartě přejděte na GitHub a otevřete soubor JSON řídicího panelu ASP.NET Core .

12. Zkopírujte nezpracovaný soubor.

13. Vložte JSON do textového pole Importovat přes model JSON řídicího panelu .

14. Vyberte Načíst.

15. V rozevíracím seznamu zdroje dat Prometheus vyberte Prometheus.

16. Vyberte Importovat.

    

    Měl by se zobrazit řídicí panel zobrazující metriky pro služby Products and Store . Vyberte úlohu , kterou chcete změnit mezi těmito dvěma službami.

17. V podokně TERMINÁL ukončete aplikaci stisknutím kláves Ctrl+C .

Přidat Zipkin

Teď rozšiřujete možnosti trasování aplikace přidáním zipkinu. Stejně jako předtím přidáte do aplikace kontejner Zipkin a nakonfigurujete ho tak, aby se připojil ke kolektoru OpenTelemetry. Pak do aplikace přidáte exportér Zipkin OpenTelemetry.

1. V podokně PRŮZKUMNÍK vyberte soubor docker-compose.yml uvnitř složky dotnet-observability .

2. Do prometheus pro zipkinpřidejte depends_on a frontend .

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Přidejte prometheus v depends_on pro backend.

    depends_on: 
      - prometheus
   

4. Přidejte proměnné prostředí pro Zipkin do OBOUfrontend a backend:

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

   Tyto dvě služby by měly vypadat takto:

   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. Přidejte tento YAML do dolní části souboru:

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

   Předchozí YAML přidá do aplikace kontejner Zipkin. Nakonfiguruje kontejner Zipkin tak, aby reagoval na portu 9411.

6. Stisknutím kláves Ctrl+S soubor uložte.

7. V podokně TERMINAL přejděte do složky Diagnostika .

   cd ./eShopLite/Diagnostics/
   

8. Přidejte balíčky pro export Zipkin.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

9. V podokně PRŮZKUMNÍK rozbalte složku Diagnostika a vyberte DiagnosticServiceCollectionExtensions.cs.

10. V dolní části seznamu zprostředkovatelů trasování, přidejte 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. Stisknutím kláves Ctrl+S soubor uložte.

12. V podokně TERMINAL v dolní části přejděte do složky dotnet-observability/eShopLite .

    cd ..
    

13. Aktualizujte kontejnery aplikací.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

14. Přejděte do složky dotnet-observability a spusťte aplikaci pomocí Dockeru:

    cd ..
    docker compose up
    

15. Na kartě PORTY vyberte Otevřít v prohlížeči pro Prometheus (9090). Pokud používáte visual Studio Code místně, otevřete novou kartu prohlížeče a přejděte do aplikace Zipkin http://localhost:9411.

16. V nabídce vyberte Závislosti.

    

17. V podokně TERMINÁL ukončete aplikaci stisknutím kláves Ctrl+C .

Přidejte Application Insights

Posledním krokem je přidání Application Insights do aplikace.

Vytvoření prostředku Application Insights v Azure

1. V podokně TERMINAL se přihlaste k Azure.

   az login --use-device-code
   

2. Zobrazení vybraného předplatného Azure

   az account show -o table
   

   Pokud je vybrané nesprávné předplatné, pomocí příkazu az account set vyberte správné předplatné.

3. Přidejte rozšíření pro Application Insights.

   az extension add -n application-insights
   

4. Vytvořte prostředek Application Insights.

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

   Měl by se zobrazit tento výstup:

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

   Z předchozího vráceného kódu JSON zkopírujte connectionStrings výjimkou ". Například:

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

5. V podokně PRŮZKUMNÍK vyberte soubor docker-compose.yml .

6. Přidáte proměnnou prostředí, kterou projekt diagnostiky používá pro připojení k Application Insights. Přidejte tento YAML do služby 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/
   

   Nahraďte předchozí připojovací řetězec řetězcem, který jste zkopírovali z Azure CLI.

7. Opakujte tento postup pro službu Produkty . Konečný YAML by měl vypadat takto:

     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. Stisknutím kláves Ctrl+S soubor uložte.

9. V podokně TERMINAL přejděte do složky Diagnostika .

   cd .\eShopLite\Diagnostics\ 
   

10. Přidejte balíček exportéru Application Insights.

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

11. V podokně PROZKOUMAT vyberte složku Diagnostika a pak vyberte DiagnosticServiceCollectionExtensions.cs.

12. Do horní části souboru přidejte tento příkaz using:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Po var otelBuilder = services.AddOpenTelemetry(); přidejte tento kód:

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

14. Stisknutím kláves Ctrl+S soubor uložte.

15. V podokně TERMINAL v dolní části přejděte do složky dotnet-observability/eShopLite .

    cd ..
    

16. Aktualizujte kontejnery aplikací.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

17. Přejděte do složky dotnet-observability a spusťte aplikaci pomocí Dockeru:

    cd ..
    docker compose up
    

18. Přihlaste se k webu Azure Portal pomocí stejných přihlašovacích údajů, které jste použili k přihlášení k Azure CLI.

19. Na webu Azure Portal vyberte skupiny prostředků.

20. Vyberte skupinu prostředků eShopLite .

21. Vyberte prostředek Application Insights s názvem eShopLiteInsights.

22. Vyberte řídicí panel aplikace.

    

23. Pokud chcete zobrazit změny metrik, přejděte do aplikace eShopLite a změňte akcie. Potom aktualizujte řídicí panel Application Insights.

24. V podokně TERMINÁL aplikaci zastavíte stisknutím kláves Ctrl+C .