Indietro

Prossima

Aggiungere l'osservabilità a un'applicazione nativa del cloud

Completato

Ora che si conosce l'importanza dell'osservabilità, si vedrà come includerla nell'applicazione nativa del cloud. Per eseguire questo passaggio, aggiungere OpenTelemetry all'app.

Aggiungere OpenTelemetry all'app

.NET offre un ricco ecosistema di strumenti di osservabilità predefiniti che producono dati di registrazione, metrica e traccia. È possibile usare questi strumenti per aggiungere l'osservabilità all'applicazione nativa del cloud. Queste librerie sono:

• Registrazione: Microsoft.Extensions.Logging.ILogger
• Metrica: System.Diagnostics.Metrics.Meter
• Traccia: System.Diagnostics.Activity e System.Diagnostics.ActivitySource

OpenTelemetry utilizza tutti i dati di telemetria precedenti, ma prima di tutto l'app nativa del cloud deve aggiungere il supporto per OpenTelemetry tramite pacchetti NuGet. Questi pacchetti possono essere classificati in tre gruppi:

Categoria	Pacchetto	Descrizione
API Core	OpenTelemetry	Libreria principale che fornisce la funzionalità principale di OpenTelemetry.
API Core	OpenTelemetry.Extensions.Hosting	Fornisce metodi di estensione per l'avvio e l'arresto automatico della traccia di OpenTelemetry negli host ASP.NET Core.
Strumentazione	OpenTelemetry.Instrumentation.AspNetCore	Strumentazione per le applicazioni ASP.NET Core. Questo pacchetto raccoglie un numero elevato di metriche sull'app senza dover scrivere codice.
Esportatore	OpenTelemetry.Exporter.Console	L'utilità di esportazione per la console consente all'app di scrivere i dati di telemetria nella console.

Sono disponibili molti altri pacchetti di strumentazione ed esportazione da includere nell'app nativa del cloud. Per altre informazioni, vedere Osservabilità di .NET con OpenTelemetry. A seconda del tipo di app da creare, è possibile aggiungere i pacchetti più pertinenti per le proprie necessità.

Questo modulo illustra l'uso di OpenTelemetry con l'app nativa del cloud eShopLite. Questa app viene creata con .NET Core e Blazor WebAssembly, quindi tutti gli esempi di codice sono basati sull'uso dell'inserimento delle dipendenze.

È possibile scegliere di includere tutti i pacchetti di OpenTelemetry per i servizi Products e Store nell'app di microservizi. Tuttavia, in un'app reale sono disponibili molti altri servizi. L'aggiunta di tutti questi pacchetti a ognuno di tali servizi comporta una duplicazione non necessaria. Un approccio migliore consiste nell'aggiungere alla soluzione un nuovo progetto di diagnostica a cui può fare riferimento qualsiasi microservizio.

Ecco un esempio di codice che crea un metodo AddObservability che un microservizio può chiamare per usare OpenTelemetry:

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

  // Add the Prometheus endpoints to your service, this will expose the metrics at http://service/metrics
  public static void MapObservability(this IEndpointRouteBuilder routes)
  {
    routes.MapPrometheusScrapingEndpoint();
  }
}

Il metodo restituisce una classe IServiceCollection che può essere aggiunta come servizio a una classe WebApplicationBuilder di ASP.NET Core.

Questa azione crea quindi una variabile var otelBuilder = services.AddOpenTelemetry() per archiviare il generatore OpenTelemetry. Il codice può quindi aggiungere metriche e tracce a otelBuilder.

Ad esempio, questa configurazione aggiunge la strumentazione per:

• ASP.NET Core
• Runtime C#
• HttpClient
• Server Web Kestrel

Queste metriche vengono visualizzate nella console. Il metodo .AddConsoleExporter() aggiunge l'utilità di esportazione al generatore.

Aggiunge anche la traccia alla console per:

• ASP.NET Core
• HttpClient
• Client SQL

L'ultima riga restituisce la classe IServiceCollection.

Una volta completato il progetto di diagnostica, basta aggiungere un riferimento al progetto e una singola riga di codice al servizio. Ad esempio, per includere OpenTelemetry nel servizio Products, aggiungere il riferimento al progetto nel file Product.csproj:

<ProjectReference Include="..\Diagnostics\Diagnostics.csproj" />

Aggiungere quindi la riga seguente al file Program.cs nella dichiarazione di builder:

var builder = WebApplication.CreateBuilder(args);

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

Aggiungere questo codice ai servizi Products nell'app eShopLite.

Continua