Ö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 ser hur du inkluderar OpenTelemetry NuGet-paketen och sedan lägger till observerbarhet i produkttjänsten .

Ö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 för att skapa codespace.

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 lagringsplatsen https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative till den lokala datorn. Sedan:

Installera alla 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: Återskapa och öppna igen i container
Välj eShopLite – dotnet-observerbarhet 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 Visual Studio Code-kommandopaletten anger du >.NET: Open Solution.
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 (Gemensamt, Bibliotek).
I fältet Namn anger du Diagnostik.
I listrutan Projekt skapas väljer du Standardkatalog.

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 Visual Studio Code:
```
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

Expandera mappen Diagnostik i explorer-fönstret och välj sedan Diagnostics.csproj.
Project Sdk Ändra längst upp till:
```
<Project Sdk="Microsoft.NET.Sdk.Web">
```
Med föregående kod kan du använda IConfiguration klassen i koden.
<PropertyGroup>I 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 Diagnostik är nu redo att användas av produkttjänsten.
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 Produkter i 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 Produkter :
```
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 terminalfönstret 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 
```
Serverdelscontainrarna (produkttjänsten ) och klientdelscontainrarna (Store Service) bör byggas. Sedan startar appen.
Om du gör den här övningen i ett kodområde väljer du fliken PORTar längst ned i Visual Studio Code-fönstret. Välj länken Öppna i webbläsaren bredvid frontend-tjänsten.
Om du gör den här övningen lokalt i Visual Studio Code går du till appen på http://localhost:32000en ny webbläsarflik.
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 produkttjänsten. 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.

Fortsätt