Monitoramento de integridade
Dica
Esse conteúdo é um trecho do eBook da Arquitetura de Microsserviços do .NET para os Aplicativos .NET em Contêineres, disponível no .NET Docs ou como um PDF para download gratuito que pode ser lido offline.
O monitoramento de integridade pode permitir informações quase em tempo real sobre o estado de seus contêineres e microsserviços. O monitoramento de integridade é fundamental para vários aspectos da operação de microsserviços e é especialmente importante quando orquestradores executam upgrades parciais de aplicativo em fases, conforme explicado posteriormente.
Aplicativos baseados em microsserviços geralmente usam pulsações ou verificações de integridade para habilitar seus monitores de desempenho, agendadores e orquestradores a controlar a variedade de serviços. Se os serviços não puderem enviar algum tipo de sinal de "estou ativo", seja sob demanda ou em um agendamento, o aplicativo poderá enfrentar riscos ao implantar as atualizações ou poderá detectar falhas tarde demais e não conseguir interromper as falhas em cascata que poderão resultar em grandes interrupções.
No modelo comum, serviços enviam relatórios sobre o status, e essas informações são agregadas para fornecer uma exibição geral do estado de integridade do seu aplicativo. Se você estiver usando um orquestrador, poderá fornecer as informações de integridade ao cluster do orquestrador para que o cluster possa agir adequadamente. Se você investir em relatórios de integridade de alta qualidade personalizados para seu aplicativo, poderá detectar e corrigir problemas do aplicativo em execução com muito mais facilidade.
Implementar verificações de integridade nos serviços do ASP.NET Core
Ao desenvolver um microsserviço ASP.NET Core ou aplicativo Web, você poderá usar o recurso de verificações de integridade interno lançado no ASP .NET Core 2.2 (Microsoft.Extensions.Diagnostics.HealthChecks). Assim como muitas funcionalidades do ASP.NET Core, as verificações de integridade são fornecidas com um conjunto de serviços e um middleware.
O middleware e os serviços de verificação de integridade são fáceis de usar e fornecem funcionalidades que permitem validar se algum recurso externo necessário para seu aplicativo (como um banco de dados do SQL Server ou uma API remota) está funcionando corretamente. Quando você usa essa funcionalidade, também pode decidir o que significa se o recurso está íntegro, como explicaremos mais adiante.
Para usar essa funcionalidade com eficiência, você precisará primeiro configurar serviços em seus microsserviços. Em segundo lugar, é necessário um aplicativo de front-end que consulte os relatórios de integridade. O aplicativo de front-end pode ser um aplicativo de relatório personalizado ou um orquestrador em si que pode reagir de acordo com os estados de integridade.
Usar a funcionalidade HealthChecks nos microsserviços de back-end do ASP.NET
Nesta seção, você aprenderá como implementar o recurso HealthChecks em uma amostra de aplicativo Web API do ASP.NET Core 8.0 quando estiver usando o pacote Microsoft.Extensions.Diagnostics.HealthChecks. A implementação desse recurso em microsserviços de grande escala como o eShopOnContainers será explicada na próxima seção.
Para começar, você precisa definir o que constitui o status íntegro para cada microsserviço. No aplicativo de exemplo, definimos que o microsserviço está íntegro se a API estiver acessível via HTTP e o banco de dados SQL Server relacionado também estiver disponível.
No .NET 8, com as APIs integradas, você pode configurar os serviços, adicionar uma Verificação de Integridade para o microsserviço e o respectivo banco de dados SQL Server dependente, como se segue:
// Program.cs from .NET 8 Web API sample
//...
// Registers required services for health checks
builder.Services.AddHealthChecks()
// Add a health check for a SQL Server database
.AddCheck(
"OrderingDB-check",
new SqlConnectionHealthCheck(builder.Configuration["ConnectionString"]),
HealthStatus.Unhealthy,
new string[] { "orderingdb" });
No código anterior, o método services.AddHealthChecks() configura uma verificação básica de HTTP que retorna um código de status 200 com "Íntegro". Além disso, o método de extensão AddCheck() configura uma SqlConnectionHealthCheck personalizada que verifica a integridade do Banco de Dados SQL relacionado.
O método AddCheck() adiciona uma nova verificação de integridade com um nome especificado e a implementação do tipo IHealthCheck. É possível adicionar várias verificações de integridade usando o método AddCheck, para que um microsserviço não forneça um status "íntegro" até que todas as verificações estejam íntegras.
SqlConnectionHealthCheck é uma classe personalizada que implementa IHealthCheck, que usa uma cadeia de conexão como um parâmetro de construtor e executa uma consulta simples para verificar se a conexão com o Banco de Dados SQL foi bem-sucedida. Ela retornara HealthCheckResult.Healthy() se a consulta for executada com êxito e um FailureStatus com a exceção real em caso de falha.
// Sample SQL Connection Health Check
public class SqlConnectionHealthCheck : IHealthCheck
{
private const string DefaultTestQuery = "Select 1";
public string ConnectionString { get; }
public string TestQuery { get; }
public SqlConnectionHealthCheck(string connectionString)
: this(connectionString, testQuery: DefaultTestQuery)
{
}
public SqlConnectionHealthCheck(string connectionString, string testQuery)
{
ConnectionString = connectionString ?? throw new ArgumentNullException(nameof(connectionString));
TestQuery = testQuery;
}
public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken cancellationToken = default(CancellationToken))
{
using (var connection = new SqlConnection(ConnectionString))
{
try
{
await connection.OpenAsync(cancellationToken);
if (TestQuery != null)
{
var command = connection.CreateCommand();
command.CommandText = TestQuery;
await command.ExecuteNonQueryAsync(cancellationToken);
}
}
catch (DbException ex)
{
return new HealthCheckResult(status: context.Registration.FailureStatus, exception: ex);
}
}
return HealthCheckResult.Healthy();
}
}
Observe que, no código anterior, Select 1 é a consulta usada para verificar a Integridade do banco de dados. Para monitorar a disponibilidade dos microsserviços, os orquestradores, como o Kubernetes, realizarão as verificações de integridade periodicamente enviando as solicitações para testar os microsserviços. É importante manter suas consultas de banco de dados eficientes para que essas operações sejam rápidas e não resultem em uma maior utilização de recursos.
Por fim, adicione um middleware que responda ao caminho da /hc:
// Program.cs from .NET 8 Web Api sample
app.MapHealthChecks("/hc");
Quando o ponto de extremidade <yourmicroservice>/hc é invocado, ele executa todas as verificações de integridade configuradas no método AddHealthChecks() na classe de Inicialização e mostra o resultado.
Implementação de HealthChecks no eShopOnContainers
Os microsserviços do eShopOnContainers dependem de vários serviços para realizar suas tarefas. Por exemplo, o microsserviço Catalog.API do eShopOnContainers depende de muitos serviços, como Armazenamento de Blobs do Azure, SQL Server e RabbitMQ. Portanto, ele tem várias verificações de integridade adicionadas usando o método AddCheck(). Para cada serviço dependente, uma implementação de IHealthCheck personalizada que define o respectivo status de integridade deveria ser adicionada.
O projeto de código aberto AspNetCore.Diagnostics.HealthChecks resolve esse problema fornecendo implementações de verificação de integridade personalizadas a cada um desses serviços corporativos, que são criados com base no .NET 8. Cada verificação de integridade está disponível como um pacote NuGet individual que pode ser adicionado ao projeto com facilidade. O eShopOnContainers usa extensivamente em todos os microsserviços.
Por exemplo, no microsserviço Catalog.API, os seguintes pacotes NuGet foram adicionados:
Figura 8-7. Verificações de Integridade personalizadas implementadas em Catalog.API usando AspNetCore.Diagnostics.HealthChecks
No seguinte código, as implementações de verificação de integridade são adicionadas a cada serviço dependente e, em seguida, o middleware é configurado:
// Extension method from Catalog.api microservice
//
public static IServiceCollection AddCustomHealthCheck(this IServiceCollection services, IConfiguration configuration)
{
var accountName = configuration.GetValue<string>("AzureStorageAccountName");
var accountKey = configuration.GetValue<string>("AzureStorageAccountKey");
var hcBuilder = services.AddHealthChecks();
hcBuilder
.AddSqlServer(
configuration["ConnectionString"],
name: "CatalogDB-check",
tags: new string[] { "catalogdb" });
if (!string.IsNullOrEmpty(accountName) && !string.IsNullOrEmpty(accountKey))
{
hcBuilder
.AddAzureBlobStorage(
$"DefaultEndpointsProtocol=https;AccountName={accountName};AccountKey={accountKey};EndpointSuffix=core.windows.net",
name: "catalog-storage-check",
tags: new string[] { "catalogstorage" });
}
if (configuration.GetValue<bool>("AzureServiceBusEnabled"))
{
hcBuilder
.AddAzureServiceBusTopic(
configuration["EventBusConnection"],
topicName: "eshop_event_bus",
name: "catalog-servicebus-check",
tags: new string[] { "servicebus" });
}
else
{
hcBuilder
.AddRabbitMQ(
$"amqp://{configuration["EventBusConnection"]}",
name: "catalog-rabbitmqbus-check",
tags: new string[] { "rabbitmqbus" });
}
return services;
}
Por fim, adicione o middleware HealthCheck para ouvir o ponto de extremidade "/hc":
// HealthCheck middleware
app.UseHealthChecks("/hc", new HealthCheckOptions()
{
Predicate = _ => true,
ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse
});
Consultar os microsserviços para relatar o status de integridade
Depois de configurar as verificações de integridade, como descrito neste artigo e colocar o microsserviço em execução no Docker, você poderá verificar diretamente se ele está íntegro usando um navegador. É necessário publicar a porta do contêiner no host do Docker, para que você possa acessar o contêiner por meio do IP externo do host do Docker ou por meio de host.docker.internal, como mostra a Figura 8-8.
Figura 8-8. Verificando o status da integridade de um único serviço em um navegador
Nesse teste, você pode ver que o microsserviço Catalog.API (em execução na porta 5101) está íntegro, retornando o status HTTP 200 e informações de status em JSON. O serviço também verificou a integridade de sua dependência do banco de dados do SQL Server e do RabbitMQ e, portanto, a verificação de integridade relatou a si própria como íntegra.
Usar watchdogs
Um watchdog é um serviço separado que pode inspecionar a integridade e a carga entre serviços e relatar a integridade dos microsserviços consultando a biblioteca HealthChecks já apresentada. Isso pode ajudar a evitar erros que não seriam detectados com base no modo de exibição de um único serviço. Os watchdogs também são um bom local para hospedar os códigos que podem realizar ações de correção para condições conhecidas sem qualquer interação com o usuário.
O exemplo de eShopOnContainers contém uma página da Web que exibe os relatórios de verificação de integridade de exemplo, como mostra a Figura 8-9. Este é o watchdog mais simples que você pode ter, pois ele mostra simplesmente o estado dos aplicativos Web e dos microsserviços no eShopOnContainers. Geralmente, um watchdog também executa ações quando detecta estados não íntegro.
Uma boa notícia é que AspNetCore.Diagnostics.HealthChecks também fornece o pacote NuGet AspNetCore.HealthChecks.UI, que pode ser usado para exibir os resultados da verificação de integridade dos URIs configurados.
Figura 8-9. Relatório de verificação de integridade de exemplo em eShopOnContainers
Em resumo, esse serviço de watchdog consulta o ponto de extremidade "/hc" de cada microsserviço. Isso executará todas as verificações de integridade definidas dentro dele e retornará um estado de integridade geral dependendo todas essas verificações. HealthChecksUI é fácil de ser consumida com algumas entradas de configuração e duas linhas de código que precisam ser adicionadas no Startup.cs do serviço de watchdog.
Arquivo de configuração de exemplo para interface do usuário da verificação de integridade:
// Configuration
{
"HealthChecksUI": {
"HealthChecks": [
{
"Name": "Ordering HTTP Check",
"Uri": "http://host.docker.internal:5102/hc"
},
{
"Name": "Ordering HTTP Background Check",
"Uri": "http://host.docker.internal:5111/hc"
},
//...
]}
}
Arquivo Program.cs que adiciona HealthChecksUI:
// Program.cs from WebStatus(Watch Dog) service
//
// Registers required services for health checks
builder.Services.AddHealthChecksUI();
// build the app, register other middleware
app.UseHealthChecksUI(config => config.UIPath = "/hc-ui");
Verificações de integridade ao usar orquestradores
Para monitorar a disponibilidade de seus microsserviços, orquestradores como Kubernetes e Service Fabric realizam verificações de integridade periodicamente enviando solicitações para testar os microsserviços. Quando um orquestrador determina que um serviço/contêiner não está íntegro, ele para de rotear solicitações para aquela instância. Ele também geralmente cria uma nova instância do contêiner.
Por exemplo, a maioria dos orquestradores pode usar verificações de integridade para gerenciar implantações de tempo de inatividade zero. Somente quando o status de um serviço/contêiner é alterado para íntegro o orquestrador começa a rotear o tráfego para instâncias de serviço/contêiner.
O monitoramento de integridade é especialmente importante quando um orquestrador executa uma atualização do aplicativo. Alguns orquestradores (como o Azure Service Fabric) atualizam os serviços em fases, por exemplo, podem atualizar um quinto da superfície de cluster para cada upgrade de aplicativo. O conjunto de nós que é atualizado ao mesmo tempo é mencionado como um domínio de atualização. Depois de cada domínio de atualização ter sido atualizado e estar disponível para os usuários, esse domínio de atualização deverá passar por verificações de integridade antes que a implantação passe para o próximo domínio de atualização.
Outro aspecto da integridade do serviço são os relatórios de métrica do serviço. Este é uma funcionalidade avançada do modelo de integridade de alguns orquestradores, como o Service Fabric. As métricas são importantes ao usar um orquestrador, pois elas são usadas para equilibrar o uso de recursos. As métricas também podem ser um indicador de integridade do sistema. Por exemplo, você pode ter um aplicativo com muitos microsserviços, e cada instância relata uma métrica de RPS (solicitações por segundo). Se um serviço estiver usando mais recursos (memória, processador etc.) que outro, o orquestrador poderá mover instâncias de serviço do cluster para tentar manter até mesmo a utilização de recursos.
Observe que o Azure Service Fabric fornece seu próprio modelo de monitoramento de integridade, que é mais avançado do que as verificações de integridade simples.
Monitoramento avançado: visualização, análise e alertas
A parte final do monitoramento é visualizar o fluxo de eventos, informar sobre o desempenho do serviço e alertar ao detectar um problema. Você pode usar diferentes soluções para esse aspecto do monitoramento.
Você pode usar aplicativos personalizados simples que mostram o estado dos serviços, como a página personalizada mostrada na explicação do AspNetCore.Diagnostics.HealthChecks. Ou você pode usar ferramentas mais avançadas, como o Azure Monitor para gerar alertas com base em fluxo de eventos.
Por fim, se você estiver armazenando todos os fluxos de eventos, poderá usar o Microsoft Power BI ou uma solução de terceiros, como o Kibana ou o Splunk, para visualizar os dados.
Recursos adicionais
HealthChecks e interface do usuário de HealthChecks para o ASP.NET Core
https://github.com/Xabaril/AspNetCore.Diagnostics.HealthChecksIntrodução ao monitoramento de integridade do Service Fabric
https://learn.microsoft.com/azure/service-fabric/service-fabric-health-introductionAzure Monitor
https://azure.microsoft.com/services/monitor/
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de