Adicionando verificações de integridade - Criando uma API de exemplo em C# (Curso)

Introdução à API de amostra e verificações de integridade

Tim explica que uma API de exemplo é uma ferramenta poderosa para quem está aprendendo desenvolvimento web. Permite aos desenvolvedores simular chamadas de API usando os métodos GET, POST, PUT e DELETE, com dados de solicitação e códigos de status apropriados. A API que Tim desenvolve oferece suporte a:

• Dados de exemplo com um modelo de dados

• Comportamentos RESTful para solicitações de API

• Respostas em formato JSON

• Exames de saúde

• Implantação tanto em contêineres Docker quanto em aplicações web

Instalando o pacote de verificações de integridade

Tim abre o projeto no Visual Studio Code e clica com o botão direito em Dependências para gerenciar os pacotes NuGet . Ele procura e instala o pacote AspNetCore.HealthChecks.UI.Client. Isso permite que o aplicativo suporte dois tipos de verificações de saúde.

Criando aulas de verificação de saúde

Tim adiciona uma nova pasta chamada HealthChecks dentro da pasta do projeto da API. Aqui, ele cria várias classes que implementam a interface IHealthCheck, cada uma representando um estado diferente: saudável, degradado, não saudável e aleatório.

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

Registrando verificações de integridade na configuração de inicialização

Tim adiciona uma nova classe estática chamada HealthChecksConfig.cs na pasta de inicialização ou configuração. Esta classe inclui dois métodos estáticos:

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

Criação de desfechos de saúde específicos

Para testar componentes individuais, Tim mapeia cada verificação de integridade por etiqueta:

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

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

Ele repete isso para /health/degraded, /health/unhealthy e /health/random. Cada uma permite que os desenvolvedores testem comportamentos específicos e como seu frontend reage a eles.

Ao visitar /health/random, a saída alterna entre "saudável", "degradado" e "não saudável" com base no resultado aleatório.

Adicionando suporte de interface do usuário para verificações de integridade.

Tim aprimora os endpoints habilitando uma resposta da interface do usuário para cada rota de verificação de integridade. Isso gera uma saída em formato JSON:

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

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

Isso permite a inspeção de cada verificação de integridade com dados como duração, tags e status. Tim então cria versões de interface do usuário para cada ponto de extremidade de saúde:

• /healthui/saudável

• /healthui/degradado

• /healthui/não saudável

• /healthui/aleatório

Cada uma responde com um formato JSON detalhado, ideal para APIs RESTful e testes em dispositivos móveis ou páginas da web.

Finalizando o projeto da API

Tim destaca que, mesmo com esses recursos, o arquivo Program.cs ainda possui apenas 21 linhas. Ele atribui isso a:

• Boa estrutura de pastas de projeto

• Manter os modelos na pasta Modelos

• Colocar endpoints e controladores em pastas separadas

• Utilizando métodos Task assíncronos para cada classe de verificação de integridade

Ele também enfatiza a utilidade dessa API de exemplo em ambientes de produção para simular latência ou falhas antes da implantação.

"Podemos realizar muito mais testes com essa API além de simplesmente fazer chamadas GET", conclui Tim.

O que vem a seguir

Tim apresenta uma prévia da próxima lição, onde adicionará lentidão simulada (por exemplo, atrasos de 5 segundos) e erros como return NotFound() ou return BadRequest() para testar ainda mais o comportamento da API.

Conclusão

Neste tutorial em vídeo , Tim Corey demonstra metodicamente a criação de uma API minimalista com verificações de integridade integradas usando o ASP.NET Core. Os principais componentes incluem:

• Classes de verificação de saúde (Saudável, Degradado, Não Saudável, Aleatório)

• Injeção de dependência via AddHealthChecks()

• Mapeamento de endpoints usando MapHealthChecks()

• Suporte a respostas JSON estruturadas

Essa abordagem facilita a validação de APIs REST, a simulação de falhas e o fortalecimento de aplicações web tanto em ambientes de desenvolvimento quanto de produção.