Aplicação C#

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

Tim Corey

23m 30s

Desenvolver e testar APIs RESTful em C# usando ASP.NET Core é uma habilidade prática para qualquer desenvolvedor backend moderno. Em seu vídeo tutorial sobre " Adicionando verificações de integridade - Criando uma API de exemplo em C# ", Tim Corey demonstra como criar uma API de exemplo com verificações de integridade integradas. Este artigo, baseado exclusivamente na transcrição de Tim, explica todo o processo passo a passo, abordando pontos-chave como o uso de public async Task, int id, var app e outros métodos de requisição HTTP.

Vamos analisar mais detalhadamente como Tim Corey configura verificações de integridade em um projeto de API C# usando o Visual Studio Code.

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.

HealthyHealthCheck.cs

Esta classe retorna um HealthCheckResult.Healthy usando uma Task pública assíncrona<HealthCheckResult> implementação:

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

Isso simula um estado saudável, útil para testar como seu front-end lida com um serviço estável.

DegradedHealthCheck.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."))

Esta verificação retorna uma resposta de serviço degradada. É uma maneira simples de simular falhas parciais ou problemas de desempenho.

Verificação de saúde não saudável.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."))

Isso simula uma falha de serviço, simulando casos em que você esperaria um código de status HTTP 500 ou o retorno de NotFound().

RandomHealthCheck.cs

Esta verificação de saúde usa um número inteiro aleatório para simular um dos três estados:

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 enfatiza que isso é útil para testar o comportamento sob condições variáveis.

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:

AdicionarTodosOsVerificaçõesDeSaúde()

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

Isso registra todas as verificações de integridade para injeção de dependência no contêiner de serviços do ASP.NET Core.

Mapeie todos os exames de saúde()

app.MapHealthChecks("/health");

app.MapHealthChecks("/health");

app.MapHealthChecks("/health")

app.MapHealthChecks("/health")

Isso cria um único ponto de extremidade /health que avalia todos os serviços em conjunto. Se algum deles estiver com problemas de saúde, toda a verificação retorna como insatisfatória.

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

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

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

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

app.MapHealthChecks("/healthui", New HealthCheckOptions With {
    .ResponseWriter = AddressOf 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.