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

  • 15 Minuten

In dieser Übung erhalten Sie eine bessere Sichtbarkeit aller Daten, die von OpenTelemetry in Ihrer App generiert werden. Sie schließen das Hinzufügen der Diagnosefunktion zum Store-Dienst ab. Damit fügen Sie prometheus und Grafana zu den eShopLite Diensten hinzu und betrachten einige der erfassten Metriken. 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 sie zum Anzeigen der Daten.

Hinzufügen von Prometheus und Grafana

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

  1. Wählen Sie im EXPLORER-Bereich die docker-compose.yml Datei 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

Im vorherigen Docker-Yaml werden zwei neue Dienste hinzugefügt: Prometheus und Grafana. Der Abschnitt "Prometheus" konfiguriert einen Container für die Reaktion auf Port 9090. Er ordnet den Prometheus-Ordner zu und erwartet eine Datei namens prometheus.yml. Der Grafana-Abschnitt konfiguriert einen Container für die Reaktion auf Port 3000. Es ordnet drei Ordner in einem Grafana-Ordner zu.

Konfigurieren von Prometheus

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

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

  2. Geben Sie im Namensfeld prometheus ein.

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

  4. Geben Sie im Namensfeld prometheus.yml ein.

  5. Geben Sie im Datei-Editor folgendes 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 vorherigen YAML wird Prometheus so konfiguriert, dass Metriken aus den Back-End- und Front-End-Diensten verschrottet werden. Da die App in Docker ausgeführt wird, sind die Hostnamen die Dienstnamen.

  6. Wählen Sie STRG+S aus, um die Datei zu speichern.

Konfigurieren von Grafana

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

  1. Klicken Sie im EXPLORER-Bereich mit der rechten Maustaste auf den Dotnet-Observability-Ordner , und wählen Sie dann "Neuer Ordner" aus.

  2. Geben Sie im Namensfeld grafana ein.

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

  4. Geben Sie im Feld "Name" die Datenquelle ein.

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

  6. Geben Sie im Feld "Name" dashboard ein.

  7. Erweitern Sie den Grafana-Ordner , klicken Sie mit der rechten Maustaste auf den Ordner "Datenquelle ", und wählen Sie dann "Neue Datei" aus.

  8. Geben Sie im Namensfeld datasource.yml ein.

  9. Geben Sie auf der Registerkarte "Editor" folgendes YAML ein:

    apiVersion: 1

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

    Im vorherigen YAML wird Grafana so konfiguriert, dass Prometheus als Datenquelle verwendet wird.

  10. Wählen Sie STRG+S aus, um die Datei zu speichern.

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

Jetzt ist das Diagnoseprojekt nur so konfiguriert, dass 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 unten im TERMINALbereich zum Ordner " Diagnose ".

  2. Führen Sie den folgenden 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 EXPLORER-Bereich den Diagnoseordner , 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 } den folgenden Code hinzu:

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

    Dieser Code fügt jedem Dienst, der dies mit ihrer App enthält, einen Prometheus-Scraping-Endpunkt hinzu. Auf diese Weise kann Prometheus Metriken von http://service/metrics abrufen.

  8. Wählen Sie STRG+S aus, um die Datei zu speichern.

Verfügbarmachen von Metriken im Store-Dienst

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

  1. Klicken Sie im Explorer-Bereich unter dem Lösungs-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 EXPLORER-Bereich den Store-Ordner , 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. Wählen Sie STRG+S aus, um die Datei zu speichern.

  7. Erweitern Sie im EXPLORER-Bereich 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. Wählen Sie STRG+S aus, um die Datei zu speichern.

Teste die neuen Observability-Funktionen

Sie testen nun die neuen Observability-Features, die Sie der App hinzugefügt haben.

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

    cd ..

  2. Aktualisieren Sie die App-Container.

    dotnet publish /p:PublishProfile=DefaultContainer

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

    cd ..
docker compose up

  4. Wählen Sie auf der Registerkarte "PORTS" die Option "Im Browser für Prometheus öffnen" (9090) aus. Wenn Sie Visual Studio Code lokal nutzen, öffnen Sie 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.

    Screenshot der konfigurierten Prometheus-App mit dem Status der eShopLite-App.

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

  6. Wählen Sie auf der Registerkarte "PORTS" die Option "Im Browser für Grafana öffnen" (3000) aus. Wenn Sie lokal in Visual Studio Code arbeiten, öffnen Sie einen Browser und gehen 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 "Erstes Dashboard erstellen" aus.

  10. Wählen Sie Dashboard importieren aus.

  11. Wechseln Sie auf einer neuen Registerkarte zu GitHub , und öffnen Sie die JSON-Datei ASP.NET Core-Dashboard .

  12. Kopieren Sie die Rohdatendatei.

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

  14. Wählen Sie und laden Sie.

  15. Wählen Sie im Dropdown-Menü der Prometheus-DatenquellePrometheus aus.

  16. Klicken Sie auf Importieren.

    Screenshot eines ASP.NET Dashboards in Grafana.

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

  17. Wählen Sie im TERMINALbereichSTRG+C aus, um die App zu beenden.

Zipkin hinzufügen

Sie erweitern jetzt die Tracing-Funktionen 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-Sammler hergestellt wird. Anschließend fügen Sie der App den Zipkin-Exporter "OpenTelemetry" hinzu.

  1. Wählen Sie im EXPLORER-Bereich die docker-compose.yml Datei im Ordner "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 das depends_on für das backend hinzu.

     depends_on: 
   - prometheus

  4. Hinzufügen von Umgebungsvariablen für Zipkin zu BOTHfrontend 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 vorherigen YAML wird der App ein Zipkin-Container hinzugefügt. Er konfiguriert den Zipkin-Container so, dass er auf Port 9411 reagiert.

  6. Wählen Sie STRG+S aus, um die Datei zu speichern.

  7. Wechseln Sie im TERMINALbereich zum Ordner " Diagnose ".

    cd ./eShopLite/Diagnostics/

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

    dotnet add package OpenTelemetry.Exporter.Zipkin --prerelease

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

  10. Fügen Sie am Ende der Liste der Tracing-Anbieter 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. Wählen Sie STRG+S aus, um die Datei zu speichern.

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

    cd ..

  13. Aktualisieren Sie die App-Container.

    dotnet publish /p:PublishProfile=DefaultContainer

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

    cd ..
docker compose up

  15. Wählen Sie auf der Registerkarte "PORTS" die Option "Im Browser für Prometheus öffnen" (9090) aus. Wenn Sie das lokal in Visual Studio Code ausführen, öffnen Sie einen neuen Browser-Tab und gehen Sie zur Zipkin-App http://localhost:9411.

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

    Screenshot von Zipkin, der die Abhängigkeiten des eShopLite-App-Stores zeigt, der Anfragen an den Dienst Produkte sendet.

  17. Wählen Sie im TERMINALbereichSTRG+C aus, 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 im TERMINALbereich 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 die richtige aus, indem Sie den Befehl "az account set" verwenden .

  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

    Sie sollten diese Ausgabe sehen:

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

    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 im EXPLORER-Bereich die docker-compose.yml Datei aus.

  6. Sie fügen eine Umgebungsvariable hinzu, die vom Diagnoseprojekt zum Herstellen einer Verbindung mit Application Insights verwendet wird. Fügen Sie diesen YAML dem 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 vorangehende 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. Wählen Sie STRG+S aus, um die Datei zu speichern.

  9. Wechseln Sie im TERMINALbereich zum Ordner " Diagnose ".

    cd .\eShopLite\Diagnostics\

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

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

  11. Wählen Sie im Bereich "ERKUNDEN " den Ordner " Diagnose" und 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 nach var otelBuilder = services.AddOpenTelemetry(); diesen Code hinzu:

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

  14. Wählen Sie STRG+S aus, um die Datei zu speichern.

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

    cd ..

  16. Aktualisieren Sie die App-Container.

    dotnet publish /p:PublishProfile=DefaultContainer

  17. Wechseln Sie zum Ordner "dotnet-observability ", 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 Ressourcengruppen aus.

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

  21. Wählen Sie die Ressource "eShopLiteInsights Application Insights" aus.

  22. Wählen Sie das Anwendungsdashboard aus.

    Screenshot, der in Application Insights den Gesundheitsstatus der eShopLite-App zeigt.

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

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