Monitoring des ressources

Le monitoring des ressources implique la mesure continue de l’utilisation des ressources sur une période spécifiée. Le package NuGet Microsoft.Extensions.Diagnostics.ResourceMonitoring propose une collection d’API conçues pour monitorer l’utilisation des ressources de vos applications .NET.

L’interface IResourceMonitor fournit des méthodes permettant de récupérer des informations en temps réel concernant l’utilisation des ressources de processus. Cette interface prend en charge la récupération des données liées à l’utilisation du processeur et de la mémoire. Elle est actuellement compatible avec les plateformes Windows et Linux. Toutes les informations du monitoring des ressources de diagnostic sont publiées par défaut sur OpenTelemetry. Vous n’êtes donc pas tenu de les publier manuellement.

En outre, la bibliothèque de surveillance des ressources signale différentes métriques de diagnostic. Pour plus d’informations, consultez Métriques de diagnostic : Microsoft.Extensions.Diagnostics.ResourceMonitoring.

Exemple d’utilisation du monitoring des ressources

L’exemple suivant montre comment utiliser l’interface IResourceMonitor pour récupérer des informations sur l’utilisation du processeur et de la mémoire par le processus actuel.

C#

using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Diagnostics.ResourceMonitoring;
using Microsoft.Extensions.Logging;
using Spectre.Console;

var services = new ServiceCollection()
    .AddLogging(static builder => builder.AddConsole())
    .AddResourceMonitoring();

var provider = services.BuildServiceProvider();

var monitor = provider.GetRequiredService<IResourceMonitor>();

Le code précédent :

• Instancie une nouvelle instance ServiceCollection, chaînant les appels aux méthodes d’extension AddLogging et AddResourceMonitoring.
• Génère une nouvelle instance ServiceProvider à partir de l’instance ServiceCollection.
• Obtient une instance de l’interface IResourceMonitor à partir de l’instance ServiceProvider.

Important

Le package Microsoft.Extensions.Diagnostics.ResourceMonitoring part du principe que le consommateur inscrit les fournisseurs de journalisation auprès du package Microsoft.Extensions.Logging. Si vous n’inscrivez pas la journalisation, l’appel à AddResourceMonitoring lève une exception. En outre, vous pouvez activer la journalisation de bibliothèque interne en configurant le Debug niveau de journalisation de la Microsoft.Extensions.Diagnostics.ResourceMonitoring catégorie conformément au guide.

À ce stade, avec l’implémentation IResourceMonitor, vous demandez l’utilisation des ressources à l’aide de la méthode IResourceMonitor.GetUtilization. La méthode GetUtilization retourne une instance ResourceUtilization qui contient les informations suivantes :

• ResourceUtilization.CpuUsedPercentage : utilisation du processeur en pourcentage.
• ResourceUtilization.MemoryUsedPercentage : utilisation de la mémoire en pourcentage.
• ResourceUtilization.MemoryUsedInBytes : utilisation de la mémoire en octets.
• ResourceUtilization.SystemResources : ressources système.
  • SystemResources.GuaranteedMemoryInBytes : mémoire garantie en octets.
  • SystemResources.MaximumMemoryInBytes : mémoire maximale en octets.
  • SystemResources.GuaranteedCpuUnits : processeur garanti en unités.
  • SystemResources.MaximumCpuUnits : processeur maximal en unités.

Étendre le monitoring des ressources avec Spectre.Console

Pour aller plus loin avec cet exemple, vous pouvez tirer profit de Spectre.Console, une bibliothèque .NET réputée qui est conçue pour simplifier le développement d’applications console multiplateformes esthétiques. Avec Spectre, vous pouvez présenter les données d’utilisation des ressources dans un format tabulaire. Le code suivant illustre l’utilisation de l’interface IResourceMonitor pour accéder aux détails relatifs à l’utilisation du processeur et de la mémoire par le processus actuel, puis la présentation de ces données dans un tableau :

C#

await StartMonitoringAsync(monitor, token);

async Task StartMonitoringAsync(IResourceMonitor monitor, CancellationToken cancellationToken)
{
    var table = new Table()
        .Centered()
        .Title("Resource Monitoring", new Style(foreground: Color.Purple, decoration: Decoration.Bold))
        .Caption("Updates every three seconds. *GTD: Guaranteed ", new Style(decoration: Decoration.Dim))
        .RoundedBorder()
        .BorderColor(Color.Cyan1)
        .AddColumns(
        [
            new TableColumn("Time").Centered(),
            new TableColumn("CPU %").Centered(),
            new TableColumn("Memory %").Centered(),
            new TableColumn("Memory (bytes)").Centered(),
            new TableColumn("GTD / Max Memory (bytes)").Centered(),
            new TableColumn("GTD / Max CPU (units)").Centered(),
        ]);

    await AnsiConsole.Live(table)
        .StartAsync(async ctx =>
        {
            var window = TimeSpan.FromSeconds(3);
            while (cancellationToken.IsCancellationRequested is false)
            {
                var utilization = monitor.GetUtilization(window);
                var resources = utilization.SystemResources;

                table.AddRow(
                    [
                        $"{DateTime.Now:T}",
                        $"{utilization.CpuUsedPercentage:p}",
                        $"{utilization.MemoryUsedPercentage:p}",
                        $"{utilization.MemoryUsedInBytes:#,#}",
                        $"{resources.GuaranteedMemoryInBytes:#,#} / {resources.MaximumMemoryInBytes:#,#}",
                        $"{resources.GuaranteedCpuUnits} / {resources.MaximumCpuUnits}",
                    ]);

                ctx.Refresh();
                await Task.Delay(window);
            }
        });

    Console.CancelKeyPress += (_, e) =>
    {
        e.Cancel = true;
        cancellationTokenSource.Cancel();
    };
}

Le code précédent :

• Crée une source de jeton d’annulation et un jeton d’annulation.
• Crée une instance Table et la configure avec un titre, une légende et des colonnes.
• Effectue un rendu en direct de l’instance Table, en passant un délégué qui est appelé toutes les trois secondes.
• Obtient des informations sur l’utilisation actuelle des ressources de l’instance IResourceMonitor et les affiche sous forme d’une nouvelle ligne dans l’instance Table.

Voici un exemple de sortie du code précédent :

Pour obtenir le code source de cet exemple, consultez l’exemple de monitoring des ressources.

Sondes Kubernetes

Outre le monitoring des ressources, les applications qui existent dans un cluster Kubernetes signalent leur intégrité par le biais de sondes de diagnostic. Le package NuGet Microsoft.Extensions.Diagnostics.Probes prend en charge les sondes Kubernetes. Il externalise divers contrôles d’intégrité qui s’alignent sur différentes sondes Kubernetes, par exemple :

• Activité
• Préparation
• Startup

La bibliothèque communique l’intégrité actuelle des applications à un environnement d’hébergement Kubernetes. Si un processus signale qu’il n’est pas sain, Kubernetes ne lui envoie aucun trafic, ce qui laisse au processus le temps de récupérer ou de se terminer.

Pour ajouter la prise en charge des sondes Kubernetes, ajoutez une référence de package à Microsoft.Extensions.Diagnostics.Probes. Sur une instance IServiceCollection, appelez AddKubernetesProbes.

Voir aussi

• Métriques d’extensions .NET