在 .NET Core Worker 服务中执行健康检查

Question

如何在 .NET Core Worker 服务中实施健康检查？

服务将在 Docker 内部运行，并且需要能够检查服务的健康状况。

Answer 1

另一种方法是实现IHealthCheckPublisher。

这种方法的好处是能够重复使用现有的IHealthChecks 或与依赖IHealthCheck 接口的第三方库（如this one）集成。

尽管您仍然将 Microsoft.NET.Sdk.Web 定位为 SDK，但您不需要添加任何 asp.net 细节。

这是一个例子：

public static IHostBuilder CreateHostBuilder(string[] args)
{
  return Host
    .CreateDefaultBuilder(args)
    .ConfigureServices((hostContext, services) =>
    {
      services
        .AddHealthChecks()
        .AddCheck<RedisHealthCheck>("redis_health_check")
        .AddCheck<RfaHealthCheck>("rfa_health_check");

      services.AddSingleton<IHealthCheckPublisher, HealthCheckPublisher>();
      services.Configure<HealthCheckPublisherOptions>(options =>
      {
        options.Delay = TimeSpan.FromSeconds(5);
        options.Period = TimeSpan.FromSeconds(5);
      });
    });
}

public class HealthCheckPublisher : IHealthCheckPublisher
{
  private readonly string _fileName;
  private HealthStatus _prevStatus = HealthStatus.Unhealthy;

  public HealthCheckPublisher()
  {
    _fileName = Environment.GetEnvironmentVariable(EnvVariableNames.DOCKER_HEALTHCHECK_FILEPATH) ??
                Path.GetTempFileName();
  }

  public Task PublishAsync(HealthReport report, CancellationToken cancellationToken)
  {
    // AWS will check if the file exists inside of the container with the command
    // test -f $DOCKER_HEALTH_CHECK_FILEPATH

    var fileExists = _prevStatus == HealthStatus.Healthy;

    if (report.Status == HealthStatus.Healthy)
    {
      if (!fileExists)
      {
        using var _ = File.Create(_fileName);
      }
    }
    else if (fileExists)
    {
      File.Delete(_fileName);
    }

    _prevStatus = report.Status;

    return Task.CompletedTask;
  }
}

Answer 2

我认为将 SDK 更改为 Microsoft.NET.Sdk.Web 不值得。您是否会因为一项健康检查而包含额外的中间件？不，谢谢...

你可以做的是使用不同的协议，比如 TCP。

大体思路是：

1. 创建一个单独的后台服务来创建一个 TCP 服务器（看看TcpListener.cs）
2. 当您收到请求时，您有两个选择：如果应用程序正常，则接受 TCP 连接，否则拒绝它。
3. 如果您使用容器，您的编排器应该可以选择通过 TCP 调用它（在 k8s 中有一个属性 tcpSocket）

如果您需要更详细的信息，可以查看：Monitoring Health of ASP.NET Core Background Services With TCP Probes on Kubernetes

干杯！

Answer 3

我认为你也应该考虑保留 Microsoft.NET.Sdk.Worker。

不要仅仅因为健康检查而改变整个 sdk。

然后您可以创建一个后台服务（就像主要工作人员一样），以便更新文件以写入例如当前时间戳。后台运行状况检查工作人员的示例如下：

public class HealthCheckWorker : BackgroundService
{
    private readonly int _intervalSec;
    private readonly string _healthCheckFileName;

    public HealthCheckWorker(string healthCheckFileName, int intervalSec)
    {
        this._intervalSec = intervalSec;
        this._healthCheckFileName = healthCheckFileName;
    }

    protected override async Task ExecuteAsync(CancellationToken stoppingToken)
    {
        while (true)
        {
            File.WriteAllText(this._healthCheckFileName, DateTime.UtcNow.ToString());
            await Task.Delay(this._intervalSec * 1000, stoppingToken);
        }
    }
}

然后你可以像这样添加一个扩展方法：

public static class HealthCheckWorkerExtensions
{
    public static void AddHealthCheck(this IServiceCollection services,
        string healthCheckFileName, int intervalSec)
    {
        services.AddHostedService<HealthCheckWorker>(x => new HealthCheckWorker(healthCheckFileName, intervalSec));
    }
}

有了这个，你可以在服务中添加健康检查支持

.ConfigureServices(services =>
{
    services.AddHealthCheck("hc.txt", 5);
})

Answer 4

我所做的就是将 Microsoft.NET.Sdk.Web 添加到我的 Worker，然后配置一个 Web 主机与 Worker 一起运行：

Host.CreateDefaultBuilder(args)
    .ConfigureWebHostDefaults(builder =>
    {
        builder.UseStartup<Startup>();
    })
    .ConfigureServices((hostContext, services) =>
    {
        services.AddHostedService<Worker>();
        services.AddLogging(builder =>
            builder
                .AddDebug()
                .AddConsole()
        );
    });

完成后，剩下要做的就是map the health check endpoint，就像您通常使用 ASP.NET Core 一样。

Answer 5

添加 HTTPListener 并公开健康检查端点。

使用 HTTPListener 不需要添加 Microsoft.NET.Sdk.Web SDK。

程序.cs

    using Consumer;
    
    IHost host = Host.CreateDefaultBuilder(args)
        .ConfigureServices(services =>
        {
            services.AddHostedService<Worker>();
            services.AddHostedService<HttpHealthcheck>();
        })
        .Build();
    
    await host.RunAsync();

HttpHealthcheck.cs

    using System.Net;
    using System.Text;
    
    namespace Consumer;
    
    public class HttpHealthcheck : BackgroundService
    {
        private readonly ILogger<Worker> _logger;
        private readonly HttpListener _httpListener;
        private readonly IConfiguration _configuration;
    
    
        public HealthcheckHttpListener(ILogger<Worker> logger, IConfiguration configuration)
        {
            _logger = logger;
            _configuration = configuration;
            _httpListener = new HttpListener();
        }
    
    
        protected override async Task ExecuteAsync(CancellationToken stoppingToken)
        {
    
            _httpListener.Prefixes.Add($"http://*:5001/healthz/live/");    
            _httpListener.Prefixes.Add($"http://*:5001/healthz/ready/");
    
            _httpListener.Start();
            _logger.LogInformation($"Healthcheck listening...");
    
            while (!stoppingToken.IsCancellationRequested)
            {
                HttpListenerContext ctx = null;
                try
                {
                    ctx = await _httpListener.GetContextAsync();
                }
                catch (HttpListenerException ex)
                {
                    if (ex.ErrorCode == 995) return;
                }
    
                if (ctx == null) continue;
    
                var response = ctx.Response;
                response.ContentType = "text/plain";
                response.Headers.Add(HttpResponseHeader.CacheControl, "no-store, no-cache");
                response.StatusCode = (int)HttpStatusCode.OK;
    
                var messageBytes = Encoding.UTF8.GetBytes("Healthy");
                response.ContentLength64 = messageBytes.Length;
                await response.OutputStream.WriteAsync(messageBytes, 0, messageBytes.Length);
                response.OutputStream.Close();
                response.Close();
            }
        }
    }