Ćwiczenie — używanie danych OpenTelemetry w aplikacji natywnej dla chmury

Ukończone

W tym ćwiczeniu uzyskasz lepszą widoczność wszystkich danych wygenerowanych przez usługę OpenTelemetry w aplikacji. Zakończono dodawanie możliwości diagnostyki do usługi Store. Dzięki temu dodasz rozwiązania Prometheus i Grafana do eShopLite usług i przyjrzysz się niektórym przechwyconym metryce. Następnym krokiem jest dodanie pliku Zipkin i wyświetlenie rozproszonych śladów. Na koniec dodasz usługę Application Insights do aplikacji i użyjesz jej do wyświetlania danych.

Dodawanie rozwiązania Prometheus i Grafana

Prometheus i Grafana udostępniają obrazy platformy Docker, które ułatwiają dodawanie ich do projektów. Umieszczasz je w pliku docker-compose.yml w katalogu głównym rozwiązania.

1. W programie Visual Studio Code w okienku EKSPLORATOR wybierz plik docker-compose.yml .

2. Dodaj ten kod YAML w dolnej części pliku:

     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
   

Powyższy plik Yaml platformy Docker dodaje dwie nowe usługi, Prometheus i Grafana. Sekcja Prometheus konfiguruje kontener do reagowania na porcie 9090. Mapuje folder prometheus oczekiwany prometheus.yml pliku. Sekcja Grafana konfiguruje kontener do odpowiadania na porcie 3000. Mapuje trzy foldery wewnątrz folderu grafana .

Konfigurowanie rozwiązania Prometheus

Rozwiązanie Prometheus musi być skonfigurowane, aby wiedzieć, gdzie zbierać metryki. Do folderu prometheus należy dodać plik prometheus.yml.

1. W programie Visual Studio Code w okienku EKSPLORATOR kliknij prawym przyciskiem myszy folder dotnet-observability , a następnie wybierz pozycję Nowy folder.

2. W polu nazwy wprowadź prometheus.

3. W okienku EKSPLORATOR kliknij prawym przyciskiem myszy folder prometheus , a następnie wybierz pozycję Nowy plik.

4. W polu nazwy wprowadź prometheus.yml.

5. W edytorze plików wprowadź następujący kod YAML:

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

   Powyższy kod YAML konfiguruje rozwiązanie Prometheus w celu złomowania metryk z usług zaplecza i frontonu . Ponieważ aplikacja działa na platformie Docker, nazwy hostów są nazwami usług.

6. Naciśnij klawisze Ctrl+S, aby zapisać plik.

Konfigurowanie narzędzia Grafana

Program Grafana musi być skonfigurowany tak, aby wiedział, gdzie zbierać metryki.

1. W programie Visual Studio Code w okienku EKSPLORATOR kliknij prawym przyciskiem myszy folder dotnet-observability , a następnie wybierz pozycję Nowy folder.

2. W polu nazwy wprowadź wartość grafana.

3. Kliknij prawym przyciskiem myszy folder grafana , a następnie wybierz pozycję Nowy folder.

4. W polu nazwy wprowadź źródło danych.

5. Kliknij prawym przyciskiem myszy folder grafana , a następnie wybierz pozycję Nowy folder.

6. W polu nazwy wprowadź pulpit nawigacyjny.

7. Rozwiń folder grafana, kliknij prawym przyciskiem myszy folder źródła danych, a następnie wybierz pozycję Nowy plik.

8. W polu nazwy wprowadź datasource.yml.

9. Na karcie edytora wprowadź następujący kod YAML:

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

   Poprzedni kod YAML konfiguruje narzędzie Grafana do używania rozwiązania Prometheus jako źródła danych.

10. Naciśnij klawisze Ctrl+S, aby zapisać plik.

Aktualizowanie aplikacji ASP.NET Core w celu uwidocznienia metryk dla rozwiązania Prometheus

Teraz projekt diagnostyczny jest skonfigurowany tylko do uwidaczniania metryk w konsoli programu . Zamiast tego zaktualizujesz projekt, aby uwidocznić metryki w usłudze Prometheus.

1. W programie Visual Studio Code w okienku TERMINAL w dolnej części przejdź do folderu Diagnostyka.

2. Uruchom następujące polecenie:

   cd .\eShopLite\Diagnostics\ 
   

3. OpenTelemetry.Exporter.Console Usuń pakiet:

   dotnet remove package OpenTelemetry.Exporter.Console
   

4. OpenTelemetry.Exporter.Prometheus.AspNetCore Dodaj pakiet:

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

5. W okienku EKSPLORATOR rozwiń folder Diagnostyka, a następnie wybierz pozycję DiagnosticServiceCollectionExtensions.cs.

6. Zastąp eksportera .AddConsoleExporter(); konsoli następującym kodem:

   .AddPrometheusExporter();
   

7. W dolnej części pliku przed ostatnim }dodaj następujący kod:

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

   Ten kod dodaje punkt końcowy złomowania Rozwiązania Prometheus do każdej usługi, która zawiera tę funkcję wraz z aplikacją. Dzięki temu rozwiązanie Prometheus może zeskrobać metryki z elementu http://service/metrics.

8. Naciśnij klawisze Ctrl+S, aby zapisać plik.

Uwidacznianie metryk w usłudze Store

Aplikacja jest obecnie skonfigurowana tylko do uwidaczniania metryk dla usługi Products . Zaktualizujesz aplikację, aby uwidocznić metryki dla usługi Store .

1. W okienku EKSPLORATOR ROZWIĄZAŃ w obszarze EKSPLORATOR ROZWIĄZAŃ kliknij prawym przyciskiem myszy projekt Store, a następnie wybierz polecenie Dodaj odwołanie do projektu.

2. Wybierz pozycję Diagnostyka.

3. W okienku EKSPLORATOR rozwiń folder Store, a następnie wybierz pozycję Program.cs.

4. W obszarze komentarza // Add observability code herekodu dodaj wywołanie metody Diagnostyka:

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

5. app.Run() Przed metodą dodaj następujący kod:

   app.MapObservability();
   

   Ta metoda dodaje punkt końcowy złomowania Rozwiązania Prometheus do usługi Store .

6. Naciśnij klawisze Ctrl+S, aby zapisać plik.

7. W okienku EKSPLORATOR rozwiń folder Product, a następnie wybierz pozycję Program.cs.

8. app.Run() Przed metodą dodaj następujący kod:

   app.MapObservability();
   

   Ta metoda dodaje punkt końcowy złomowania Rozwiązania Prometheus do usługi Products .

9. Naciśnij klawisze Ctrl+S, aby zapisać plik.

Testowanie nowych funkcji obserwacji

Teraz przetestujesz nowe funkcje obserwacji dodane do aplikacji.

1. W okienku TERMINAL w dolnej części przejdź do folderu dotnet-observability/eShopLite.

   cd ..
   

2. Aktualizowanie kontenerów aplikacji.

   dotnet publish /p:PublishProfile=DefaultContainer 
   

3. Przejdź do folderu dotnet-observability i uruchom aplikację za pomocą platformy Docker:

   cd ..
   docker compose up
   

4. Na karcie PORTY wybierz pozycję Otwórz w przeglądarce dla programu Prometheus (9090). Jeśli korzystasz lokalnie w programie Visual Studio Code, otwórz przeglądarkę i na nowej karcie przejdź do aplikacji http://localhost:9090Prometheus.

5. W górnym menu wybierz pozycję Stan , a następnie wybierz pozycję Cele.

   

   Powinny zostać wyświetlone usługi Products and Store jako UP.

6. Na karcie PORTY wybierz pozycję Otwórz w przeglądarce dla programu Grafana (3000). Jeśli korzystasz lokalnie w programie Visual Studio Code, otwórz przeglądarkę i na nowej karcie przejdź do aplikacji http://localhost:3000Grafana.

7. Wprowadź administratora nazwy użytkownika.

8. Wprowadź hasło grafana.

9. Wybierz pozycję Utwórz pierwszy pulpit nawigacyjny.

10. Wybierz pozycję Importuj pulpit nawigacyjny.

11. Na nowej karcie przejdź do witryny GitHub i otwórz plik json pulpitu nawigacyjnego platformy ASP.NET Core.

12. Skopiuj plik Nieprzetworzone.

13. Wklej kod JSON do pola tekstowego Importuj za pośrednictwem modelu JSON pulpitu nawigacyjnego.

14. Wybierz Załaduj.

15. Na liście rozwijanej Źródło danych Prometheus wybierz pozycję Prometheus.

16. Wybierz Importuj.

    

    Powinien zostać wyświetlony pulpit nawigacyjny przedstawiający metryki dla usług Products and Store . Wybierz zadanie, które chcesz zmienić między dwiema usługami.

17. W okienku TERMINAL wybierz Ctrl+C , aby zatrzymać aplikację.

Dodaj plik Zipkin

Teraz rozszerzysz możliwości śledzenia aplikacji, dodając plik Zipkin. Tak jak wcześniej, do aplikacji dodasz kontener Zipkin i skonfigurujesz go tak, aby łączył się z modułem zbierającym OpenTelemetry. Następnie dodasz eksportera Zipkin OpenTelemetry do aplikacji.

1. W programie Visual Studio Code w okienku EKSPLORATOR wybierz plik docker-compose.yml w folderze dotnet-observability.

2. Dodaj prometheus element i zipkin w elemecie depends_on dla elementu frontend.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Dodaj prometheus element depends_on dla elementu backend.

    depends_on: 
      - prometheus
   

4. Dodaj zmienne środowiskowe dla pliku Zipkin do funkcji ZARÓWNO, jak frontend i backend:

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

   Te dwie usługi powinny wyglądać następująco:

   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. Dodaj ten kod YAML w dolnej części pliku:

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

   Powyższy kod YAML dodaje kontener Zipkin do aplikacji. Konfiguruje kontener Zipkin do odpowiadania na porcie 9411.

6. Naciśnij klawisze Ctrl+S, aby zapisać plik.

7. W okienku TERMINAL przejdź do folderu Diagnostyka.

   cd ./eShopLite/Diagnostics/
   

8. Dodaj pakiety eksportu Zipkin.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

9. W okienku EKSPLORATOR rozwiń folder Diagnostyka, a następnie wybierz pozycję DiagnosticServiceCollectionExtensions.cs.

10. W dolnej części dostawców śledzenia dodaj plik 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. Naciśnij klawisze Ctrl+S, aby zapisać plik.

12. W okienku TERMINAL w dolnej części przejdź do folderu dotnet-observability/eShopLite.

    cd ..
    

13. Aktualizowanie kontenerów aplikacji.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

14. Przejdź do folderu dotnet-observability i uruchom aplikację za pomocą platformy Docker:

    cd ..
    docker compose up
    

15. Na karcie PORTY wybierz pozycję Otwórz w przeglądarce dla programu Prometheus (9090). Jeśli korzystasz lokalnie w programie Visual Studio Code, otwórz nową kartę przeglądarki i przejdź do aplikacji http://localhost:9411Zipkin.

16. W menu wybierz pozycję Zależności.

    

17. W okienku TERMINAL wybierz Ctrl+C , aby zatrzymać aplikację.

Dodawanie usługi Application Insights

Ostatnim krokiem jest dodanie usługi Application Insights do aplikacji.

Tworzenie zasobu usługi Application Insights na platformie Azure

1. W programie Visual Studio Code w okienku TERMINAL zaloguj się do platformy Azure.

   az login --use-device-code
   

2. Wyświetl wybraną subskrypcję platformy Azure.

   az account show -o table
   

   Jeśli wybrano niewłaściwą subskrypcję, wybierz poprawną subskrypcję przy użyciu polecenia az account set .

3. Dodaj rozszerzenie dla usługi Application Insights.

   az extension add -n application-insights
   

4. Utwórz zasób usługi Application Insights.

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

   Powinny być widoczne następujące dane wyjściowe:

   {
     "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 poprzedniego zwróconego kodu JSON skopiuj wartość connectionString, z wyłączeniem ciągu ". Na przykład:

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

5. W programie Visual Studio Code w okienku EKSPLORATOR wybierz plik docker-compose.yml .

6. Dodasz zmienną środowiskową używaną przez projekt diagnostyczny do nawiązywania połączenia z usługą Application Insights. Dodaj ten kod YAML do usługi 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/
   

   Zastąp poprzednią parametry połączenia wartością skopiowaną z interfejsu wiersza polecenia platformy Azure.

7. Powtórz te kroki dla usługi Products . Końcowy kod YAML powinien wyglądać następująco:

     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. Naciśnij klawisze Ctrl+S, aby zapisać plik.

9. W okienku TERMINAL przejdź do folderu Diagnostyka.

   cd .\eShopLite\Diagnostics\ 
   

10. Dodaj pakiet eksportera usługi Application Insights.

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

11. W okienku EKSPLORUJ wybierz folder Diagnostyka, a następnie wybierz pozycję DiagnosticServiceCollectionExtensions.cs.

12. W górnej części pliku dodaj następującą using instrukcję:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Poniżej var otelBuilder = services.AddOpenTelemetry();dodaj następujący kod:

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

14. Naciśnij klawisze Ctrl+S, aby zapisać plik.

15. W okienku TERMINAL w dolnej części przejdź do folderu dotnet-observability/eShopLite.

    cd ..
    

16. Aktualizowanie kontenerów aplikacji.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

17. Przejdź do folderu dotnet-observability i uruchom aplikację za pomocą platformy Docker:

    cd ..
    docker compose up
    

18. Zaloguj się do witryny Azure Portal przy użyciu tych samych poświadczeń, które były używane do logowania się do interfejsu wiersza polecenia platformy Azure.

19. W witrynie Azure Portal wybierz pozycję Grupy zasobów.

20. Wybierz grupę zasobów eShopLite .

21. Wybierz zasób eShopLiteInsights Application Insights.

22. Wybierz pulpit nawigacyjny aplikacji.

    

23. Aby wyświetlić zmiany metryk, przejdź do eShopLite aplikacji i zmień zapasy. Następnie odśwież pulpit nawigacyjny usługi Application Insights.

24. W okienku TERMINAL naciśnij Ctrl+C , aby zatrzymać aplikację.