Contrôles d’intégrité gRPC dans ASP.NET Core

Par James Newton-King

Le protocole de contrôle d’intégrité gRPC est une norme permettant de signaler l’intégrité des applications serveur gRPC.

Les contrôles d’intégrité sont exposés par une application comme un service gRPC. Ils sont généralement utilisés avec un service d’analyse externe pour vérifier l’état d’une application. Le service peut être configuré pour différents scénarios de supervision en temps réel :

• Les sondes d’intégrité peuvent être utilisées par les orchestrateurs de conteneurs et les équilibreurs de charge afin de vérifier l’état d’une application. Par exemple, Kubernetes prend en charge la disponibilité, la préparation et les sondes de démarrage gRPC. Kubernetes peut être configuré pour rediriger le trafic ou redémarrer des conteneurs non sains en fonction des résultats de contrôle d’intégrité gRPC.
• L’utilisation de la mémoire, des disques et des autres ressources de serveur physique peut être supervisée dans le cadre d’un contrôle d’intégrité.
• Les contrôles d’intégrité peuvent tester les dépendances d’une application, telles que les bases de données et les points de terminaison de service externes, dans le but de vérifier leur disponibilité et leur bon fonctionnement.

Configurer les contrôles d’intégrité gRPC

gRPC ASP.NET Core dispose de la prise en charge intégrée des contrôles d’intégrité gRPC avec le package Grpc.AspNetCore.HealthChecks. Les résultats des contrôles d’intégrité .NET sont signalés aux appelants.

Pour configurer des contrôles d’intégrité gRPC dans une application :

• Ajoutez une référence de package Grpc.AspNetCore.HealthChecks.
• Inscrire le service de contrôles d’intégrité gRPC :
  • AddGrpcHealthChecks pour inscrire les services qui activent les contrôles d’intégrité.
  • MapGrpcHealthChecksService pour ajouter un point de terminaison de service de contrôle d’intégrité.
• Ajoutez des contrôles d’intégrité en implémentant IHealthCheck ou en utilisant la méthode AddCheck.

using GrpcServiceHC.Services;
using Microsoft.Extensions.Diagnostics.HealthChecks;

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddGrpc();
builder.Services.AddGrpcHealthChecks()
                .AddCheck("Sample", () => HealthCheckResult.Healthy());

var app = builder.Build();

app.MapGrpcService<GreeterService>();
app.MapGrpcHealthChecksService();

// Code removed for brevity.

Lorsque les contrôles d’intégrité sont configurés :

• Le service de contrôles d’intégrité est ajouté à l’application serveur.
• Les contrôles d’intégrité .NET inscrits auprès de l’application sont régulièrement exécutés pour obtenir des résultats d’intégrité. Par défaut, il y a un délai de 5 secondes après le démarrage de l’application, puis des vérifications d’intégrité sont exécutées toutes les 30 secondes. L’intervalle d’exécution du contrôle d’intégrité peut être personnalisé avec HealthCheckPublisherOptions.
• Les résultats d’intégrité déterminent ce que le service gRPC signale :
  • Unknown est signalé lorsqu’il n’y a aucun résultat de santé.
  • NotServing est signalé lorsqu’il y a des résultats de santé de HealthStatus.Unhealthy.
  • Sinon, Serving est signalé.

Sécurité du service de contrôle d’intégrité

Les contrôles d’intégrité gRPC permettent de déterminer l’état de santé d’une application, ce qui peut constituer une information sensible. Il convient de veiller à limiter l’accès au service des contrôles d’intégrité gRPC.

L’accès au service peut être contrôlé par des méthodes d’extension d’autorisation ASP.NET Core standard, telles que AllowAnonymous et RequireAuthorization.

Par exemple, si une application a été configurée pour nécessiter une autorisation par défaut, configurez le point de terminaison des contrôles d’intégrité gRPC avec AllowAnonymous pour ignorer l’authentification et l’autorisation.

app.MapGrpcHealthChecksService().AllowAnonymous();

Configurer Grpc.AspNetCore.HealthChecks

Par défaut, le service de contrôles d’intégrité gRPC utilise tous les contrôles d’intégrité inscrits pour déterminer les statuts d’intégrité. Les contrôles d’intégrité gRPC peuvent être personnalisés lors de l’inscription pour utiliser un sous-ensemble de contrôles d’intégrité. La méthode MapService est utilisée pour mapper les résultats d’intégrité aux noms de service, ainsi qu’un prédicat pour filtrer les résultats d’intégrité :

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddGrpc();
builder.Services.AddGrpcHealthChecks(o =>
{
    o.Services.MapService("", r => r.Tags.Contains("public"));
});

var app = builder.Build();

Le code précédent remplace le service par défaut ("") pour utiliser uniquement les résultats d’intégrité avec la balise « public ».

Les contrôles d’intégrité gRPC prennent en charge le client spécifiant un argument de nom de service lors du contrôle de l’intégrité. Plusieurs services sont pris en charge en fournissant un nom de service à MapService :

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddGrpc();
builder.Services.AddGrpcHealthChecks(o =>
{
    o.Services.MapService("greet.Greeter", r => r.Tags.Contains("greeter"));
    o.Services.MapService("count.Counter", r => r.Tags.Contains("counter"));
});

var app = builder.Build();

Le nom de service spécifié par le client est généralement le nom par défaut ("") ou un nom qualifié de package d’un service dans votre application. Toutefois, rien n’empêche le client d’utiliser des valeurs arbitraires pour contrôler l’intégrité de l’application.

Configurer l’intervalle d’exécution des contrôles d’intégrité

Les contrôles d’intégrité sont exécutés immédiatement quand la méthode Check est appelée. Watch est une méthode de diffusion en continu, avec un comportement différent de Check : Le flux durable signale les résultats des contrôles d’intégrité au fil du temps en exécutant régulièrement IHealthCheckPublisher pour collecter les résultats sur l’intégrité. Par défaut, l’éditeur :

• Attend 5 secondes, après le démarrage de l’application, avant d’exécuter des contrôles d’intégrité.
• Exécute des contrôles d’intégrité toutes les 30 secondes.

Les intervalles du serveur de publication peuvent être configurés à l’aide de HealthCheckPublisherOptions au démarrage :

builder.Services.Configure<HealthCheckPublisherOptions>(options =>
{
    options.Delay = TimeSpan.Zero;
    options.Period = TimeSpan.FromSeconds(10);
});

Appeler le service de contrôles d’intégrité gRPC

Le package Grpc.HealthCheck inclut un client pour les contrôles d’intégrité gRPC :

var channel = GrpcChannel.ForAddress("https://localhost:5001");
var client = new Health.HealthClient(channel);

var response = await client.CheckAsync(new HealthCheckRequest());
var status = response.Status;

Il existe deux méthodes sur le service Health :

• Check est une méthode unaire permettant d’obtenir l’état d’intégrité actuel. Les contrôles d’intégrité sont exécutés immédiatement lorsque Check est appelé. Le serveur retourne une réponse d’erreur NOT_FOUND si le client demande un nom de service inconnu. Cela peut se produire au démarrage de l’application si les résultats d’intégrité n’ont pas encore été publiés.
• Watch est une méthode de diffusion en continu qui signale les modifications du statut de l’intégrité au fil du temps. IHealthCheckPublisher est exécuté périodiquement pour collecter les résultats d’intégrité. Le serveur retourne un statut Unknown si le client demande un nom de service inconnu.

Le client Grpc.HealthCheck peut être utilisé dans une approche de fabrique de clients :

builder.Services
    .AddGrpcClient<Health.HealthClient>(o =>
    {
        o.Address = new Uri("https://localhost:5001");
    });

Dans l’exemple précédent, une fabrique de clients pour les instances Health.HealthClient est inscrite auprès du système d’injection de dépendances. Ces instances sont ensuite injectées dans des services pour l’exécution d’appels de vérification d’intégrité.

Pour plus d’informations, consultez Intégration de la fabrique de clients gRPC dans .NET.

Ressources supplémentaires

• Contrôles d’intégrité dans ASP.NET Core
• Protocole de contrôle d’intégrité gRPC
• Grpc.AspNetCore.HealthChecks
• Grpc.HealthCheck