Building Resilient Microservices with Java, Spring Boot 3, Kafka, and Kubernetes

Introduction

Modern enterprise microservices must withstand unpredictable traffic spikes, network partitions, and hardware failures while maintaining strict 99.9% availability SLAs. In this deep dive, we explore architectural patterns for high-throughput, cloud-native services utilizing Java 21, Spring Boot 3, Apache Kafka, and Kubernetes.

1. Event-Driven Architecture with Kafka & Spring Boot

Decoupled event messaging prevents cascading failures across microservices. Using @KafkaListener with idempotent consumers and dead-letter queues (DLQ) ensures at-least-once processing without message loss:

OrderEventConsumer.java

@Component
@Slf4j
public class OrderEventConsumer {
 
    private final OrderProcessingService orderProcessingService;
 
    public OrderEventConsumer(OrderProcessingService orderProcessingService) {
        this.orderProcessingService = orderProcessingService;
    }
 
    @RetryableTopic(
        attempts = "4",
        backoff = @Backoff(delay = 1000, multiplier = 2.0),
        dltStrategy = DltStrategy.FAIL_ON_ERROR
    )
    @KafkaListener(topics = "orders.placed", groupId = "order-fulfillment-group")
    public void handleOrderPlaced(@Payload OrderEvent event, Acknowledgment ack) {
        log.info("Processing order event for ID: {}", event.getOrderId());
        orderProcessingService.processOrder(event);
        ack.acknowledge();
    }
}

2. Distributed Caching & Sub-Millisecond Reads

To sustain 500K+ daily transactions without overwhelming primary transactional databases (PostgreSQL/MySQL), implement a cache-aside pattern with Redis:

ProductCatalogService.java

@Service
public class ProductCatalogService {
 
    @Cacheable(value = "products", key = "#sku", unless = "#result == null")
    public ProductDto getProductBySku(String sku) {
        return productRepository.findBySku(sku)
            .map(this::mapToDto)
            .orElseThrow(() -> new ResourceNotFoundException("Product not found: " + sku));
    }
}

3. Kubernetes Multi-Node Cluster Orchestration

Containerize Spring Boot applications using multi-stage Docker builds and deploy with automated health probes and horizontal pod autoscaling (HPA):

k8s-deployment.yaml

apiVersion: apps/v1
kind: Deployment
metadata:
  name: order-service
  labels:
    app: order-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: order-service
  template:
    metadata:
      labels:
        app: order-service
    spec:
      containers:
        - name: order-service
          image: manojsuthar/order-service:1.2.0
          ports:
            - containerPort: 8080
          livenessProbe:
            httpGet:
              path: /actuator/health/liveness
              port: 8080
            initialDelaySeconds: 20
            periodSeconds: 10
          readinessProbe:
            httpGet:
              path: /actuator/health/readiness
              port: 8080
            initialDelaySeconds: 15
            periodSeconds: 5

4. Observability with Prometheus & Grafana

Instrument your microservices using Spring Boot Actuator and Micrometer to export metrics for Prometheus scraping:

Summary

Combining Java, Spring Boot 3, Apache Kafka, and Kubernetes provides a battle-tested foundation for mission-critical, enterprise-scale platforms.