Spring Cloud Overview

Spring Cloud is a family of projects that solve the recurring problems of distributed systems — configuration, discovery, routing, resilience, and tracing — as drop-in Spring Boot starters. You don’t adopt “Spring Cloud” wholesale; you pull in the specific projects you need, all kept compatible by a single versioned BOM. This page covers that versioning model and tours the core components.

The release train and the BOM

Spring Cloud ships as a release train: a curated set of mutually compatible module versions published together under a calendar-style name (e.g. 2024.0.x). Each train targets a specific Spring Boot generation. Pin the train once via the BOM and every Spring Cloud starter inherits the right version.

Spring Boot	Spring Cloud train
3.5.x	2024.0.x
3.4.x	2024.0.x
3.3.x	2023.0.x
3.2.x	2023.0.x

Warning: Mismatching the train and Boot version is the most common Spring Cloud setup error. Always check the compatibility matrix before upgrading either side.

Maven setup

Import the BOM in dependencyManagement, then add starters without versions:

<properties>
    <java.version>17</java.version>
    <spring-cloud.version>2024.0.0</spring-cloud.version>
</properties>

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-openfeign</artifactId>
    </dependency>
</dependencies>

Gradle setup

ext {
    set('springCloudVersion', '2024.0.0')
}
dependencyManagement {
    imports {
        mavenBom "org.springframework.cloud:spring-cloud-dependencies:${springCloudVersion}"
    }
}

Core projects

Spring Cloud is modular. These are the projects you’ll meet most in a Spring Boot fleet:

Project	Starter	What it does
Gateway	`spring-cloud-starter-gateway`	Reactive API gateway: routing, predicates, filters
Config	`spring-cloud-config-server` / `spring-cloud-starter-config`	Centralized, git-backed configuration
Netflix Eureka	`spring-cloud-starter-netflix-eureka-server` / `-client`	Service registry and discovery
OpenFeign	`spring-cloud-starter-openfeign`	Declarative REST clients
LoadBalancer	`spring-cloud-starter-loadbalancer`	Client-side load balancing
Circuit Breaker	`spring-cloud-starter-circuitbreaker-resilience4j`	Resilience: retries, fallbacks, bulkheads
Consul	`spring-cloud-starter-consul-discovery`	Alternative discovery + KV config

Gateway

A reactive (Project Reactor) gateway that routes traffic to backend services, applies cross-cutting filters (auth, rate limiting, CORS), and integrates with discovery via lb:// URIs. See API Gateway.

Config

A @EnableConfigServer application serves configuration from a git repository; clients import it at startup and refresh at runtime with @RefreshScope. See Config Server.

Eureka

A discovery server where services register themselves and look each other up by logical name. See Service Discovery (Eureka).

OpenFeign + LoadBalancer

OpenFeign turns an interface into an HTTP client; combined with Spring Cloud LoadBalancer it transparently spreads calls across discovered instances. See OpenFeign Client and Load Balancing.

Resilience4j

Spring Cloud Circuit Breaker wraps Resilience4j to add circuit breakers, retries, rate limiters, bulkheads, and time limiters around remote calls. See Circuit Breaker (Resilience4j).

How they fit together

spring-cloud-dependencies (BOM)  ── pins all versions
        │
        ├── starter-gateway          → edge routing
        ├── starter-config           → fetch config at boot
        ├── netflix-eureka-client    → register + discover
        ├── starter-loadbalancer     → spread calls
        ├── starter-openfeign        → call other services
        └── circuitbreaker-resilience4j → survive failures

Tip: Add only the starters a given service needs. A pure backend service rarely needs the gateway starter; the gateway rarely needs JPA. Keep each artifact focused.