Belajar Spring Boot - Cloud-Native Deployment

#Pendahuluan

Menjalankan aplikasi di laptop tidak cukup — aplikasi harus berjalan di cloud dengan container yang ringan, startup yang cepat, dan probe yang tepat agar orchestration bekerja. Episode 20 membahas cloud-native deployment secara menyeluruh.

Kalian akan mengoptimalkan Dockerfile, mempelajari native image dengan GraalVM, mengonfigurasi probe Kubernetes yang benar, dan meninjau pilihan platform cloud untuk deployment.

#Dockerfile Optimasi dan Multi-Stage Build

#Masalah Dockerfile Naif

Container yang buruk bisa berisi build tool, source code, dan layer yang membengkak. Multi-stage build menyelesaikannya: stage pertama membangun aplikasi dengan JDK dan Maven, stage kedua hanya menyalin jar ke image runtime yang ramping:

FROM eclipse-temurin:21-jdk AS builder
WORKDIR /app
COPY .mvn .mvn
COPY mvnw pom.xml ./
RUN ./mvnw dependency:go-offline
COPY src ./src
RUN ./mvnw clean package -DskipTests
 
FROM eclipse-temurin:21-jre
WORKDIR /app
COPY --from=builder /app/target/belajar-spring-boot.jar app.jar
EXPOSE 8080
ENTRYPOINT ["java", "-XX:MaxRAMPercentage=75", "-jar", "app.jar"]

Stage builder memakai JDK untuk meng-compile; stage runtime hanya membawa JRE dan jar. Perhatikan pemisahan dependency:go-offline sebelum COPY src — ini memanfaatkan layer cache Docker agar dependency tidak diunduh ulang saat source berubah.

#Optimasi Tambahan

• Gunakan flag -XX:MaxRAMPercentage agar heap menyesuaikan batas memory container secara dinamis.
• Jalankan image dengan user non-root untuk keamanan.
• Pin tag base image ke versi tertentu agar build reproducible.

#Native Image dengan GraalVM dan Spring AOT

#Mengapa Native Image

JVM memulai aplikasi dalam detik; native image memulai dalam milidetik dengan memory jauh lebih kecil. GraalVM meng-compile aplikasi Java menjadi executable native — kode Java diterjemahkan ke machine code pada build time.

./mvnw -Pnative native:compile
./target/belajar-spring-boot

Perintah ./mvnw -Pnative native:compile menghasilkan executable native di folder target. Hasilnya: aplikasi berjalan tanpa JVM, cocok untuk serverless dan instance yang sering di-scale.

#Spring AOT dan Keterbatasan

Spring AOT (Ahead-of-Time) memproses aplikasi saat build time — memindai bean, konfigurasi, dan reflection — sehingga native image tahu apa yang harus disertakan. Namun tidak semua library kompatibel dengan native image, dan waktu build jauh lebih lama. Untuk aplikasi yang membutuhkan startup ultracepat dengan trade-off yang bisa diterima, native image adalah pilihan yang kuat.

#Integrasi dengan Kubernetes

#Probes: liveness, readiness, dan startup

Kubernetes memakai probe untuk mengetahui kondisi aplikasi. Spring Boot Actuator dari episode 9 menjadi sumbernya:

spec:
  containers:
    - name: belajar-spring-boot
      image: belajar-spring-boot:1.0
      ports:
        - containerPort: 8080
      readinessProbe:
        httpGet:
          path: /actuator/health/readiness
          port: 8080
        initialDelaySeconds: 10
      livenessProbe:
        httpGet:
          path: /actuator/health/liveness
          port: 8080

readinessProbe menentukan kapan pod menerima traffic, livenessProbe menentukan kapan pod di-restart karena tidak sehat, dan startupProbe (untuk aplikasi dengan startup lambat) menunda kedua probe di atas. Aktuator menyediakan tiga endpoint tersebut secara terpisah — pastikan management.endpoint.health.probes.enabled=true.

#Deployment dan Rolling Update

Define deployment agar Kubernetes mengelola rollout:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: belajar-spring-boot
spec:
  replicas: 3
  selector:
    matchLabels:
      app: belajar-spring-boot
  template:
    metadata:
      labels:
        app: belajar-spring-boot
    spec:
      containers:
        - name: belajar-spring-boot
          image: belajar-spring-boot:1.0
          imagePullPolicy: IfNotPresent

Gunakan Helm chart untuk mengelola template ini secara parameterizable. Strategi rollout — canary dan blue-green — akan dibahas lebih dalam di episode 21.

#Deployment ke Platform Cloud

#Managed Kubernetes dan PaaS

Beberapa jalur untuk menjalankan aplikasi di cloud:

• Managed Kubernetes: EKS di AWS, GKE di Google Cloud, AKS di Azure — kontrol penuh, tanggung jawab lebih besar.
• Platform PaaS: Cloud Run, AWS App Runner, Azure App Service — deploy image langsung, platform mengelola scaling.
• Serverless: AWS Lambda lewat Quarkus atau native image Spring — eksekusi per fungsi.

Untuk Cloud Run, deployment cukup dua perintah:

docker build -t belajar:1.0 .
gcloud run deploy belajar \
  --image belajar:1.0 --platform managed

Perintah gcloud run deploy belajar --image belajar:1.0 --platform managed mendepoy image ke Cloud Run. Cloud Run menangani scaling otomatis hingga nol, sehingga cocok dengan aplikasi Spring Boot ber-startup cepat.

#Penutup

Episode 20 membekali kalian dengan deployment cloud-native: Dockerfile multi-stage yang ramping, native image dengan GraalVM dan Spring AOT, probe Kubernetes yang benar untuk liveness dan readiness, serta pilihan deployment di AWS, GCP, Azure, dan platform PaaS.

Inti yang harus dibawa pulang:

• Multi-stage Dockerfile memisahkan build dan runtime untuk image yang ramping.
• -XX:MaxRAMPercentage menyesuaikan heap dengan memory container.
• Native image mempercepat startup secara drastis dengan trade-off kompatibilitas.
• Actuator menyediakan endpoint readiness dan liveness untuk probe Kubernetes.
• startupProbe mencegah restart dini untuk aplikasi dengan startup lambat.
• Pilih managed Kubernetes, PaaS, atau serverless sesuai kebutuhan dan tanggung jawab.

Di episode 21 selanjutnya kita akan membahas CI/CD dan release automation — pipeline dengan GitHub Actions dan GitLab CI, build test security scan dan deploy otomatis, artifact registry dan versioning, serta strategi canary release, blue-green, dan rollback.