Spring Microservices in Action, Second Edition

Service Granularitydesign lever

The degree to which application functionality is decomposed into independently deployable units with narrowly scoped, well-defined business responsibilities and minimal data ownership overlap, ranging from coarse-grained (few, larger services) to fine-grained (many, smaller services).

Externalized Configurationdesign lever

The practice of completely separating all environment-specific configuration data (database URLs, credentials, feature flags) from the deployable service artifact and serving it from a centralized, versioned repository (filesystem, Git, or Vault) at service bootstrap time.

Service Discoverydesign lever

The architectural mechanism by which service instances dynamically register their physical location with a discovery registry (Netflix Eureka) and clients resolve service endpoints by logical name rather than hardcoded IP/port, enabling transparent addition and removal of instances.

Client-Side Load Balancingdesign lever

The pattern in which the service consumer maintains a local cache of available service instance locations (obtained from Eureka) and distributes outbound calls across healthy instances using a round-robin or zone-aware algorithm, eliminating reliance on a centralized load balancer.

Circuit Breaker Implementationdesign lever

The application of Resilience4j @CircuitBreaker annotations to remote resource calls, configuring ring buffer sizes, failure-rate thresholds, and wait durations so that sustained call failures cause the circuit to open and subsequent calls to fail fast rather than exhaust thread pools.

Fallback Strategydesign lever

The definition of alternative code paths invoked by Resilience4j when a circuit breaker opens or a call otherwise fails, enabling the service to return degraded but useful data rather than propagating an exception to the caller.

Bulkhead Implementationdesign lever

The use of Resilience4j @Bulkhead to compartmentalize concurrent calls to remote resources into isolated thread pools or semaphore limits, preventing a single slow downstream service from exhausting all container threads and collapsing the entire application.

Retry and Rate Limiter Patternsdesign lever

The application of Resilience4j @Retry to re-attempt transient failures up to a configured maximum with configurable wait durations, and @RateLimiter to cap the total number of calls per time period, preventing both retry storms and service overload.

API Gateway Routingdesign lever

The use of Spring Cloud Gateway as a single entry point that proxies all inbound service calls, applies predicate-based routing rules to map URL paths to downstream Eureka-registered service IDs, and enforces cross-cutting policies uniformly before forwarding requests.

Gateway Filter Engineeringdesign lever

The implementation of custom Spring Cloud Gateway pre-filters and post-filters to inject correlation IDs, validate authentication tokens, collect metrics, and augment HTTP response headers, enforcing consistent cross-cutting behavior across all services without modifying individual service code.

OAuth2 and Keycloak Securitydesign lever

The implementation of token-based authentication and role-based authorization using Keycloak as the identity provider, Spring Security and KeycloakWebSecurityConfigurerAdapter in each service, and JWT Bearer tokens propagated through the full service call chain via KeycloakRestTemplate.

Event-Driven Messagingdesign lever

The architectural choice to communicate state changes between services asynchronously via a Kafka topic using Spring Cloud Stream Source and Sink abstractions, decoupling producers from consumers and enabling durable, scalable, and replay-capable event propagation.

Distributed Cachingdesign lever

The use of Redis as a shared, externalized key-value cache layer that stores organization data retrieved by the licensing service, with cache invalidation triggered by Kafka messages emitted when organization state changes, reducing database load and improving response times.

Correlation ID Propagationdesign lever

The systematic injection and forwarding of a unique transaction-scoped identifier through HTTP headers, ThreadLocal storage, RestTemplate interceptors, and Spring Cloud Sleuth trace IDs, enabling end-to-end linking of log entries across all services involved in a single user transaction.

Distributed Tracingdesign lever

The instrumentation of services with Spring Cloud Sleuth to automatically generate and propagate trace and span IDs, integrated with Zipkin for visual transaction flow analysis and the ELK Stack for queryable, aggregated log storage, enabling performance profiling and failure diagnosis across service boundaries.

Immutable Deployment Pipelinedesign lever

The practice of building, testing, and packaging microservices as immutable Docker container images through a Jenkins-based CI/CD pipeline that deploys to Kubernetes on Amazon EKS, ensuring that every environment receives an identical, versioned artifact and that configuration drift is eliminated.

Service Coupling Degreepsychological state

The extent to which individual microservices have direct runtime dependencies on the physical location, internal data model, or synchronous availability of other services, ranging from tightly coupled (direct HTTP calls with shared data models) to loosely coupled (event-driven with independent data stores).

Configuration Drift Riskpsychological state

The probability that service instances running in production have diverged from their intended configuration state due to ad hoc manual changes, inconsistent environment promotion, or embedded properties in deployed artifacts, leading to unpredictable runtime behavior.

Resiliency Posturepsychological state

The overall capability of the microservices ecosystem to absorb partial failures—slow services, unreachable dependencies, thread exhaustion—without cascading those failures to consumers, maintaining partial availability and graceful degradation rather than total system collapse.

Security Posturepsychological state

The aggregate strength of authentication, authorization, token propagation, network zoning, and transport encryption controls protecting the microservices ecosystem from unauthorized access, credential exposure, and privilege escalation attacks.

System Observabilitypsychological state

The degree to which the internal state and transaction flow of the microservices ecosystem can be understood from its external outputs—structured logs with correlation IDs, distributed traces in Zipkin, and metrics dashboards in Grafana/Prometheus—enabling rapid diagnosis of production issues.

System Availabilityoutcome metric

The measured uptime and request success rate of the overall microservices application as experienced by end users, reflecting the cumulative effect of resiliency patterns, fault isolation, health monitoring, and rapid instance recovery mechanisms.

Delivery Velocityoutcome metric

The rate at which new features, bug fixes, and configuration changes can be safely built, tested, and deployed to production, enabled by independent service deployability, immutable container images, and automated CI/CD pipelines.

Operational Maintainabilityoutcome metric

The ease with which operators and developers can understand, diagnose, reconfigure, scale, and recover the running microservices ecosystem, determined by the quality of observability tooling, configuration management automation, and deployment pipeline repeatability.

Developer Productivityoutcome metric

The efficiency and confidence with which individual developers can build, test, and evolve their microservice in isolation, supported by Spring Boot's auto-configuration and embedded server model, Spring Cloud's annotation-driven infrastructure abstractions, and reproducible Docker Compose environments.