Vérifications de santé dans .NET.NET Aspire

Article
15/12/2024

Les vérifications de santé fournissent des informations sur la disponibilité et l'état d'une application. Les vérifications de l'état de santé sont souvent exposées en tant que points de terminaison HTTP, mais peuvent également être utilisées en interne par l'application pour consigner des journaux ou effectuer d'autres tâches en fonction de l'état de santé actuel. Les vérifications d’intégrité sont généralement utilisées conjointement avec un service de supervision externe ou un orchestrateur de conteneur pour vérifier l’état d’une application. Les données rapportées par les vérifications de santé peuvent être utilisées pour différents scénarios :

Influencez les décisions prises par les orchestrateurs de conteneurs, les équilibreurs de charge, les passerelles d’API et d’autres services de gestion. Par exemple, si le contrôle d’intégrité d’une application conteneurisée échoue, elle peut être ignorée par un équilibrage de charge qui répartit le trafic.
Vérifiez que les dépendances sous-jacentes sont disponibles, telles qu’une base de données ou un cache, et retournez un message d’état approprié.
Déclenchez des alertes ou des notifications lorsqu’une application ne répond pas comme prévu.

.NET .NET Aspire points de terminaison de contrôle d’intégrité

.NET .NET Aspire expose deux points de terminaison HTTP de contrôle d’intégrité par défaut dans les environnements Développement lorsque les méthodes AddServiceDefaults et MapDefaultEndpoints sont appelées à partir du fichier Program.cs :

Le point de terminaison /health indique si l’application s’exécute normalement où elle est prête à recevoir des demandes. Toutes les vérifications d’intégrité doivent passer pour que l’application soit considérée comme prête à accepter le trafic après le démarrage.

HTTP
```
GET /health
```
Le point de terminaison /health retourne un code d’état HTTP 200 et une valeur text/plain de Healthy lorsque l’application est saine.
La /alive indique si une application est en cours d’exécution ou a bloqué et doit être redémarrée. Seules les vérifications d’intégrité étiquetées avec la balise live doivent être réussies pour que l’application soit considérée comme opérationnelle.

HTTP
```
GET /alive
```
Le point de terminaison /alive retourne un code d’état HTTP 200 et une valeur text/plain de Healthy lorsque l’application est active.

Les méthodes et appliquent également diverses configurations à votre application, au-delà des vérifications d’intégrité, comme les configurations de découverte de services, ainsi que et .

Environnements sans développement

Dans les environnements sans développement, les points de terminaison /health et /alive sont désactivés par défaut. Si vous devez les activer, il est recommandé de protéger ces points de terminaison avec différentes fonctionnalités de routage, telles que le filtrage et/ou l’autorisation de l’hôte. Pour plus d’informations, consultez les contrôles de santé dans àde .

En outre, il peut être avantageux de configurer les délais d’expiration des demandes et la mise en cache de sortie pour ces points de terminaison afin d’empêcher les attaques par abus ou par déni de service. Pour ce faire, tenez compte de la méthode AddDefaultHealthChecks modifiée suivante :

public static IHostApplicationBuilder AddDefaultHealthChecks(this IHostApplicationBuilder builder)
{
    builder.Services.AddRequestTimeouts(
        configure: static timeouts =>
            timeouts.AddPolicy("HealthChecks", TimeSpan.FromSeconds(5)));

    builder.Services.AddOutputCache(
        configureOptions: static caching =>
            caching.AddPolicy("HealthChecks",
            build: static policy => policy.Expire(TimeSpan.FromSeconds(10))));

    builder.Services.AddHealthChecks()
        // Add a default liveness check to ensure app is responsive
        .AddCheck("self", () => HealthCheckResult.Healthy(), ["live"]);

    return builder;
}

Code précédent :

Ajoute un délai d’expiration de 5 secondes aux contrôles de santé avec une stratégie nommée HealthChecks.
Ajoute un cache de 10 secondes aux réponses de vérification d’intégrité avec une stratégie nommée HealthChecks.

Tenez maintenant compte de la méthode MapDefaultEndpoints mise à jour :

public static WebApplication MapDefaultEndpoints(this WebApplication app)
{
    var healthChecks = app.MapGroup("");

    healthChecks
        .CacheOutput("HealthChecks")
        .WithRequestTimeout("HealthChecks");

    // All health checks must pass for app to be
    // considered ready to accept traffic after starting
    healthChecks.MapHealthChecks("/health");

    // Only health checks tagged with the "live" tag
    // must pass for app to be considered alive
    healthChecks.MapHealthChecks("/alive", new()
    {
        Predicate = static r => r.Tags.Contains("live")
    });

    return app;
}

Code précédent :

Regroupe les points de vérification de santé sous le chemin d’accès /.
Met en cache la sortie et spécifie un instant de requête avec la stratégie HealthChecks correspondante.

Outre les méthodes AddDefaultHealthChecks et MapDefaultEndpoints mises à jour, vous devez également ajouter les services correspondants pour les délais d’expiration des requêtes et la mise en cache de sortie.

Dans le point d’entrée de l’application consommatrice appropriée (généralement le fichier Program.cs), ajoutez le code suivant :

// Wherever your services are being registered.
// Before the call to Build().
builder.Services.AddRequestTimeouts();
builder.Services.AddOutputCache();

var app = builder.Build();

// Wherever your app has been built, before the call to Run().
app.UseRequestTimeouts();
app.UseOutputCache();

app.Run();

Pour plus d’informations, consultez intergiciels de délai d’attente de requête dans ASP.NET Core et intergiciel de mise en cache de sortie dans ASP.NET Core.

Vérifications d’intégrité de l’intégration

Les intégrations .NET.NET Aspire peuvent également enregistrer des vérifications d’intégrité supplémentaires pour votre application. Ces contrôles d’intégrité contribuent à l’état retourné des points de terminaison /health et /alive. Par exemple, l’intégration .NET AspirePostgreSQL ajoute automatiquement une vérification de l'état pour vérifier les conditions suivantes :

Une connexion de base de données peut être établie
Une requête de base de données peut être exécutée avec succès

Si l’une de ces opérations échoue, le contrôle d’intégrité correspondant échoue également.

Configurer les vérifications d’intégrité

Vous pouvez désactiver les vérifications d’intégrité d’une intégration donnée à l’aide de l’une des options de configuration disponibles. .NET .NET Aspire intégrations prennent en charge Microsoft.Extensions.Configurations pour appliquer des paramètres via des fichiers de configuration tels que appsettings.json:

JSON

{
  "Aspire": {
    "Npgsql": {
      "DisableHealthChecks": true,
    }
  }
}

Vous pouvez également utiliser un délégué en ligne pour configurer les contrôles de santé :

builder.AddNpgsqlDbContext<MyDbContext>(
    "postgresdb",
    static settings => settings.DisableHealthChecks  = true);

Voir aussi

.NET contrôles d’intégrité de l’application en C#
vérifications de santé dans ASP.NET Core

Partager via