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

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.

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.Degraded("This is a test degraded service."));

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

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

return Task.FromResult(HealthCheckResult.Unhealthy("This is a test unhealthy 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."))
};

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."))
};

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 :

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" });

app.MapHealthChecks("/health");

app.MapHealthChecks("/health");

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")
});

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
});

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.