Vérification de la santé de vos API ASP.NET Core

Avec l'avènement et la popularisation des API Web et des microservices, la surveillance de leur santé est indispensable, et lorsqu'il s'agit de gérer plusieurs API en même temps, cette tâche peut devenir assez difficile. Mais certaines fonctionnalités nous aident à développer des vérifications rapidement et avec précision : les vérifications de l'état.

Que sont les vérifications de l'état dans ASP.NET Core ?

Les vérifications de l'état font partie du middleware et des bibliothèques fournis par ASP.NET Core pour vous aider signaler l'état de santé des composants de l'infrastructure d'application.

Pourquoi avons-nous besoin de contrôles de santé ?

Parce que grâce à eux, nous pouvons surveiller le fonctionnement d'une application en temps réel, de manière simple et directe. 👨‍⚕️🩺

Comment fonctionnent les bilans de santé ?

Pour savoir si une API s'exécute de manière saine ou non, nous utilisons un bilan de santé pour valider l'état d'un service et ses dépendances via un point de terminaison dans le API du service REST.

Cela nous permet de décider rapidement et de manière standardisée si le service ou nos dépendances sont désactivés.

Ce point de terminaison utilise un service distinct qui évalue la disponibilité des fonctions du reste du système ainsi que l'état de ses dépendances.

Les informations collectées lors de la vérification peuvent inclure des calculs de performances, le temps d'exécution ou la connexion à d'autres services en aval. Une fois l'évaluation terminée, un code HTTP et un objet JSON sont renvoyés en fonction de l'évaluation des services dans le bilan de santé.

Maintenant que nous connaissons les bases des bilans de santé, nous pouvons mettre en œuvre un exemple et voir en pratique comment cela fonctionne.

👨‍💻 Vous pouvez accéder au code source complet ici.

Création du projet

Ouvrez une console PowerShell dans le dossier où vous souhaitez créer le projet, puis donnez la commande ci-dessous. Cette commande créera un projet d'API Web ASP.NET 5 avec le nom « HealthCheck ». Une fois qu'il est créé, vous pouvez ouvrir le fichier « HealthCheck.csproj » avec Visual Studio.

dotnet new webapi -n HealthCheck --framework net5.0

Ensuite, créez un nouveau contrôleur nommé « HealthController ” et ajoutez le code suivant :

using Microsoft.AspNetCore.Mvc;
using Microsoft. Extensions.Diagnostics.HealthChecks;
à l'aide de Microsoft.Extensions.Logging;[19659020]en utilisant System.Net;
en utilisant System.Threading.Tâches;

 espace de noms HealthCheck.Contrôleurs
{
    [Contrôleur]
    [Route("santé")]
    public classe  HealthController : ControllerBase
    {
        private readonly ILogger<HealthController> _logger;
        private readonly HealthCheckService ;

        public HealthController(ILogger<HealthController> logger, Service HealthCheckService)[19659043]{
            _logger = enregistreur;
            _service = service;
        }

        [HttpGet]
        public async Tâche<IActionResult> Get()
        {
            var rapport = wait _service.CheckHealthAsync ();

            _logger.LogInformation($"Get Health Information : {report}");

            return report.Statut == HealthStatus.Sain ? Ok(report) : StatusCode[19659028]((int)HttpStatusCode.ServiceUnavailable, rapport);
        }
    } 
}

Notre contrôleur contiendra la méthode chargée de vérifier la santé de l'API. Lorsqu'il reçoit une demande, il la vérifie, puis il renvoie un JSON avec le contenu de la réponse et, comme bonne pratique, nous avons ajouté une méthode pour consigner l'exécution.

Enregistrement du service HealthCheck

Ouvrez le fichier "Startup.cs" et à l'intérieur trouver la méthode "ConfigureServices". À l'intérieur, ajoutez cet extrait de code :

services.AddHealthChecks() ;

Vous pouvez maintenant démarrer l'application et vous verrez la route /health que nous venons de créer. Vous pouvez utiliser Fiddler pour faire la demande comme dans l'image ci-dessous :

Lorsque nous avons envoyé une demande à la route /health, l'application a renvoyé un objet JSON avec quelques informations :

Entrées : Un objet de type dictionnaire dans ce cas est vide.

Status : 2 – Dérivé de l'énumération « HealthStatus » et comme le résumé signifie :  « Indique que le contrôle d'intégrité a déterminé que le composant était sain ». L'API est « en bonne santé » : aucun problème n'a été détecté et nous avons maintenant un itinéraire juste pour vérifier cela. 🎉😊

Contrôle de santé dans la base de données

En plus de l'intégrité de l'application, nous pouvons également vérifier d'autres facteurs de base tels que la connexion à une base de données.

Dans ce cas, nous utiliserons Redis comme base de données. . Vous devez l'exécuter sur votre machine dans une image Docker ou directement. Si vous le souhaitez, vous pouvez utiliser n'importe quelle autre base de données, modifiez simplement la chaîne de connexion.

Pour cela, nous devons installer le package : "AspNetCore.HealthChecks.Redis" – Version="5.0.2". dans le projet avec NugetPackage ou depuis la console avec la commande :

dotnet add package AspNetCore.HealthChecks.Redis

Créons maintenant une classe « Helper » où nous mettrons la chaîne de connexion avec Redis. Créez ensuite un dossier appelé « Helpers » dans le projet, et à l'intérieur de celui-ci, créez une classe statique appelée « UtilsHelpers » et mettez-y le code suivant :

public static string GetConnectionString ()
{
return "localhost:6379";
}

Dans le fichier "Startup.cs" ajoutez la méthode chargée de vérifier la connexion avec Redis . Il utilisera la chaîne de connexion que nous venons de créer.

La méthode « ConfigureServices » du démarrage devrait donc ressembler à ceci :

 public void ConfigureServices(IServiceCollection services )
        {
            
            services.AddHealthChecks()
                .AddRedis(redisConnectionString: UtilsHelpers.G 19659028](), nom: "instance Redis");

            services.Ajouter des contrôleurs();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", nouveau OpenApiInfo { Titre = "HealthCheck"[19659028], Version = "v1" });
            });
        }

Si votre la connexion à Redis ou à une autre base de données que vous avez utilisée est correcte, lorsque vous effectuez la demande via Fiddler, nous obtenons le résultat suivant, affichant les informations sur la connexion :

Une autre fonction intéressante fournie par les contrôles de santé ASP.NET Core est une interface graphique avec une sorte de tableau de bord amusant afin que nous puissions visualiser les événements qui ont eu lieu pendant les contrôles et l'historique de l'ensemble exécution.

Alors, implémentons-le et voyons cela fonctionner. Pour cela, nous devons installer les dépendances suivantes dans le projet :

• AspNetCore.HealthChecks.UI
• AspNetCore.HealthChecks.UI.Client
• AspNetCore.HealthChecks.UI.InMemory.Storage

Maintenant au « Démarrage » du projet, nous allons ajouter les configurations des bibliothèques que nous venons d'installer dans le projet, puis remplacer la méthode « ConfigureServices » par celle-ci ci-dessous. Vous pouvez voir dans les commentaires la responsabilité de chaque configuration.

 public void ConfigureServices(IServiceCollection services)
        {
            
            services.AddHealthChecks()
                .AddRedis(redisConnectionString: UtilsHelpers.G 19659028](), nom: "instance Redis");

            services.Ajouter des contrôleurs();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", nouveau OpenApiInfo { Titre = "HealthCheck"[19659028], Version = "v1" });
            });

            
            services.AddHealthChecksUI(options =>
            {
                options.Définir le temps d'évaluation en secondes(5);
                options.Maximum HistoryEntriesPerEndpoint(10);
                options.AddHealthCheckEndpoint("Health Checks API", "/health"); 
            })[19659028].AddInMemoryStorage(); 
        }

Et la méthode « Configurer » la remplace par ceci :

public void Configure[19659028](Application IApplicationBuilder, IWebHostEnvironment env)
        {
            if (env.IsDevelopment( ]))
            {
                app.UseDeveloperExceptionPage();
                app.UtilisezSwagger();
                app.UseSwaggerUI(c => c.SwaggerEndpoint("/swagger/v1/ swagger.json", "HealthCheck v1"));
            }

            app.UtiliserHttpsRedirection();

            app.UseRouting();

            app.Utiliser l'autorisation();

            app.UseEndpoints(endpoints =>
            {
                points de terminaison.MapControllers();

                
                points de terminaison.MapHealthChecks("/health");
            });

            
            app.Utiliser HealthChecks("/health", new HealthCheckOptions
            {
                Prédicat = p => vrai,
                ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
            });

            
            app.UseHealthChecksUI(options => { options.UIPath = "/ tableau de bord"; });
        }

Notre tableau de bord est presque prêt à fonctionner. Maintenant, dans la classe « UtilsHelpers », ajoutez la méthode suivante :

 public static string ToJSON(this object @object) => JsonConvert.SerializeObject(@object, Formatage .Aucun);

🔴 Important ! Pour utiliser la méthode « SerializeObject », vous devez installer « Newtonsoft.Json » – Version=« 13.0.1 » comme dépendance.

Et maintenant, dans le « HealthController » remplacez la méthode « Get » par :

 [HttpGet]
        public async Tâche <IActionResult> Get()
        {
            var rapport = wait _service.CheckHealthAsync();
            var rapportVersJson = rapport.VersJSON();

            _logger.LogInformation($"Get Health Information : {reportToJson}");

            return report.Status == HealthStatus.Sain ? Ok(reportToJson) : StatusCode[19659028]((int)HttpStatusCode.ServiceUnavailable, reportToJson);
        }

Enfin , nous pouvons voir notre tableau de bord. Pour cela, lancez l'application et allez dans « localhost:PORT/dashboard ». Si vous avez suivi toutes les étapes précédentes, vous verrez dans votre navigateur ce beau tableau de bord avec les données de vérification :

Personnalisation des contrôles

Une fonctionnalité intéressante est la possibilité de personnaliser les contrôles, choisir comment nous voulons retourner les résultats.

Pour cela, nous devons créer une classe qui héritera de l'interface « IHealthCheck ». Créez ensuite un dossier appelé « Personnalisé » et à l'intérieur, créez une classe nommée « CustomHealthChecks » et placez-y le code ci-dessous :

à l'aide de Microsoft.Extensions.Diagnostics .HealthChecks;
en utilisant System;
en utilisant System.Net;
en utilisant System.Net.Http;
using System.Threading;
using System .Threading.Tasks;

namespace HealthCheck.Personnalisé
{
    public class CustomHealthChecks : IHealthCheck
    {
        public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context,Annulation du jeton = default)
        {
            var catUrl = "https://http.cat/401";

            var  client = nouveau HttpClient();

            client.BaseAddress = new Uri(catUrl);

            Réponse HttpResponseMessage = wait client.GetAsync("");

            return réponse[19459029StatusCode == HttpStatusCode.OK ? 
                wait Task.FromResult(nouveau  Résultat du contrôle de santé(
                      état : État de santé.Sain,
                      description: "L'API est saine （。＾▽＾）")) :
                wait Task.FromResult[19659028](nouveau HealthCheckResult(
                      état : État de santé.Mauvais,
                      description: "L'API est malade ('﹏*๑)"));
        }
    }
}

Dans cette classe , nous créons une méthode qui fait une requête à une API "cat" et renvoie le résultat avec un Kaomoji amusant.

Mais ce n'est pas encore fait, nous devons faire l'injection de dépendance de classe.

Donc, au démarrage, nous allons ajouter le contrôle dans la classe juste après le contrôle Redis, donc la méthode « ConfigureServices » devrait ressembler à ceci :

 public void ConfigureServices( Services IServiceCollection)
        {
            
            services.AddHealthChecks()
                .AddRedis(redisConnectionString: UtilsHelpers.G 19659028](), nom: "instance Redis")
                .AddCheck<CustomHealthChecks> ("Contrôles de santé personnalisés");

            services.Ajouter des contrôleurs();
            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", nouveau OpenApiInfo { Titre = "HealthCheck"[19659028], Version = "v1" });
            });

            
            services.AddHealthChecksUI(options =>
            {
                options.Définir le temps d'évaluation en secondes(5);
                options.Maximum HistoryEntriesPerEndpoint(10);
                options.AddHealthCheckEndpoint("Health Checks API", "/health"); 
            })[19659028].AddInMemoryStorage(); 
        }

Nous pouvons maintenant redémarrer l'application et nous aurons le résultat suivant dans le tableau de bord :

Conclusion

Dans cet article, nous avons vu l'importance de faire le bilan de santé dans nos API et comment l'implémenter de manière simple avec des ressources de bilan de santé. Nous avons également appris à utiliser l'interface graphique du tableau de bord et à personnaliser les résultats.

J'espère que cet article vous sera utile pour créer vos bilans de santé ! A bientôt.