Cvičení – přidání OpenTelemetry do aplikace nativní pro cloud

7 min

V tomto cvičení přidáte do eShopLite řešení nový diagnostický projekt. Uvidíte, jak zahrnout balíčky NuGet OpenTelemetry a pak do služby Products přidat pozorovatelnost.

Otevřete vývojové prostředí a vytvořte prostředky Azure.

Můžete použít prostor kódu GitHubu, který je hostitelem cvičení, nebo cvičení dokončit místně v editoru Visual Studio Code.

Pokud chcete použít Codespace, vytvořte předem nakonfigurovaný Codespace GitHubu s touto šablonou pro vytvoření Codespace .

Tento krok trvá několik minut, než GitHub vytvoří a nakonfiguruje prostor kódu. Po dokončení procesu se zobrazí soubory kódu pro cvičení. Kód použitý pro zbytek tohoto modulu je v adresáři /dotnet-observability.

Abyste mohli použít Visual Studio Code, naklonujte úložiště https://github.com/MicrosoftDocs/mslearn-dotnet-cloudnative do místního počítače. Potom:

Nainstalujte všechny systémové požadavky pro spuštění dev kontejneru v editoru Visual Studio Code.
Ujistěte se, že je Docker spuštěný.
V novém okně editoru Visual Studio Code otevřete složku klonovaného úložiště.
Stisknutím kláves Ctrl+Shift+P otevřete paletu příkazů.
Hledání: >Dev Containers: Opětovné sestavení a opětovné otevření v kontejneru
V rozevírací nabídce vyberte eShopLite – dotnet-observability. Visual Studio Code vytvoří vývojový kontejner místně.

Přidání diagnostického projektu do řešení

Prvním krokem k přidání pozorovatelnosti do aplikace eShopLite je zavedení nového diagnostického projektu do řešení. Tento projekt obsahuje všechny balíčky a konfigurace OpenTelemetry, které použijete k přidání pozorovatelnosti do aplikace.

Na paletě příkazů editoru Visual Studio Code zadejte >.NET: Open Solution.
Vyberte dotnet-observability/eShopLite/eShopLite.sln.
V průzkumníku řešenív dolní části podokna EXPLORER klikněte pravým tlačítkem na řešení eShopLite a vyberte Nový projekt.
V dialogovém okně Vyberte šablonu pro nový projekt .NET vyberte Knihovnu tříd (Common, Library).
Do pole Název zadejte Diagnostika.
V rozevíracím seznamu Project, který bude vytvořen v rozevíracím seznamu, vyberte Výchozí adresář.

Přidání balíčků OpenTelemetry

Teď přidejte balíčky OpenTelemetry do nového diagnostického projektu.

Pomocí podokna TERMINAL v dolní části editoru Visual Studio Code přejděte do složky projektu Diagnostics:
```
cd dotnet-observability/eShopLite/Diagnostics
```

Spusťte tyto příkazy dotnet add:

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

V podokně EXPLORER rozbalte složku Diagnostics a pak vyberte Diagnostics.csproj.
Změňte Project Sdk v horní části na:
```
<Project Sdk="Microsoft.NET.Sdk.Web">
```
Předchozí kód umožňuje použít třídu IConfiguration v kódu.
Do <PropertyGroup>přidejte typ výstupu:
```
<OutputType>Library</OutputType>
```
Výše uvedený kód zajistí, že se projekt sestaví jako knihovna. V opačném případě kompilátor očekává Program.cs soubor s main metodou.

Přidání kódu pro použití OpenTelemetry

S přidanými balíčky OpenTelemetry nyní zavedete kód, který je použije.

Na panelu EXPLORER klikněte pravým tlačítkem myši na soubor Class1.cs a vyberte Přejmenovat.
Přejmenujte soubor na DiagnosticServiceCollectionExtensions.cs.

Nahraďte kód v souboru následujícím kódem:

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;
  }
}

V podokně TERMINAL spusťte tento příkaz pro sestavení projektu:
```
dotnet build
```
Měl by se zobrazit výstup podobný tomuto příkladu:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```
Projekt diagnostiky je nyní připravený k použití službou products.
V podokně EXPLORER, v části SOLUTION EXPLORER, klikněte pravým tlačítkem myši na projekt Products a poté vyberte Přidat referenci projektu.
Vyberte diagnostiky.
V podokně EXPLORER rozbalte složku Products a pak vyberte Program.cs.
Pod komentář kódu // Add observability code herepřidejte volání metody Diagnostiky:
```
builder.Services.AddObservability("Products", builder.Configuration);
```
V podokně TERMINAL přejděte do složky Products:
```
cd ../Products
```
Spuštěním tohoto příkazu sestavte projekt:
```
dotnet build
```
Měl by se zobrazit výstup podobný tomuto příkladu:
```
Build succeeded.
    0 Warning(s)
    0 Error(s)
```

Aktualizace nastavení Dockeru a spuštění aplikace

V podokně TERMINAL přejděte do kořenového adresáře složky dotnet-observability:
```
cd ..
dotnet publish /p:PublishProfile=DefaultContainer
```
Spusťte tyto příkazy Dockeru:
```
cd /workspaces/mslearn-dotnet-cloudnative/dotnet-observability/
docker compose up 
```
Kontejnery pro back-end (Products service) a front-end (Store service) by měly být sestaveny. Pak se aplikace spustí.
Pokud toto cvičení provádíte v Codespace, vyberte kartu PORTY ve spodní části okna Visual Studio Code. Vyberte odkaz Otevřít v prohlížeči vedle služby Front End.
Pokud toto cvičení provádíte místně ve Visual Studio Code, přejděte v nové kartě prohlížeče do aplikace na http://localhost:32000.
V aplikaci na navigačním panelu vyberte Produkty.
Vyberte Aktualizovat zásoby pro některé z produktů. Potom v dialogovém okně změňte hodnotu akcií a vyberte Aktualizovat.

Vyberte kartu TERMINAL a procházejte zprávami. Všimněte si, že z OpenTelemetry existují zprávy jako:

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

Stisknutím kláves Ctrl+C aplikaci zastavte.

Úspěšně jste přidali OpenTelemetry do služby Products. V další lekci se dozvíte, jak lépe využívat telemetrická data jejich zobrazením v nástrojích, jako je Prometheus a Grafana.