Health Checks

// Program.cs
builder.Services.AddHealthChecks();

var app = builder.Build();
app.MapHealthChecks("/health");

// A simple GET /health request returns "Healthy" with 200 OK if no checks fail

Common follow-ups: What's the difference between liveness and readiness health checks?;How do you add a custom check for a specific dependency like a database?

public class DatabaseHealthCheck(AppDbContext db) : IHealthCheck {
    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken ct = default) {
        try {
            await db.Database.CanConnectAsync(ct);
            return HealthCheckResult.Healthy("Database connection OK");
        } catch (Exception ex) {
            return HealthCheckResult.Unhealthy("Database connection failed", ex);
        }
    }
}

builder.Services.AddHealthChecks()
    .AddCheck<DatabaseHealthCheck>("database");

Common follow-ups: What's the difference between Degraded and Unhealthy, and how should consumers of the health endpoint react differently to each?;How do you set a timeout for an individual health check so a hanging dependency doesn't block the whole endpoint?

builder.Services.AddHealthChecks()
    .AddCheck<DatabaseHealthCheck>("database", tags: new[] { "ready" })
    .AddCheck("self", () => HealthCheckResult.Healthy(), tags: new[] { "live" });

app.MapHealthChecks("/health/live", new HealthCheckOptions { Predicate = c => c.Tags.Contains("live") });
app.MapHealthChecks("/health/ready", new HealthCheckOptions { Predicate = c => c.Tags.Contains("ready") });

Common follow-ups: What happens if you incorrectly use the same check for both liveness and readiness?;How would a slow-starting dependency (like a cache warming up) be handled differently between the two probe types?

app.MapHealthChecks("/health", new HealthCheckOptions {
    ResponseWriter = async (context, report) => {
        context.Response.ContentType = "application/json";
        var result = JsonSerializer.Serialize(new {
            status = report.Status.ToString(),
            checks = report.Entries.Select(e => new { name = e.Key, status = e.Value.Status.ToString(), duration = e.Value.Duration.TotalMilliseconds })
        });
        await context.Response.WriteAsync(result);
    }
});

Common follow-ups: How would you use the AspNetCore.HealthChecks.UI package instead of writing a custom formatter from scratch?;Should the detailed health check response be exposed publicly, or restricted to internal monitoring systems only?

public class DatabaseLatencyHealthCheck(AppDbContext db) : IHealthCheck {
    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken ct = default) {
        var sw = Stopwatch.StartNew();
        await db.Database.ExecuteSqlRawAsync("SELECT 1", ct);
        sw.Stop();

        return sw.ElapsedMilliseconds switch {
            < 100 => HealthCheckResult.Healthy($"{sw.ElapsedMilliseconds}ms"),
            < 1000 => HealthCheckResult.Degraded($"Slow: {sw.ElapsedMilliseconds}ms"),
            _ => HealthCheckResult.Unhealthy($"Very slow: {sw.ElapsedMilliseconds}ms")
        };
    }
}

Common follow-ups: How should a load balancer or Kubernetes readiness probe treat a Degraded status differently from Unhealthy?;How do you avoid the health check's own overhead (running test queries) contributing meaningfully to database load?

// After: dotnet add package AspNetCore.HealthChecks.SqlServer
//        dotnet add package AspNetCore.HealthChecks.Redis
builder.Services.AddHealthChecks()
    .AddSqlServer(builder.Configuration.GetConnectionString("Default"), name: "sql-server")
    .AddRedis(builder.Configuration.GetConnectionString("Redis"), name: "redis")
    .AddUrlGroup(new Uri("https://api.partner.com/health"), name: "partner-api");

Common follow-ups: How do you evaluate whether a community health check package is trustworthy and well-maintained before depending on it in production?;How would you write a custom check for a dependency type not covered by any existing community package?

// Program.cs
builder.Services.AddHealthChecksUI(options => {
    options.AddHealthCheckEndpoint("API", "/health");
}).AddInMemoryStorage();

var app = builder.Build();
app.MapHealthChecks("/health", new HealthCheckOptions { Predicate = _ => true, ResponseWriter = UIResponseWriter.WriteHealthCheckUIResponse });
app.MapHealthChecksUI(options => options.UIPath = "/healthchecks-ui");

Common follow-ups: What's the trade-off of in-memory storage versus a persistent database backend for the UI's historical data?;How would you configure webhook notifications to alert a team channel when status changes?

public class OrderDbHealthCheck(OrderDbContext db) : IHealthCheck {  // scoped DbContext injected safely
    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken ct = default) {
        return await db.Database.CanConnectAsync(ct) ? HealthCheckResult.Healthy() : HealthCheckResult.Unhealthy();
    }
}

// Registration -- the health check itself is registered, DI scope handled automatically per invocation
builder.Services.AddHealthChecks().AddCheck<OrderDbHealthCheck>("orders-db");

Common follow-ups: What would go wrong if a health check were mistakenly registered as a singleton but tried to cache a scoped dependency across invocations?;How does this scoping behavior differ for a health check invoked from a background polling HostedService versus an HTTP request?

public class SlowDependencyHealthCheck : IHealthCheck {
    public async Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken ct = default) {
        using var timeoutCts = CancellationTokenSource.CreateLinkedTokenSource(ct);
        timeoutCts.CancelAfter(TimeSpan.FromSeconds(3));
        try {
            await _dependency.PingAsync(timeoutCts.Token);
            return HealthCheckResult.Healthy();
        } catch (OperationCanceledException) {
            return HealthCheckResult.Unhealthy("Dependency check timed out after 3s");
        }
    }
}

Common follow-ups: What's the difference between a per-check timeout and the overall HealthCheckOptions timeout at the endpoint level?;How should a Kubernetes probe's own timeout setting relate to the application's internal health check timeouts?

// Program.cs -- separate detailed (internal) and minimal (public) health endpoints
app.MapHealthChecks("/health/detailed", new HealthCheckOptions {
    ResponseWriter = WriteDetailedJson
}).RequireAuthorization("InternalOnly");

app.MapHealthChecks("/health", new HealthCheckOptions {
    ResponseWriter = (context, report) => context.Response.WriteAsync(report.Status.ToString())
});  // minimal, publicly safe

Common follow-ups: What network-level (versus application-level) approaches exist for restricting access to the detailed endpoint?;What specific pieces of information are most risky to leak via a health check response?