Övning – Lägga till OpenTelemetry i ett molnbaserat program

7 minuter

I den här övningen lägger du till ett nytt diagnostikprojekt i din eShopLite lösning. Du får se hur du inkluderar OpenTelemetry NuGet-paketen och sedan lägger till observerbarhet i tjänsten Products.

Öppna utvecklingsmiljön och skapa Azure-resurserna

Du kan välja att använda ett GitHub-kodområde som är värd för övningen eller slutföra övningen lokalt i Visual Studio Code.

Om du vill använda ett kodområde skapar du ett förkonfigurerat GitHub-kodområde med den här mallen codespace creation.

Det här steget tar flera minuter medan GitHub skapar och konfigurerar kodområdet. När processen är klar visas kodfilerna för övningen. Koden som används för resten av den här modulen finns i katalogen /dotnet-observability.

Om du vill använda Visual Studio Code, klonar du https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative lagringsplatsen till den lokala datorn. Då:

Installera eventuella systemkrav för att köra Dev Container i Visual Studio Code.
Kontrollera att Docker körs.
Öppna mappen för den klonade lagringsplatsen i ett nytt Visual Studio Code-fönster.
Tryck på Ctrl+Skift+P för att öppna kommandopaletten.
Sök: >Dev Containers: Återuppbygg och öppna igen i containern.
Välj eShopLite – dotnet-observability i listrutan. Visual Studio Code skapar din utvecklingscontainer lokalt.

Lägga till ett diagnostikprojekt i lösningen

Det första steget för att lägga till observerbarhet i eShopLite-appen är att introducera ett nytt diagnostikprojekt i lösningen. Det här projektet innehåller alla OpenTelemetry-paket och konfigurationer som du ska använda för att lägga till observerbarhet i appen.

I kommandopaletten för Codespace anger du >.NET: Öppna lösning.
Välj dotnet-observability/eShopLite/eShopLite.sln.
Högerklicka på eShopLite-lösningen längst ned i explorer-fönstret i Solution Explorer och välj sedan Nytt projekt.
I dialogrutan Välj en mall för att skapa ett nytt .NET-projekt väljer du Klassbibliotek (Vanligt, Bibliotek).
I fältet Namn anger du Diagnostik.
I listrutan Projekt kommer att skapas i, säkerställ att filsökvägskatalogen är /workspaces/mslearn-dotnet-cloudnative/dotnet-observability/eShopLite/.

Lägga till OpenTelemetry-paket

Lägg nu till OpenTelemetry-paketen i det nya diagnostikprojektet.

Gå till projektmappen Diagnostik genom att använda terminalfönstret längst ned i Codespace:
```
cd dotnet-observability/eShopLite/Diagnostics
```

Kör följande dotnet add kommandon:

dotnet add package OpenTelemetry.Exporter.Console
dotnet add package OpenTelemetry.Extensions.Hosting
dotnet add package OpenTelemetry.Instrumentation.AspNetCore
dotnet add package OpenTelemetry.Instrumentation.EventCounters --prerelease
dotnet add package OpenTelemetry.Instrumentation.Runtime
dotnet add package OpenTelemetry.Instrumentation.SqlClient --prerelease
dotnet add package OpenTelemetry.Instrumentation.Http

I fönstret EXPLORER expanderar du mappen Diagnostics och väljer sedan Diagnostics.csproj.
Ändra Project Sdk längst upp till:
```
<Project Sdk="Microsoft.NET.Sdk.Web">
```
Med föregående kod kan du använda klassen IConfiguration i koden.
I <PropertyGroup>lägger du till utdatatypen:
```
<OutputType>Library</OutputType>
```
Föregående kod säkerställer att projektet byggs som ett bibliotek. Annars förväntar sig kompilatorn en Program.cs fil med en main-metod.

Lägg till koden för att använda OpenTelemetry

Med OpenTelemetry-paketen tillagda introducerar du nu koden för att använda dem.

Högerklicka på filen Class1.cs i explorer-fönstret och välj sedan Byt namn.
Byt namn på filen till DiagnosticServiceCollectionExtensions.cs.

Ersätt koden i filen med följande kod:

using OpenTelemetry.Metrics;
using OpenTelemetry.Resources;
using OpenTelemetry.Trace;

namespace Microsoft.Extensions.DependencyInjection;

public static class DiagnosticServiceCollectionExtensions
{
  public static IServiceCollection AddObservability(this IServiceCollection services,
      string serviceName,
      IConfiguration configuration)
  {
    // create the resource that references the service name passed in
    var resource = ResourceBuilder.CreateDefault().AddService(serviceName: serviceName, serviceVersion: "1.0");

    // add the OpenTelemetry services
    var otelBuilder = services.AddOpenTelemetry();

    otelBuilder
        // add the metrics providers
        .WithMetrics(metrics =>
        {
          metrics
            .SetResourceBuilder(resource)
            .AddRuntimeInstrumentation()
            .AddAspNetCoreInstrumentation()
            .AddHttpClientInstrumentation()
            .AddEventCountersInstrumentation(c =>
            {
              c.AddEventSources(
                      "Microsoft.AspNetCore.Hosting",
                      "Microsoft-AspNetCore-Server-Kestrel",
                      "System.Net.Http",
                      "System.Net.Sockets");
            })
            .AddMeter("Microsoft.AspNetCore.Hosting", "Microsoft.AspNetCore.Server.Kestrel")
            .AddConsoleExporter();

        })
        // add the tracing providers
        .WithTracing(tracing =>
        {
          tracing.SetResourceBuilder(resource)
                      .AddAspNetCoreInstrumentation()
                      .AddHttpClientInstrumentation()
                      .AddSqlClientInstrumentation();
        });

    return services;
  }
}

I fönstret TERMINAL kör du det här kommandot för att skapa projektet:
```
dotnet build
```
Du bör se utdata som liknar det här exemplet:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```
Projektet Diagnostics är nu redo att användas av tjänsten Products.
Högerklicka på projektet Products (Produkter) i explorer-fönstret under SOLUTION EXPLORER och välj sedan Lägg till projektreferens.
Välj Diagnostik.
Expandera mappen Produkteri explorer-fönstret och välj sedan Program.cs.
Under kodkommenten // Add observability code herelägger du till ett anrop till metoden Diagnostik:
```
builder.Services.AddObservability("Products", builder.Configuration);
```
I fönstret TERMINAL går du till mappen Products:
```
cd ../Products
```
Kör det här kommandot för att skapa projektet:
```
dotnet build
```
Du bör se utdata som liknar det här exemplet:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```

Uppdatera Docker-inställningarna och kör appen

I fönstret TERMINAL går du till roten för mappen dotnet-observability:
```
cd ..
dotnet publish /p:PublishProfile=DefaultContainer
```
Kör dessa Docker-kommandon:
```
cd /workspaces/mslearn-dotnet-cloudnative/dotnet-observability/
docker compose up 
```
Backend-containerna (Products service) och frontend-containerna (Store service) ska byggas. Sedan startar appen.
Om du gör den här övningen i en Codespace-miljö väljer du fliken PORTS längst ned i Visual Studio Code-fönstret. Välj länken Öppna i webbläsaren bredvid tjänsten Front End.
Om du gör den här övningen lokalt i Visual Studio Code går du till appen på en ny webbläsarflik på http://localhost:32000.
I appen väljer du Produkter i navigeringsfältet.
Välj Uppdatera lager för flera av produkterna. I dialogrutan ändrar du sedan lagervärdet och väljer Uppdatera.

Välj fliken TERMINAL och bläddra igenom meddelandena. Observera att det finns meddelanden från OpenTelemetry som:

backend-1   | Export ec.Microsoft-AspNetCore-Server-Kestrel.connection-queue-length, Meter: OpenTelemetry.Instrumentation.EventCounters/1.5.1.1
backend-1   | (2023-11-09T19:55:14.8933518Z, 2023-11-09T20:04:44.8596671Z] http.request.method: PUT http.response.status_code: 200 http.route: /api/Stock/{id} network.protocol.name: http network.protocol.version: 1.1 url.scheme: http Histogram      
backend-1   | Value: Sum: 0.05144170000000001 Count: 4 Min: 0.0039736 Max: 0.0359739

Tryck på Ctrl+C för att stoppa appen.

Du har lagt till OpenTelemetry i tjänsten Products. I nästa lektion får du se hur du kan använda telemetridata bättre genom att visa dem på verktyg som Prometheus och Grafana.

Feedback

Var den här sidan till hjälp?