Building Microservices with Spring Cloud

Microservices architecture is changing the way we build modern applications. Instead of creating one large application (monolith), we build many small services that work together. Each service is independent, easy to scale, and can use different technologies.

In this article, we’ll learn how to build microservices using Spring Cloud, a popular toolkit built on top of Spring Boot.

---

🔧 What Are Microservices?

Microservices are a way of building software where each feature or business logic is a small, separate service.

✅ Key Features:

• Independent deployment

• Own database

• Communicates using APIs (often REST)

• Small, focused responsibility

Example: In an e-commerce app, different microservices can be:

• Product Service

• Order Service

• Payment Service

• Notification Service

---

🚀 What is Spring Cloud?

Spring Cloud is a set of tools that helps us build microservices easily in the Spring ecosystem. It handles:

• Service Discovery

• Load Balancing

• Configuration Management

• API Gateway

• Fault Tolerance

It works with Spring Boot, so you can quickly set up services with less code.

---

🧱 Step-by-Step Guide to Build Microservices with Spring Cloud

🔹 Step 1: Create Spring Boot Projects

Use Spring Initializr (https://start.spring.io) to create multiple microservices. For example:

• product-service

• order-service

• discovery-server

• config-server

• api-gateway

Each of these will be a separate project.

---

🔹 Step 2: Set Up Eureka Discovery Server

Eureka is used to register all services.

// Main class
@EnableEurekaServer
@SpringBootApplication
public class DiscoveryServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(DiscoveryServerApplication.class, args);
    }
}

In application.yml:

server:
  port: 8761

eureka:
  client:
    register-with-eureka: false
    fetch-registry: false

---

🔹 Step 3: Register Services with Eureka

Add Eureka Client dependency and register services like this:

spring:
  application:
    name: product-service

eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

In main class:

@EnableEurekaClient
@SpringBootApplication
public class ProductServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(ProductServiceApplication.class, args);
    }
}

---

🔹 Step 4: Set Up Spring Cloud Config Server

The Config Server stores config files in a Git repo or folder and shares them with other services.

@EnableConfigServer
@SpringBootApplication
public class ConfigServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(ConfigServerApplication.class, args);
    }
}

---

🔹 Step 5: Centralized Configuration

Keep service config files in Git:

product-service.yml
order-service.yml

Each service loads config from the Config Server:

spring:
  config:
    import: configserver:http://localhost:8888

---

🔹 Step 6: Create REST APIs in Microservices

Example in ProductServiceController.java:

@RestController
@RequestMapping("/products")
public class ProductController {

    @GetMapping
    public List<String> getProducts() {
        return List.of("iPhone", "Samsung", "Pixel");
    }
}

---

🔹 Step 7: Set Up Spring Cloud Gateway

Spring Cloud Gateway is used as a single entry point for all microservices.

In application.yml:

spring:
  cloud:
    gateway:
      routes:
        - id: product-service
          uri: lb://PRODUCT-SERVICE
          predicates:
            - Path=/products/**

Add Eureka discovery and the gateway will automatically route to services.

---

🔹 Step 8: Call Other Services with Feign Client

Feign makes REST calls easy.

@FeignClient(name = "order-service")
public interface OrderClient {
    @GetMapping("/orders")
    List<Order> getAllOrders();
}

---

🔹 Step 9: Add Resilience with Resilience4J

Use Resilience4J for circuit breakers and fallback logic.

@CircuitBreaker(name = "orderService", fallbackMethod = "fallbackOrders")
public List<Order> getAllOrders() {
    return orderClient.getAllOrders();
}

public List<Order> fallbackOrders(Exception e) {
    return List.of(); // empty list on failure
}

---

🔹 Step 10: Add Tracing with Zipkin

Zipkin helps trace requests between microservices.

Add dependency:

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-zipkin</artifactId>
</dependency>

In application.yml:

spring:
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
      probability: 1.0

---

🧪 Testing the Microservices

1. Start Eureka Server.

2. Start Config Server.

3. Start individual microservices.

4. Start Gateway.

5. Open http://localhost:8761 to see registered services.

6. Access APIs through the gateway:

   http://localhost:8080/products
   http://localhost:8080/orders
   

---

📦 Advantages of Spring Cloud

• Easy service discovery

• Central configuration

• Secure and scalable

• Simplified REST calls

• Smart routing with gateway

• Built-in resilience and tracing

---

⚠️ Challenges to Consider

• Need to handle service failures

• More components to manage

• Initial setup complexity

• Requires good understanding of cloud principles

---

✅ Best Practices

• Use separate databases for each service

• Monitor services using tools like Zipkin and Prometheus

• Handle exceptions gracefully

• Use versioning for APIs

• Secure services with Spring Security or OAuth2

---

🚀 Final Words

Spring Cloud simplifies building microservices by offering powerful tools to solve complex problems. Once you set up the basics, you can build scalable and maintainable systems for real-world projects.

Learn Full Stack Java Course

Read More 

How Generative AI Differs from Traditional AI

Tosca Course

Why Choose Python for Full-Stack Web Development

Generative AI in Simple Words