How to Achieve 99.99% Availability in Spring Boot Microservices: 7 Essential Steps

Principle 1: Design for Failure

Assume the system will fail. Common faults include network jitter, service‑dependency timeouts, exhausted DB connection pools, JVM Full GC, Kubernetes node failures, and third‑party API outages. The architecture must provide automatic degradation, recovery, and isolation.

Circuit Breaker

Use a circuit breaker to pause requests when the error rate exceeds a threshold, preventing cascading failures.

Library : Resilience4j

<dependency>
    <groupId>io.github.resilience4j</groupId>
    <artifactId>resilience4j-spring-boot3</artifactId>
</dependency>

resilience4j:
  circuitbreaker:
    instances:
      userService:
        slidingWindowSize: 10
        failureRateThreshold: 50
        waitDurationInOpenState: 10s

package com.icoderoad.service;

import io.github.resilience4j.circuitbreaker.annotation.CircuitBreaker;
import org.springframework.stereotype.Service;

@Service
public class UserServiceClient {
    @CircuitBreaker(name = "userService", fallbackMethod = "fallback")
    public String getUserInfo() {
        throw new RuntimeException("user service unavailable");
    }

    public String fallback(Throwable t) {
        return "default user";
    }
}

Timeout Control

Set explicit call timeouts to avoid thread‑pool exhaustion.

feign:
  client:
    config:
      default:
        connectTimeout: 2000
        readTimeout: 3000

Typical timeout values:

Internal service: 2 s

Database: 1 s

Third‑party API: 3–5 s

Service Isolation (Bulkhead)

Limit concurrent calls per service.

resilience4j:
  bulkhead:
    instances:
      paymentService:
        maxConcurrentCalls: 20

package com.icoderoad.service;

import io.github.resilience4j.bulkhead.annotation.Bulkhead;
import org.springframework.stereotype.Service;

@Service
public class PaymentServiceClient {
    @Bulkhead(name = "paymentService")
    public String pay() {
        return "payment success";
    }
}

Automatic Retry

Configure retries for transient failures.

resilience4j:
  retry:
    instances:
      orderService:
        maxAttempts: 3
        waitDuration: 500ms

package com.icoderoad.service;

import io.github.resilience4j.retry.annotation.Retry;
import org.springframework.stereotype.Service;

@Service
public class OrderService {
    @Retry(name = "orderService")
    public String createOrder() {
        return "order created";
    }
}

Multi‑Instance Deployment

Deploy at least three replicas to achieve high availability.

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
spec:
  replicas: 3

Monitoring System

Combine Spring Boot Actuator, Prometheus, Grafana, and AlertManager.

Spring Boot Actuator – application metrics

Prometheus – metrics collection

Grafana – visualization

AlertManager – automatic alerts

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>

management:
  endpoints:
    web:
      exposure:
        include: "*"

Metrics are exposed at http://localhost:8080/actuator/metrics, covering JVM memory, HTTP request count, response time, error rate, and thread‑pool usage.

Availability Target

Four Nines (99.99 %) availability permits a maximum of 52.56 minutes of downtime per year.