Zero Downtime Deployment of Microservices in Kubernetes with Spring Boot

Delivering reliable and seamless updates to microservices is a crucial challenge for modern software teams. Downtime during deployments can disrupt users and damage trust. Fortunately, Kubernetes provides a robust set of tools to ensure zero downtime deployment, and combining them with Spring Boot enhances your ability to maintain resilient, always-available microservices.

This post explores how to achieve zero downtime deployments by leveraging Kubernetes features like readiness and liveness probes, rolling updates, graceful shutdown, and advanced deployment strategies like Blue-Green and Canary deployments.

Table of Contents

1. What is Zero Downtime Deployment?
2. Readiness and Liveness Probes
3. Rolling Updates and Health Checks
4. Graceful Shutdown in Spring Boot
5. Blue-Green and Canary Deployment Strategies
6. Summary

What is Zero Downtime Deployment?

Zero downtime deployment ensures that a microservice remains fully operational while its software is updated or replaced. Instead of interrupting user requests during updates, Kubernetes allows you to phase in changes gradually, rerouting traffic seamlessly without disruptions.

Microservices architectures exacerbate deployment challenges:

• Each service evolves independently, often with multiple deploys per day.
• Dependencies between services increase the risk of cascading failures during updates.

Planning for zero downtime involves:

• Minimizing impact during updates by leveraging Kubernetes primitives.
• Safeguarding service health through probes and checks.
• Deploying strategically to ensure changes don’t impact all users at once.

Readiness and Liveness Probes

Kubernetes provides readiness and liveness probes to monitor and manage microservices during their lifecycle.

What Are Probes?

1. Readiness Probe
   Determines if your application is ready to serve traffic. Kubernetes only sends requests to ready pods.
2. Liveness Probe
   Monitors application health during operation. If a pod becomes unhealthy, Kubernetes restarts it automatically.

Configuring Probes in Spring Boot

Spring Boot offers Actuator endpoints that integrate seamlessly with Kubernetes probes. Use the /actuator/health endpoint for liveness and readiness probing.

Example Probe Configuration:

Update the deployment.yaml for your service:

livenessProbe:
  httpGet:
    path: /actuator/health/liveness
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 10

readinessProbe:
  httpGet:
    path: /actuator/health/readiness
    port: 8080
  initialDelaySeconds: 5
  periodSeconds: 5

Customizing Health Endpoints:

Add the following lines to application.yml to define detailed liveness and readiness checks:

management.endpoints.web.exposure.include=health
management.endpoint.health.group.liveness.include=liveness
management.endpoint.health.group.readiness.include=readiness

Key Benefits:

• Probes prevent error-prone pods from accepting traffic too early.
• Kubernetes takes care of restarting unhealthy pods.

Rolling Updates and Health Checks

Kubernetes rolling updates replace old versions of your application with new ones incrementally. This approach ensures that your microservices stay online while transitioning to the updated version.

How Rolling Updates Work

• Step 1: Kubernetes spawns instances of the new pods, gradually increasing the count.
• Step 2: Simultaneously, it terminates old pods, reducing their count.
• Step 3: Traffic is seamlessly routed to the new pods only if they pass readiness checks.

Configuring Rolling Updates

Define rolling update properties in your Deployment manifest:

strategy:
  type: RollingUpdate
  rollingUpdate:
    maxSurge: 1  # Number of additional pods to add at a time
    maxUnavailable: 0  # Number of pods that can go down during updates

Validating Updates:

Prioritize validating your updates before releasing them cluster-wide:

1. Use readiness probes to hold back faulty pods from receiving traffic.
2. Deploy updates in small increments by adjusting replicas in your deployment.

Monitoring:

Monitor deployments with:

kubectl rollout status deployment <deployment-name>

Rolling updates combined with health probes drastically reduce the risk of failed deployments.

Graceful Shutdown in Spring Boot

When updating services or shutting down pods, requests in progress may fail unless handled gracefully. Spring Boot provides graceful shutdown mechanisms to ensure that open requests are completed before the pod terminates.

Why Is Graceful Shutdown Important?

During deployment or scaling, Kubernetes may terminate service pods. Without proper handling:

1. Requests Fail: Abrupt termination cuts off active requests.
2. State Corruption: Transactions or database connections may remain incomplete.

Enabling Graceful Shutdown in Spring Boot

Add a preStop hook to Kubernetes deployments to delay pod termination:

lifecycle:
  preStop:
    exec:
      command:
      - sleep
      - "15"  # Wait 15 seconds before termination

Additionally, ensure Spring Boot waits to complete any active tasks:

Configure the Shutdown Hook:

server:
  shutdown: graceful

Handle Shutdown Notifications:

Implement a custom shutdown handler:

@Component
public class GracefulShutdown implements DisposableBean {

    @Override
    public void destroy() throws Exception {
        // Complete ongoing tasks or clean up resources
    }
}

This combination ensures your microservices don’t leave requests half-processed during shutdown.

Blue-Green and Canary Deployment Strategies

Beyond rolling updates, advanced deployment strategies like Blue-Green and Canary deployments allow for controlled testing and rollback capabilities, ensuring safe and zero-downtime releases.

Blue-Green Deployment

What It Does:

• Deploy the new version (Green) alongside the existing version (Blue).
• Route traffic gradually to the new version once validated.

Configuration:

1. Deploy the two environments as separate services.
2. Use a Kubernetes ingress controller or traffic router to swap environments.

kubectl apply -f blue-service.yaml
kubectl apply -f green-service.yaml

Switch routing:

kubectl patch service my-service -p '{"spec":{"selector":{"version":"green"}}}'

Pros:

• Simple rollback by switching traffic back to the Blue environment.
• No downtime as new and old versions are live simultaneously.

Canary Deployment

What It Does:

• Gradually release the new version to a subset of users while monitoring performance.
• Scale up the new version incrementally before full rollout.

Implementation with Kubernetes:

Use multiple replicas for your service and split traffic using Istio or a similar service mesh.

Istio Example:

apiVersion: networking.istio.io/v1alpha3
kind: VirtualService
spec:
  hosts:
  - my-service
  http:
  - route:
    - destination:
        host: my-service
        subset: v1
      weight: 80
    - destination:
        host: my-service
        subset: v2
      weight: 20

Monitor performance before increasing the v2 weight.

Pros:

• Early detection of issues with minimal user impact.
• High confidence in deployment stability.

Summary

Zero downtime deployments are vital for ensuring a seamless user experience in today’s 24/7 world. By leveraging Kubernetes alongside Spring Boot, you can build resilient systems that thrive under dynamic conditions. Here’s what we covered:

1. Probes: Readiness and liveness probes help keep unhealthy pods offline.
2. Rolling Updates: Ensure seamless transitions without any downtime.
3. Graceful Shutdown: Prevent request failures during pod termination.
4. Deployment Strategies: Use Blue-Green and Canary deployments for controlled rollouts and easy rollbacks.

Adopting these practices will transform how you update microservices, enabling you to deliver new features and solutions confidently. Take the first step today toward achieving zero downtime!