Belajar Java - Microservices & Cloud-Native Java

#Pendahuluan

Aplikasi modern jarang berjalan sendiri — ia menjadi bagian dari ekosistem layanan yang saling terhubung. Episode 20 membahas microservices dan cloud-native Java: arsitektur yang memecah aplikasi menjadi layanan kecil, framework Java modern, containerization, dan integrasi antar layanan.

Cloud-native adalah cara baru membangun dan menjalankan perangkat lunak: kontainer, orkestrasi, dan layanan yang independen. Kalian akan memahami pola microservices serta framework yang mendukungnya.

#Pengenalan Microservices dan Framework Java Modern

#Apa itu Microservices

Microservices memecah aplikasi menjadi layanan kecil yang independen — setiap layanan memiliki tanggung jawab tunggal, data sendiri, dan deployment terpisah. Layanan berkomunikasi lewat jaringan dengan REST, gRPC, atau message broker.

Keuntungannya: skala per layanan, isolasi kegagalan, dan tim yang otonom. Tantangannya: kompleksitas jaringan, data terdistribusi, dan observability yang lebih sulit.

#Monolit vs Microservices

Monolitik lebih sederhana untuk aplikasi kecil; microservices unggul saat aplikasi besar dengan banyak tim:

monolit: satu aplikasi, satu deployment
microservices: banyak layanan, banyak deployment

#Framework Java Modern untuk Microservices

#Spring Boot

Spring Boot adalah framework paling populer untuk microservices Java. Buat proyek cepat dengan Spring Initializr:

curl -s https://start.spring.io/starter.zip \
  -d type=maven-project \
  -d dependencies=web,actuator \
  -o demo.zip
unzip demo.zip

#Micronaut, Quarkus, dan Helidon

Micronaut dan Quarkus dirancang khusus untuk cloud-native dengan startup cepat dan konsumsi memori rendah, mendukung kompilasi native (AOT). Helidon dari Oracle juga menawarkan mode reactive dan microprofile. Pilihan framework bergantung kebutuhan: Spring Boot untuk ekosistem terbesar, Quarkus untuk cloud-native dan serverless, Micronaut untuk performa.

#Containerization Java dan Native Image GraalVM

#Docker untuk Aplikasi Java

Container membuat aplikasi portable. Buat Dockerfile untuk aplikasi Java:

FROM maven:3.9-eclipse-temurin-21 AS build
WORKDIR /app
COPY pom.xml .
RUN mvn dependency:go-offline
COPY src ./src
RUN mvn package -DskipTests
 
FROM eclipse-temurin:21-jre
WORKDIR /app
COPY --from=build /app/target/*.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-jar", "app.jar"]

Build image:

docker build -t aplikasi-demo:1.0.0 .
docker run -p 8080:8080 aplikasi-demo:1.0.0

docker build -t aplikasi-demo:1.0.0 . membuat image dari Dockerfile, dan docker run menjalankannya.

#Native Image GraalVM

GraalVM native image mengompilasi aplikasi Java menjadi executable native yang start dalam milidetik dan memakai memori jauh lebih sedikit — ideal untuk fungsi serverless:

native-image -jar aplikasi.jar aplikasi-native

native-image -jar aplikasi.jar menghasilkan binary native yang berjalan tanpa JVM.

#Service Discovery, Circuit Breaker, dan Observability

#Service Discovery

Layanan perlu menemukan satu sama lain di lingkungan yang dinamis. Service discovery memakai registry seperti Consul, Eureka, atau Kubernetes DNS:

layanan A -> service registry -> menemukan layanan B

#Circuit Breaker

Circuit breaker mencegah kegagalan berantai: jika satu layanan gagal, panggilan diputus sementara alih-alih menunggu timeout. Resilience4j adalah library populer:

import io.github.resilience4j.circuitbreaker.CircuitBreaker;
import io.github.resilience4j.circuitbreaker.CircuitBreakerRegistry;
 
public class DemoCircuitBreaker {
    public static void main(String[] args) {
        CircuitBreakerRegistry registry = CircuitBreakerRegistry.ofDefaults();
        CircuitBreaker cb = registry.circuitBreaker("layanan-pembayaran");
 
        System.out.println("State: " + cb.getState());
    }
}

#Observability

Microservices menuntut observability: metrik, log terstruktur, dan tracing terdistribusi. Spring Boot Actuator, Micrometer, dan OpenTelemetry (dibahas di episode 22) adalah fondasi pengamatan layanan.

#Penutup

Episode 20 membahas microservices dan cloud-native Java: arsitektur microservices, framework Spring Boot, Micronaut, Quarkus, dan Helidon, containerization dengan Docker dan native image GraalVM, serta service discovery, circuit breaker, dan observability.

Inti yang harus dibawa pulang:

• Microservices memecah aplikasi menjadi layanan independen.
• Spring Boot mendominasi; Quarkus dan Micronaut untuk cloud-native.
• Docker membuat aplikasi Java portable.
• GraalVM native image memberi startup super cepat.
• Service discovery membantu layanan menemukan satu sama lain.
• Circuit breaker mencegah kegagalan berantai.

Di episode 21 selanjutnya kita akan membahas CI/CD dan deployment produksi — Continuous Integration dan Continuous Delivery dengan GitHub Actions, build dan release management dengan semantic versioning, deployment ke server dan Kubernetes, serta strategi rollback dan blue-green deployment. Saatnya mengantar kode ke produksi!