Praktik Mandiri 12: Microservices dengan Spring Boot

Tahap 1: Pemahaman Konsep Microservices

Tujuan: Memahami arsitektur microservices dan perbedaannya dengan monolitik.

1. Materi:
   • Karakteristik microservices: Decentralized, Scalable, Independently Deployable.
   • Kelebihan & tantangan: Distributed systems, data management, consistency.
   • Perbandingan dengan monolitik dan SOA (Service-Oriented Architecture).
2. Praktik:
   • Analisis studi kasus (contoh: Netflix, Amazon).
   • Buat diagram arsitektur sederhana untuk aplikasi e-commerce dengan 3 microservices (User, Product, Order).

---

Tahap 2: Setup Spring Boot untuk Microservices

Tujuan: Membangun microservice sederhana dengan Spring Boot.

1. Materi:
   • Spring Boot dasar: @RestController, @Service, dependency injection.
   • Konfigurasi application.properties/application.yml.
   • Penggunaan Spring Initializr (https://start.spring.io/).
2. Praktik:
   • Buat microservice “User Service” dengan endpoint:
     • GET /users: Mengembalikan daftar user.
     • POST /users: Menambahkan user baru.
   • Contoh kode:

@RestController
@RequestMapping("/users")
public class UserController {
    @GetMapping
    public List<User> getUsers() {
        return userService.getAllUsers();
    }
}

3. Sumber Belajar: Spring Boot Documentation.

Tahap 3: Service Discovery & Load Balancing

Tujuan: Mengimplementasikan service discovery dengan Spring Cloud Netflix Eureka.

1. Materi:
   • Konsep service registry dan client-side discovery.
   • Integrasi Eureka Server dan Eureka Client.
2. Praktik:
   • Buat Eureka Server sebagai registry.
   • Daftarkan 2 instance “User Service” ke Eureka.
   • Implementasi load balancing dengan @LoadBalanced di RestTemplate.
   • Contoh konfigurasi Eureka Client:

# application.yml
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

3. Sumber Belajar: Spring Cloud Netflix Eureka Docs.

Tahap 4: Komunikasi Antar Microservices

Tujuan: Mengatur komunikasi antar service dengan RestTemplate, Feign Client, dan Message Broker.

1. Materi:
   • RESTful API communication (synchronous).
   • Event-driven architecture dengan Apache Kafka atau RabbitMQ (asynchronous).
2. Praktik:
   • Buat “Order Service” yang memanggil “User Service” menggunakan Feign Client:

@FeignClient(name = "user-service")
public interface UserServiceClient {
    @GetMapping("/users/{id}")
    User getUserById(@PathVariable Long id);
}

Implementasi event OrderCreated menggunakan Kafka:

@KafkaListener(topics = "order-topic")
public void handleOrderEvent(OrderEvent event) {
    // Proses event
}

3. Sumber Belajar: Spring Cloud OpenFeign.

Tahap 5: Resilience & Fault Tolerance

Tujuan: Menangani kegagalan dengan Resilience4j atau Hystrix.

1. Materi:
   • Circuit Breaker, Retry, Rate Limiter.
   • Fallback mechanism.
2. Praktik:
   • Tambahkan circuit breaker di Feign Client untuk menghindari cascading failure:

@FeignClient(name = "user-service", fallback = UserServiceFallback.class)
public interface UserServiceClient { ... }

Contoh fallback class:

@Component
public class UserServiceFallback implements UserServiceClient {
    @Override
    public User getUserById(Long id) {
        return new User("default", "default@email.com");
    }
}

Sumber Belajar: Resilience4j Documentation.

Tahap 6: Centralized Configuration & API Gateway

Tujuan: Mengelola konfigurasi terpusat dengan Spring Cloud Config dan routing dengan Spring Cloud Gateway.

1. Materi:
   • Penyimpanan konfigurasi di Git repository.
   • Dynamic refresh dengan @RefreshScope.
   • Routing, filtering, dan authentication di API Gateway.
2. Praktik:
   • Buat Spring Cloud Config Server yang terhubung ke GitHub repo.
   • Implementasi API Gateway untuk routing:

# application.yml (Gateway)
spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/users/**

3. Sumber Belajar: Spring Cloud Gateway Docs.

Tahap 7: Distributed Tracing & Monitoring

Tujuan: Melacak request di seluruh microservices dengan Zipkin dan Sleuth.

1. Materi:
   • Trace ID dan Span ID untuk debugging.
   • Integrasi dengan Zipkin dashboard.
2. Praktik:
   • Tambahkan Sleuth dan Zipkin di semua microservices.
   • Pantau request dari “Order Service” ke “User Service” di dashboard Zipkin.
   • Contoh konfigurasi:

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

3. Sumber Belajar: Spring Cloud Sleuth Docs.

Tahap 8: Containerisasi & Deployment

Tujuan: Mendeploy microservices dengan Docker dan Kubernetes.

1. Materi:
   • Dockerfile untuk Spring Boot aplikasi.
   • Kubernetes basics: Pod, Service, Deployment.
2. Praktik:
   • Containerize “User Service” dengan Docker:

FROM openjdk:17-jdk-slim
COPY target/user-service.jar app.jar
ENTRYPOINT ["java","-jar","/app.jar"]

• Deploy ke Kubernetes cluster (minikube atau cloud provider).

3. Sumber Belajar: Docker Docs, Kubernetes Basics.

Proyek Akhir: Sistem E-Commerce Microservices

Fitur:

1. Service:
   • User Service: Manajemen user & autentikasi (Spring Security + JWT).
   • Product Service: CRUD produk.
   • Order Service: Proses order dengan komunikasi ke Product Service.
   • Notification Service: Mengirim email (asynchronous via Kafka).
2. Teknologi:
   • Spring Boot, Eureka, Spring Cloud Gateway, Kafka, PostgreSQL, Docker.
3. Deployment:
   • Docker Compose untuk lingkungan lokal atau Kubernetes untuk production.

---

Jadwal Belajar (8 Minggu)

Minggu	Topik	Target
1	Konsep Microservices	Diagram arsitektur e-commerce
2	Spring Boot & Service Discovery	2 microservices + Eureka Server
3	Komunikasi & Resilience	Feign Client + Circuit Breaker
4	API Gateway & Config Server	Routing & centralized config
5	Distributed Tracing	Integrasi Zipkin + Sleuth
6	Event-Driven dengan Kafka	Async notification service
7-8	Containerisasi & Proyek Akhir	Deploy ke Kubernetes

---

Tips Penting

1. Gunakan Git: Pisahkan repository per service atau gunakan monorepo.
2. Testing:
   • Unit test dengan JUnit/Mockito.
   • Integration test dengan @SpringBootTest.
   • Contract testing dengan Pact untuk kompatibilitas API.
3. Monitoring:
   • Prometheus + Grafana untuk metrics (CPU, memory, request rate).
4. Komunitas:
   • Bergabung di forum Spring Community atau Stack Overflow.

---

Dengan konsistensi dan eksplorasi, Anda akan menguasai pembuatan sistem terdistribusi yang scalable dan resilient menggunakan Spring Boot. Selamat belajar! 🚀