Zero-Downtime Rolling Updates with Readiness Probes

In this lesson, you will learn how to orchestrate seamless .NET service deployments using Kubernetes readiness probes to ensure your application remains reachable throughout a rolling update.

The Rolling Update Orchestration

A "Rolling Update" is the process of incrementally replacing old pods with new ones. To achieve zero downtime, the orchestration layer (like Kubernetes) must not route traffic to a new instance until it is truly ready to handle requests. This is where Readiness Probes become critical.

Without these probes, the load balancer might route traffic to a container the moment its process starts. If your .NET application requires a warm-up—such as establishing database connections, warming up the JIT compiler, or populating internal caches—the initial requests will fail or time out.

Implementing the Readiness Endpoint

In ASP.NET Core, you expose this capability via the Microsoft.Extensions.Diagnostics.HealthChecks library. You define a custom check that verifies your dependencies are actually initialized:

public class StartupHealthCheck : IHealthCheck
{
    public Task<HealthCheckResult> CheckHealthAsync(HealthCheckContext context, CancellationToken ct)
    {
        // Only return 'Healthy' once the DB connection is verified
        return _db.CanConnectAsync() 
            ? Task.FromResult(HealthCheckResult.Healthy())
            : Task.FromResult(HealthCheckResult.Unhealthy("Database unavailable"));
    }
}

In your Program.cs, you map this to an endpoint:

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

The Kubernetes Handshake

When you define your deployment manifest, you instruct the orchestrator to poll this /health/ready endpoint. Kubernetes will:

1. Start the new pod.
2. Wait for the readiness probe to return 200 OK.
3. Add the pod to the load balancer rotation only after success.
4. Terminate an old pod only after the new one is receiving traffic.

This handshake ensures that your .NET runtime is fully "warmed up" and ready to process traffic before it is exposed to the outside world, effectively eliminating the "cold start" request failures common in large-scale microservices.

Key Takeaway: Zero-downtime is achieved by coupling graceful startup logic with readiness probes that signal the orchestrator to delay traffic routing until the .NET runtime is fully initialized.