Vorherige

Nächste

Übung – Verwenden von OpenTelemetry-Daten in einer cloudnativen Anwendung

Abgeschlossen

In dieser Übung erhalten Sie eine bessere Einsicht in alle Daten, die von OpenTelemetry in Ihrer App generiert werden. Zum Abschluss fügen Sie die Diagnosefunktion zum Store-Dienst hinzu. Damit fügen Sie Prometheus und Grafana zu den eShopLite-Diensten hinzu und sehen sich einige der erfassten Metriken an. Der nächste Schritt besteht darin, Zipkin hinzuzufügen und die verteilten Ablaufverfolgungen anzuzeigen. Schließlich fügen Sie Ihrer App Application Insights hinzu und verwenden dies zum Anzeigen der Daten.

Hinzufügen von Prometheus und Grafana

Prometheus und Grafana stellen Docker-Images bereit, die ihnen das Hinzufügen zu Ihren Projekten erleichtern. Sie fügen sie in die Datei docker-compose.yml im Stammverzeichnis der Lösung ein.

1. Wählen Sie in Visual Studio Code im Bereich EXPLORER die Datei docker-compose.yml aus.

2. Fügen Sie dieses YAML am Ende der Datei hinzu:

     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
   

Der obige Docker-YAML-Code fügt zwei neue Dienste hinzu: Prometheus und Grafana. Der Abschnitt "Prometheus" konfiguriert einen Container für die Reaktion auf Port 9090. Er ordnet den Ordner prometheus zu, der eine Datei vom Typ prometheus.yml erwartet. Im Abschnitt Grafana wird ein Container für die Reaktion auf Port 3000 konfiguriert. Er ordnet drei Ordner im Ordner grafana zu.

Konfigurieren von Prometheus

Prometheus muss so konfiguriert werden, dass es weiß, wo die Metriken erfasst werden sollen. Sie fügen dem Ordner prometheus die Datei prometheus.yml hinzu.

1. Klicken Sie in Visual Studio Code im Bereich EXPLORER mit der rechten Maustaste auf den Ordner dotnet-observability, und wählen Sie dann Neuer Ordner aus.

2. Geben Sie im NamensfeldPrometheus ein.

3. Klicken Sie im Bereich EXPLORER mit der rechten Maustaste auf den Ordner prometheus, und wählen Sie Neue Datei aus.

4. Geben Sie im Namensfeld prometheus.yml ein.

5. Geben Sie im Datei-Editor folgende YAML ein:

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

   Im obigen YAML-Code wird Prometheus so konfiguriert, dass Metriken aus den Back-End- und Front-End-Diensten ausgelesen werden. Da die App in Docker ausgeführt wird, sind die Hostnamen die Dienstnamen.

6. Drücken Sie STRG+S, um die Datei zu speichern.

Konfigurieren von Grafana

Grafana muss so konfiguriert werden, dass es weiß, wo die Metriken erfasst werden sollen.

1. Klicken Sie in Visual Studio Code im Bereich EXPLORER mit der rechten Maustaste auf den Ordner dotnet-observability, und wählen Sie dann Neuer Ordner aus.

2. Geben Sie im Namensfeld Grafana ein.

3. Klicken Sie mit der rechten Maustaste auf den Ordner grafana, und wählen Sie dann Neuer Ordner aus.

4. Geben Sie im Namensfeld Datenquelle ein.

5. Klicken Sie mit der rechten Maustaste auf den Ordner grafana, und wählen Sie dann Neuer Ordner aus.

6. Geben Sie im Namensfeld Dashboard ein.

7. Erweitern Sie den Ordner grafana, klicken Sie mit der rechten Maustaste auf den Ordner datasource, und wählen Sie dann Neue Datei aus.

8. Geben Sie im Namensfeld datasource.yml ein.

9. Geben Sie auf der Registerkarte „Editor“ den folgenden YAML-Code ein:

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

   Im obigen YAML-Code wird Grafana so konfiguriert, dass Prometheus als Datenquelle verwendet wird.

10. Drücken Sie STRG+S, um die Datei zu speichern.

Aktualisieren Ihrer ASP.NET Core-App, um Metriken für Prometheus verfügbar zu machen

Das Diagnose Projekt ist jetzt so konfiguriert, dass nur Metriken für die Konsole verfügbar gemacht werden. Sie aktualisieren das Projekt, um stattdessen Metriken für Prometheus verfügbar zu machen.

1. Wechseln Sie in Visual Studio Code im Bereich TERMINAL unten zum Ordner Diagnostics.

2. Führen Sie diesen Befehl aus:

   cd .\eShopLite\Diagnostics\ 
   

3. Entfernen Sie das OpenTelemetry.Exporter.Console -Paket:

   dotnet remove package OpenTelemetry.Exporter.Console
   

4. Fügen Sie das OpenTelemetry.Exporter.Prometheus.AspNetCore -Paket hinzu:

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

5. Erweitern Sie im Bereich EXPLORER den Ordner Diagnostics, und wählen Sie dann DiagnosticServiceCollectionExtensions.cs aus.

6. Ersetzen Sie den Konsolenexporteur .AddConsoleExporter(); durch diesen Code:

   .AddPrometheusExporter();
   

7. Fügen Sie am Ende der Datei, vor dem letzten }, diesen Code hinzu:

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

   Dieser Code fügt jedem Dienst, der dies in ihrer App enthält, einen Prometheus-Scraping-Endpunkt hinzu. Dadurch kann Prometheus Metriken aus http://service/metrics auslesen.

8. Drücken Sie STRG+S, um die Datei zu speichern.

Verfügbarmachen von Metriken im Store-Dienst

Die App ist derzeit nur so konfiguriert, dass Metriken für den Dienst Produkte verfügbar gemacht werden. Sie aktualisieren die App, um auch Metriken für den Store-Dienst verfügbar zu machen.

1. Klicken Sie im Bereich EXPLORER unter PROJEKTMAPPEN-EXPLORER mit der rechten Maustaste auf das Projekt Store, und wählen Sie dann Projektverweis hinzufügen aus.

2. Wählen Sie Diagnose.

3. Erweitern Sie im Bereich EXPLORER den Ordner Store, und wählen Sie dann Program.cs aus.

4. Fügen Sie unter dem Codekommentar // Add observability code here einen Aufruf der Diagnosemethode hinzu:

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

5. Fügen Sie vor der app.Run() -Methode diesen Code hinzu:

   app.MapObservability();
   

   Diese Methode fügt dem Store-Dienst den Prometheus-Scraping-Endpunkt hinzu.

6. Drücken Sie STRG+S, um die Datei zu speichern.

7. Erweitern Sie im Bereich EXPLORER den Ordner Produkt, und wählen Sie dann Program.cs aus.

8. Fügen Sie vor der app.Run() -Methode diesen Code hinzu:

   app.MapObservability();
   

   Diese Methode fügt den Prometheus-Scraping-Endpunkt zum Dienst Produkte hinzu.

9. Drücken Sie STRG+S, um die Datei zu speichern.

Testen der neuen Observability-Features

Sie testen jetzt die neuen Einblickfunktionen, die Sie der App hinzugefügt haben.

1. Wechseln Sie im Bereich TERMINAL unten zum dotnet-observability/eShopLite-Ordner.

   cd ..
   

2. Aktualisieren Sie die App-Container.

   dotnet publish /p:PublishProfile=DefaultContainer 
   

3. Wechseln Sie zum dotnet-observability-Ordner, und starten Sie die App mit Docker:

   cd ..
   docker compose up
   

4. Wählen Sie auf der Registerkarte PORTS die Option Im Browser öffnen für Prometheus (9090) aus. Öffnen Sie bei der lokalen Ausführung in Visual Studio Code einen Browser, und wechseln Sie auf einer neuen Registerkarte zur Prometheus-App http://localhost:9090.

5. Wählen Sie im oberen Menü Status und dann Ziele aus.

   

   Die Produkte und Store- -Dienste sollten als UP aufgeführt werden.

6. Wählen Sie auf der Registerkarte PORTS die Option Im Browser öffnen für Grafana (3000) aus. Öffnen Sie bei der lokalen Ausführung in Visual Studio Code einen Browser, und wechseln Sie auf einer neuen Registerkarte zur Grafana-App http://localhost:3000.

7. Geben Sie den Benutzernamen admin ein.

8. Geben Sie das Kennwort grafana ein.

9. Wählen Sie Erstellen Ihres ersten Dashboards aus.

10. Wählen Sie Dashboard importieren aus.

11. Wechseln Sie auf einer neuen Registerkarte zu GitHub und öffnen Sie die Datei ASP.NET Core dashboard json.

12. Kopieren Sie die Rohdatendatei.

13. Fügen Sie den JSON-Code in das Importieren über das Dashboard-JSON-Modell -Textfeld ein.

14. Wählen Sie Laden aus.

15. Wählen Sie im Dropdownmenü Prometheus-DatenquellePrometheus aus.

16. Klicken Sie auf Importieren.

    

    Es sollte ein Dashboard mit Metriken für die Produkte und Store -Dienste angezeigt werden. Wählen Sie die Auftrag aus, um zwischen den beiden Diensten zu wechseln.

17. Drücken Sie im Bereich TERMINAL die Tastenkombination STRG +C, um die App zu beenden.

Zipkin hinzufügen

Sie erweitern nun die Ablaufverfolgungsfunktionen der App, indem Sie Zipkin hinzufügen. Wie bereits zuvor, fügen Sie Ihrer App einen Zipkin-Container hinzu und konfigurieren ihn so, dass eine Verbindung mit dem OpenTelemetry-Collector hergestellt wird. Anschließend fügen Sie der App den OpenTelemetry Zipkin-Export hinzu.

1. Wählen Sie im Bereich EXPLORER in Visual Studio Code die Datei docker-compose.yml innerhalb des Ordners dotnet-observability aus.

2. Fügen Sie prometheus und zipkin in depends_on für frontend hinzu.

   depends_on: 
     - backend
     - prometheus
     - zipkin 
   

3. Fügen Sie prometheus in depends_on für backend hinzu.

    depends_on: 
      - prometheus
   

4. Hinzufügen von Umgebungsvariablen für Zipkin zu BEIDEN, frontend und backend:

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

   Die beiden Dienste sollten wie folgt aussehen:

   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. Fügen Sie dieses YAML am Ende der Datei hinzu:

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

   Im obigen YAML-Code wird der App ein Zipkin-Container hinzugefügt. Er konfiguriert den Zipkin-Container so, dass er auf Port 9411 reagiert.

6. Drücken Sie STRG+S, um die Datei zu speichern.

7. Wechseln Sie im Bereich TERMINAL zum Ordner Diagnostics.

   cd ./eShopLite/Diagnostics/
   

8. Fügen Sie die Zipkin-Exportpakete hinzu.

   dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease
   

9. Erweitern Sie im Bereich EXPLORER den Ordner Diagnostics, und wählen Sie dann DiagnosticServiceCollectionExtensions.cs aus.

10. Fügen Sie unten in den Ablaufverfolgungsanbietern Zipkin hinzu:

    // 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. Drücken Sie STRG+S, um die Datei zu speichern.

12. Wechseln Sie im Bereich TERMINAL unten zum dotnet-observability/eShopLite-Ordner.

    cd ..
    

13. Aktualisieren Sie die App-Container.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

14. Wechseln Sie zum dotnet-observability-Ordner, und starten Sie die App mit Docker:

    cd ..
    docker compose up
    

15. Wählen Sie auf der Registerkarte PORTS die Option Im Browser öffnen für Prometheus (9090) aus. Öffnen Sie bei der lokalen Ausführung in Visual Studio Code eine neue Browserregisterkarte, und wechseln Sie zur Zipkin-App http://localhost:9411.

16. Wählen Sie im Menü Abhängigkeiten aus.

    

17. Drücken Sie im Bereich TERMINAL die Tastenkombination STRG +C, um die App zu beenden.

Hinzufügen von Application Insights

Der letzte Schritt besteht darin, Ihrer App Application Insights hinzuzufügen.

Erstellen der Application Insights-Ressource in Azure

1. Melden Sie sich in Visual Studio Code im Bereich TERMINAL bei Azure an.

   az login --use-device-code
   

2. Zeigen Sie Ihr ausgewähltes Azure-Abonnement an.

   az account show -o table
   

   Wenn das falsche Abonnement ausgewählt ist, wählen Sie das richtige mit dem Befehl az account set aus.

3. Fügen Sie die Erweiterung für Application Insights hinzu.

   az extension add -n application-insights
   

4. Erstellen Sie eine Application Insights-Ressource.

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

   Die folgende Ausgabe sollte angezeigt werden:

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

   Kopieren Sie aus dem vorherigen zurückgegebenen JSON-Code connectionString ohne ". Beispiel:

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

5. Wählen Sie in Visual Studio Code im Bereich EXPLORER die Datei docker-compose.yml aus.

6. Sie fügen eine Umgebungsvariable hinzu, die vom Diagnoseprojekt zum Herstellen einer Verbindung mit Application Insights verwendet wird. Fügen Sie dieses YAML zum Store- -Dienst hinzu:

   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/
   

   Ersetzen Sie die obige Verbindungszeichenfolge durch die Zeichenfolge, die Sie aus der Azure CLI kopiert haben.

7. Wiederholen Sie diese Schritte für den Dienst Produkte. Das endgültige YAML sollte wie folgt aussehen:

     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. Drücken Sie STRG+S, um die Datei zu speichern.

9. Wechseln Sie im Bereich TERMINAL zum Ordner Diagnostics.

   cd .\eShopLite\Diagnostics\ 
   

10. Fügen Sie das Application Insights-Exporteurpaket hinzu.

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

11. Erweitern Sie im Bereich EXPLORER den Ordner Diagnostics, und wählen Sie dann DiagnosticServiceCollectionExtensions.cs aus.

12. Fügen Sie oben in der Datei diese using-Anweisung hinzu:

    using Azure.Monitor.OpenTelemetry.AspNetCore;
    

13. Fügen Sie unter var otelBuilder = services.AddOpenTelemetry(); diesen Code hinzu:

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

14. Drücken Sie STRG+S, um die Datei zu speichern.

15. Wechseln Sie im Bereich TERMINAL unten zum dotnet-observability/eShopLite-Ordner.

    cd ..
    

16. Aktualisieren Sie die App-Container.

    dotnet publish /p:PublishProfile=DefaultContainer 
    

17. Wechseln Sie zum dotnet-observability-Ordner, und starten Sie die App mit Docker:

    cd ..
    docker compose up
    

18. Melden Sie sich beim Azure-Portal mit denselben Anmeldeinformationen an, die Sie für die Anmeldung bei der Azure CLI verwendet haben.

19. Wählen Sie im Azure-Portal die Option „Ressourcengruppen“ aus.

20. Wählen Sie die eShopLite -Ressourcengruppe aus.

21. Wählen Sie die Ressource für eShopLiteInsights Application Insights aus.

22. Wählen Sie das Application Dashboard aus.

    

23. Um Änderungen an Metriken anzuzeigen, wechseln Sie zur eShopLite -App, und ändern Sie den Bestand. Aktualisieren Sie dann das Application Insights-Dashboard.

24. Drücken Sie im Bereich TERMINALSTRG+C, um die App zu beenden.

Weiter