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. Na místě přidáte Do služeb Prometheus a Grafana eShopLite a podíváte se na některé zachycené metriky. Dalším krokem je přidání zipkinu a zobrazení distribuovaných trasování. Nakonec do aplikace přidáte Application Insights a použijete ji k zobrazení dat.

Přidání prometheus a Grafany

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 editoru Visual Studio Code vyberte v podokně PRŮZKUMNÍKa 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 editoru Visual Studio Code klikněte v podokně EXPLORER 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 názvu 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 se z back-endových a front-endových služeb odehrávala metriky. Vzhledem k tomu, že aplikace běží v Dockeru, názvy hostitelů jsou názvy služeb.

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

Konfigurace Grafany

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

1. V editoru Visual Studio Code klikněte v podokně EXPLORER 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 názvu 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 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 editoru Visual Studio Code přejděte v podokně TERMINAL v dolní části do složky Diagnostika .

2. Spusťte tento příkaz:

   cd .\eShopLite\Diagnostics\ 
   

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

   dotnet remove package OpenTelemetry.Exporter.Console
   

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

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

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

6. Nahraďte vývozce .AddConsoleExporter(); konzoly 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í. To umožňuje Prometheus škrábat metriky z http://service/metrics.

8. Stisknutím 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ář // Add observability code hereke kódu př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á koncový bod pro výstřižky Prometheus do služby Store .

6. Stisknutím 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á koncový bod pro výstřižky Prometheus do služby Products .

9. Stisknutím 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 v editoru Visual Studio Code běžíte místně, otevřete prohlížeč a na nové kartě přejděte do aplikace http://localhost:9090Prometheus .

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

   

   Měly by se zobrazit služby produktů a obchodů uvedené jako UP.

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

7. Zadejte správce uživatelského jména.

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 Prometheus zdroje dat 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 editoru Visual Studio Code v podokně PRŮZKUMNÍK vyberte soubor docker-compose.yml uvnitř složky dotnet-observability .

2. Přidejte a zipkin vložte prometheus ho do depends_on pole frontend.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Přidejte prometheus do depends_on pole pro .backend

    depends_on: 
      - prometheus
   

4. Přidejte proměnné prostředí pro Zipkin do OBOU frontend 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 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 zipkinu.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

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

10. V dolní části 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 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 v editoru Visual Studio Code běžíte místně, otevřete novou kartu prohlížeče a přejděte do aplikace http://localhost:9411Zipkin .

16. V nabídce vyberte Závislosti.

    

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

Přidání Application Insights

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

Vytvoření prostředku Application Insights v Azure

1. V editoru Visual Studio Code se v podokně TERMINAL 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ěli byste vidět 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 connectionStringznak s výjimkou znaku ". Příklad:

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

5. V editoru Visual Studio Code vyberte v podokně PRŮZKUMNÍKa 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 tím, 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 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. Na začátek souboru přidejte tento using příkaz:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Níže var otelBuilder = services.AddOpenTelemetry();přidejte tento kód:

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

14. Stisknutím 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 eShopLiteInsights Application Insights.

22. Vyberte řídicí panel aplikace.

    

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

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