Application C#

Ajouter des contrôles de santé - Construire un exemple d'API en C# Course

Tim Corey

23m 30s

Développer et tester des API RESTful en C# à l'aide d'ASP.NET Core est une compétence pratique pour tout développeur backend moderne. Dans son didacticiel vidéo intitulé "Adding Health Checks - Building a Sample API in C# Course", Tim Corey explique comment construire un exemple d'API avec des contrôles de santé intégrés. Cet article, basé uniquement sur la transcription de Tim, explique l'ensemble du processus étape par étape, en abordant des points clés tels que l'utilisation de public async Task, int id, var app, et d'autres méthodes de requête HTTP.

Voyons plus en détail comment Tim Corey met en place des contrôles de santé dans un projet d'API C# à l'aide de Visual Studio Code.

Introduction à l'API d'échantillonnage et aux bilans de santé

Tim explique qu'un exemple d'API est un outil puissant lors de l'apprentissage du développement web. Il permet aux développeurs de simuler des appels API à l'aide des méthodes GET, POST, PUT et DELETE, avec les données de requête et les codes d'état appropriés. L'API que Tim construit prend en charge :

Exemple de données avec un modèle de données
Comportements RESTful pour les demandes d'API
Réponses au format JSON
Contrôles de santé
Déploiement sous forme de conteneurs Docker et d'applications web

Installation du progiciel Health Checks

Tim ouvre le projet dans Visual Studio Code et fait un clic droit sur Dépendances pour gérer les packages NuGet. Il recherche et installe le paquet AspNetCore.HealthChecks.UI.Client. L'application peut ainsi prendre en charge deux types de bilans de santé.

Créer des classes de bilan de santé

Tim ajoute un nouveau dossier nommé HealthChecks dans le dossier du projet API. Ici, il crée plusieurs classes mettant en œuvre l'interface IHealthCheck, chacune représentant un état différent : sain, dégradé, malsain et aléatoire.

Vérification de la santé.cs

Cette classe renvoie un HealthCheckResult.Healthy à l'aide d'une implémentation asynchrone publique Task<HealthCheckResult> :

return Task.FromResult(HealthCheckResult.Healthy("This is a test healthy service."));

return Task.FromResult(HealthCheckResult.Healthy("This is a test healthy service."));

Return Task.FromResult(HealthCheckResult.Healthy("This is a test healthy service."))

Return Task.FromResult(HealthCheckResult.Healthy("This is a test healthy service."))

Ceci simule un état sain, utile pour tester la façon dont votre front-end gère un service stable.

Vérification de la santé dégradée.cs

return Task.FromResult(HealthCheckResult.Degraded("This is a test degraded service."));

return Task.FromResult(HealthCheckResult.Degraded("This is a test degraded service."));

Return Task.FromResult(HealthCheckResult.Degraded("This is a test degraded service."))

Return Task.FromResult(HealthCheckResult.Degraded("This is a test degraded service."))

Ce contrôle renvoie une réponse de service dégradé. Il s'agit d'un moyen simple de simuler une défaillance partielle ou des problèmes de performance.

Vérification de l'état de santé.cs

return Task.FromResult(HealthCheckResult.Unhealthy("This is a test unhealthy service."));

return Task.FromResult(HealthCheckResult.Unhealthy("This is a test unhealthy service."));

Return Task.FromResult(HealthCheckResult.Unhealthy("This is a test unhealthy service."))

Return Task.FromResult(HealthCheckResult.Unhealthy("This is a test unhealthy service."))

Ceci imite un service défaillant, simulant des cas où l'on s'attendrait à un code d'état HTTP 500 ou à un retour NotFound().

Vérification de santé aléatoire.cs

Ce bilan de santé utilise un nombre entier aléatoire pour simuler l'un des trois états :

int randomResult = Random.Shared.Next(1, 4);
return randomResult switch
{
    1 => Task.FromResult(HealthCheckResult.Healthy("This is a test random service.")),
    2 => Task.FromResult(HealthCheckResult.Degraded("This is a test random service.")),
    3 => Task.FromResult(HealthCheckResult.Unhealthy("This is a test random service.")),
    _ => Task.FromResult(HealthCheckResult.Healthy("This is a test random service."))
};

int randomResult = Random.Shared.Next(1, 4);
return randomResult switch
{
    1 => Task.FromResult(HealthCheckResult.Healthy("This is a test random service.")),
    2 => Task.FromResult(HealthCheckResult.Degraded("This is a test random service.")),
    3 => Task.FromResult(HealthCheckResult.Unhealthy("This is a test random service.")),
    _ => Task.FromResult(HealthCheckResult.Healthy("This is a test random service."))
};

Dim randomResult As Integer = Random.Shared.Next(1, 4)
Return randomResult Select Case
    Case 1
        Task.FromResult(HealthCheckResult.Healthy("This is a test random service."))
    Case 2
        Task.FromResult(HealthCheckResult.Degraded("This is a test random service."))
    Case 3
        Task.FromResult(HealthCheckResult.Unhealthy("This is a test random service."))
    Case Else
        Task.FromResult(HealthCheckResult.Healthy("This is a test random service."))
End Select

Dim randomResult As Integer = Random.Shared.Next(1, 4)
Return randomResult Select Case
    Case 1
        Task.FromResult(HealthCheckResult.Healthy("This is a test random service."))
    Case 2
        Task.FromResult(HealthCheckResult.Degraded("This is a test random service."))
    Case 3
        Task.FromResult(HealthCheckResult.Unhealthy("This is a test random service."))
    Case Else
        Task.FromResult(HealthCheckResult.Healthy("This is a test random service."))
End Select

Tim souligne que ces outils sont utiles pour tester le comportement dans des conditions variables.

Enregistrement des contrôles de santé dans la configuration de démarrage

Tim ajoute une nouvelle classe statique HealthChecksConfig.cs dans le dossier de démarrage ou de configuration. Cette classe comprend deux méthodes statiques :

AjouterTousLesContrôlesDeSanté()

services.AddHealthChecks()
    .AddCheck<RandomHealthCheck>("random", tags: new[] { "random" })
    .AddCheck<HealthyHealthCheck>("healthy", tags: new[] { "healthy" })
    .AddCheck<DegradedHealthCheck>("degraded", tags: new[] { "degraded" })
    .AddCheck<UnhealthyHealthCheck>("unhealthy", tags: new[] { "unhealthy" });

services.AddHealthChecks()
    .AddCheck<RandomHealthCheck>("random", tags: new[] { "random" })
    .AddCheck<HealthyHealthCheck>("healthy", tags: new[] { "healthy" })
    .AddCheck<DegradedHealthCheck>("degraded", tags: new[] { "degraded" })
    .AddCheck<UnhealthyHealthCheck>("unhealthy", tags: new[] { "unhealthy" });

services.AddHealthChecks() _
    .AddCheck(Of RandomHealthCheck)("random", tags:=New String() {"random"}) _
    .AddCheck(Of HealthyHealthCheck)("healthy", tags:=New String() {"healthy"}) _
    .AddCheck(Of DegradedHealthCheck)("degraded", tags:=New String() {"degraded"}) _
    .AddCheck(Of UnhealthyHealthCheck)("unhealthy", tags:=New String() {"unhealthy"})

services.AddHealthChecks() _
    .AddCheck(Of RandomHealthCheck)("random", tags:=New String() {"random"}) _
    .AddCheck(Of HealthyHealthCheck)("healthy", tags:=New String() {"healthy"}) _
    .AddCheck(Of DegradedHealthCheck)("degraded", tags:=New String() {"degraded"}) _
    .AddCheck(Of UnhealthyHealthCheck)("unhealthy", tags:=New String() {"unhealthy"})

Ceci enregistre tous les contrôles de santé pour l'injection de dépendances dans le conteneur de services de ASP.NET Core.

MapAllHealthChecks()

app.MapHealthChecks("/health");

app.MapHealthChecks("/health");

app.MapHealthChecks("/health")

app.MapHealthChecks("/health")

Cela permet de créer un point final unique /santé qui évalue tous les services ensemble. Si l'un d'entre eux est malsain, l'ensemble de la vérification renvoie un résultat malsain.

Création de paramètres de santé spécifiques

Pour tester les composants individuels, Tim fait correspondre chaque bilan de santé à une balise :

app.MapHealthChecks("/health/healthy", new HealthCheckOptions {
    Predicate = x => x.Tags.Contains("healthy")
});

app.MapHealthChecks("/health/healthy", new HealthCheckOptions {
    Predicate = x => x.Tags.Contains("healthy")
});

app.MapHealthChecks("/health/healthy", New HealthCheckOptions With {
    .Predicate = Function(x) x.Tags.Contains("healthy")
})

app.MapHealthChecks("/health/healthy", New HealthCheckOptions With {
    .Predicate = Function(x) x.Tags.Contains("healthy")
})

Il répète cette opération pour /health/degraded, /health/unhealthy et /health/random. Chacun d'entre eux permet aux développeurs de tester des comportements spécifiques et la façon dont leur frontend y réagit.

Lorsque l'on visite le site /health/random, le résultat change entre "healthy", "degraded" et "unhealthy" en fonction du résultat aléatoire.

Ajouter la prise en charge de l'interface utilisateur pour les contrôles de santé

Tim améliore les points d'extrémité en permettant une réponse de l'interface utilisateur pour chaque itinéraire de contrôle de santé. Cette traduction fournit une sortie JSON :

app.MapHealthChecks("/healthui", new HealthCheckOptions
{
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

app.MapHealthChecks("/healthui", new HealthCheckOptions
{
    ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});

app.MapHealthChecks("/healthui", New HealthCheckOptions With {
    .ResponseWriter = AddressOf UIResponseWriter.WriteHealthCheckUIResponse
})

app.MapHealthChecks("/healthui", New HealthCheckOptions With {
    .ResponseWriter = AddressOf UIResponseWriter.WriteHealthCheckUIResponse
})

Cela permet d'inspecter chaque bilan de santé avec des données telles que la durée, les balises et l'état. Tim crée ensuite des versions de l'interface utilisateur pour chaque point d'accès à la santé :

/healthui/healthy
/healthui/dégradé
/healthui/malsain
/healthui/aléatoire

Chaque réponse contient un format JSON détaillé, idéal pour les API RESTful et les tests à partir d'appareils mobiles ou de pages web.

Envelopper le projet API

Tim souligne que même avec ces fonctionnalités, Program.cs ne fait que 21 lignes. Il attribue cette réussite à :

Bonne structure de dossier de projet
Conserver les modèles dans le dossier Models
Placer les points d'extrémité et les contrôleurs dans leurs propres dossiers
Utilisation de méthodes de tâches asynchrones pour chaque classe de bilan de santé

Il souligne également l'utilité de cet exemple d'API dans les environnements de production pour simuler la latence ou les défauts avant le déploiement.

Nous pouvons faire beaucoup plus de tests avec cette API que de simples appels GET", conclut Tim.

Les prochaines étapes

Tim donne un aperçu de la prochaine leçon, dans laquelle il ajoutera des ralentissements simulés (par exemple, des délais de 5 secondes) et des erreurs telles que return NotFound() ou return BadRequest() pour tester encore davantage le comportement de l'API.

Conclusion

Dans ce tutoriel vidéo, Tim Corey parcourt méthodiquement la construction d'une API minimale avec des contrôles de santé intégrés à l'aide d'ASP.NET Core. Les principaux éléments sont les suivants :

Classes de bilan de santé (sain, dégradé, malsain, aléatoire)
Injection de dépendance via AddHealthChecks()
Cartographie des points d'extrémité à l'aide de MapHealthChecks()
Prise en charge des réponses JSON structurées

Cette approche facilite la validation des API REST, la simulation des défaillances et le renforcement des applications web dans les environnements de développement et de production.