Précédent

Suivant

Ajouter l’observabilité à une application native cloud

Effectué

Maintenant que vous comprenez l’importance de l’observabilité, vous voyez comment l’inclure dans votre application native cloud. Pour ce faire, ajoutez OpenTelemetry à votre application.

Ajouter OpenTelemetry à votre application

.NET dispose d’un écosystème riche d’outils d’observabilité intégrés qui produisent des données de journalisation, de métriques et de suivi. Pour ajouter l’observabilité à votre application native cloud, procédez comme suit : Ces bibliothèques sont les suivantes :

• de journalisation : Microsoft.Extensions.Logging.ILogger
• métriques: System.Diagnostics.Metrics.Meter
• de suivi : System.Diagnostics.Activity et System.Diagnostics.ActivitySource

OpenTelemetry consomme toutes les données de télémétrie précédentes, mais votre application native cloud doit d’abord ajouter la prise en charge d’OpenTelemetry en utilisant des packages NuGet. Ces packages peuvent être classés en trois groupes :

Catégorie	Package	Description
API Core	OpenTelemetry	Bibliothèque principale qui fournit la fonctionnalité OpenTelemetry principale.
API Core	OpenTelemetry.Extensions.Hosting	Fournit des méthodes d’extension pour démarrer et arrêter automatiquement le suivi OpenTelemetry dans ASP.NET hôtes Core.
Instrumentation	OpenTelemetry.Instrumentation.AspNetCore	Instrumentation pour les applications ASP.NET Core. Ce package collecte un grand nombre de métriques sur votre application sans avoir à écrire de code.
Exportateur	OpenTelemetry.Exporter.Console	L’exportateur pour la console permet à l’application d’écrire des données de télémétrie dans la console.

De nombreux packages d’instrumentation et d’exportation supplémentaires sont disponibles pour être inclus dans votre application native cloud. Pour plus d’informations, consultez l’observabilité .NET avec OpenTelemetry. Selon le type d’application que vous créez, vous pouvez ajouter les packages les plus pertinents pour vous.

Ce module se concentre sur l’utilisation d’OpenTelemetry avec l’application cloud-native eShopLite . Comme cette application est créée avec .NET Core et Blazor WebAssembly, tous les exemples de code sont basés sur l’utilisation de l’injection de dépendances.

Vous pouvez choisir d’inclure tous les packages OpenTelemetry aux services Products et Store dans l’application de microservices. Toutefois, dans une application réelle, vous avez beaucoup plus de services. L’ajout de tous ces packages à chacun d’eux implique une duplication inutile. Une meilleure approche consiste à ajouter un nouveau projet de diagnostic à votre solution que n’importe quel microservice peut référencer pour être observé.

Voici un exemple de code qui crée une méthode AddObservability qu’un microservice peut appeler pour utiliser 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();
  }
}

La méthode renvoie une classe IServiceCollection qui peut être ajoutée comme service à un WebApplicationBuilder ASP.NET Core.

Cette action crée ensuite une variable var otelBuilder = services.AddOpenTelemetry() pour stocker le générateur OpenTelemetry. Le code peut ensuite ajouter des métriques et des traces à otelBuilder.

Par exemple, cette configuration ajoute l’instrumentation pour les éléments suivants :

• ASP.NET Core
• Runtime C#
• HttpCLient
• Serveur web Kestrel

Ces métriques sont affichées dans la console. La méthode .AddConsoleExporter() ajoute l’exportateur au générateur.

Elle ajoute également le suivi à la console pour :

• ASP.NET Core
• HttpClient
• SQL Client

La dernière ligne renvoie la classe IServiceCollection.

Une fois le projet de diagnostic terminé, c’est aussi simple que d’ajouter une référence au projet et une seule ligne de code au service. Par exemple, pour inclure OpenTelemetry dans le service Products, ajoutez la référence du projet dans votre fichier Product.csproj :

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

Ajoutez ensuite la ligne suivante au Program.cs fichier sous votre déclaration de builder:

var builder = WebApplication.CreateBuilder(args);

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

Ajoutons ce code aux services Produits dans l’application eShopLite .

Continuer