Belajar Spring Boot - API Gateway & Secure Microservices

#Pendahuluan

Ketika aplikasi berkembang menjadi banyak service kecil, keamanan tidak lagi hanya soal satu aplikasi. Episode 14 membahas API gateway dan secure microservices — bagaimana satu titik masuk yang aman melindungi seluruh sistem.

Kalian akan memahami pola API gateway sebagai security boundary, membangun gateway dengan Spring Cloud Gateway, mengamankan komunikasi antar service, dan menerapkan rate limiting serta API contract yang aman.

#Pola API Gateway dan Security Boundary

#Mengapa Perlu Gateway

Dalam arsitektur microservices, setiap service tidak boleh terekspos langsung ke client. API gateway menjadi satu titik masuk tunggal yang mengarahkan request ke service yang tepat. Manfaat utamanya:

• Routing — memetakan path ke service backend.
• Security boundary — memvalidasi token sekali di gateway, bukan di setiap service.
• Cross-cutting concern — rate limiting, logging, dan CORS dipusatkan.
• Abstraksi — client hanya tahu gateway, bukan topologi internal.

#Batasan yang Jelas

Gateway membentuk trust boundary: jaringan internal hanya mempercayai request yang datang melalui gateway. Service internal harus menolak request dari luar. Di environment container, aturan ini ditegakkan dengan network policy.

#Spring Cloud Gateway

#Menambahkan Dependency

Spring Cloud Gateway dibangun di atas WebFlux dan menyediakan routing reaktif:

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

Gateway ini bukan aplikasi MVC — ia berjalan di atas server reaktif Netty. Karena itu konfigurasi routing dilakukan lewat YAML atau RouteLocator.

#Konfigurasi Routing

Definisikan route yang menghubungkan path publik ke service internal:

spring:
  cloud:
    gateway:
      routes:
        - id: item-service
          uri: http://item-service:8080
          predicates:
            - Path=/api/items/**
        - id: order-service
          uri: http://order-service:8081
          predicates:
            - Path=/api/orders/**

Predicate Path=/api/items/** memastikan semua request dengan awalan /api/items/ diteruskan ke item-service. Dengan gateway, client memanggil satu host saja — misalnya https://api.example.com — sementara internal routing sepenuhnya dikelola gateway.

#Filter untuk Modifikasi Request

Tambahkan filter untuk menyuntikkan atau memodifikasi header sebelum diteruskan:

spring:
  cloud:
    gateway:
      routes:
        - id: item-service
          uri: http://item-service:8080
          predicates:
            - Path=/api/items/**
          filters:
            - StripPrefix=1

Filter StripPrefix=1 menghapus segmen pertama path — /api/items/123 menjadi /items/123 di sisi service. Kombinasi predicate dan filter memberikan kontrol penuh atas alur request.

#Autentikasi dan Otorisasi Service-to-Service

#Trust Boundary dan JWT

Dua pola umum untuk komunikasi service-to-service:

• JWT dengan klaim service — service memakai client credentials untuk mendapat token, lalu memanggil service lain dengan token tersebut.
• mTLS — mutual TLS di mana kedua sisi memverifikasi sertifikat satu sama lain; sangat kuat untuk jaringan internal.

Untuk pola JWT, konfigurasi resource server (episode 13) dipakai di setiap service. Contoh layanan yang memakai client_credentials untuk memanggil service lain:

@Configuration
public class ServiceClientConfig {
 
    @Bean
    public OAuth2AuthorizedClientManager authorizedClientManager(
            ClientRegistrationRepository clients,
            OAuth2AuthorizedClientService authorizedClients) {
        return new AuthorizedClientServiceOAuth2AuthorizedClientManager(
                clients, authorizedClients);
    }
}

Alur ini memastikan setiap service membuktikan identitasnya saat memanggil service lain — bukan sekadar mempercayai request dari jaringan internal.

#Validasi Token di Setiap Service

Meski gateway memvalidasi token untuk client eksternal, service internal tetap harus memvalidasi — jangan mengandalkan asumsi bahwa request selalu datang dari gateway. Prinsip defense in depth ini melindungi service jika ada celah di gateway.

#Rate Limiting dan Secure API Contracts

#Rate Limiting di Gateway

Rate limiting melindungi sistem dari lonjakan request dan penyalahgunaan. Spring Cloud Gateway memakai bucket-based limiter; contoh dengan Redis:

spring:
  cloud:
    gateway:
      routes:
        - id: item-service
          uri: http://item-service:8080
          predicates:
            - Path=/api/items/**
          filters:
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 10
                redis-rate-limiter.burstCapacity: 20
                redis-rate-limiter.requestedTokens: 1

Konfigurasi di atas membatasi rata-rata 10 request per detik dengan burst hingga 20. Saat kuota habis, gateway mengembalikan 429 Too Many Requests. Redis dipakai untuk melacak penghitungan secara terdistribusi.

#Secure API Contracts

Kontrak API yang jelas mengurangi miskomunikasi antar tim. Praktik yang disarankan:

• Dokumentasikan kontrak dengan OpenAPI dan validasi request secara otomatis.
• Versi-kan API — misalnya /api/v1/items — agar perubahan tidak merusak client lama.
• Terapkan validation di sisi gateway maupun service untuk melindungi dari payload berbahaya.

for i in $(seq 1 25); do
  curl -s -o /dev/null -w "%{http_code}\n" http://localhost:8080/api/items
done

Loop for i in $(seq 1 25); do curl ...; done mengirim 25 request beruntun. Perhatikan bahwa request melewati batas akan menerima 429 Too Many Requests — bukti rate limiter bekerja.

#Penutup

Episode 14 membekali kalian dengan keamanan dan arsitektur microservices: pola API gateway sebagai security boundary, routing dan filtering dengan Spring Cloud Gateway, autentikasi service-to-service, serta rate limiting dan secure API contracts.

Inti yang harus dibawa pulang:

• API gateway adalah satu titik masuk yang menangani routing, security, dan cross-cutting concern.
• Spring Cloud Gateway dikonfigurasi lewat route, predicate, dan filter.
• Service internal tetap harus memvalidasi token meski sudah lewat gateway.
• Service-to-service memakai JWT client credentials atau mTLS.
• Rate limiting dengan Redis melindungi dari lonjakan request.
• Dokumentasikan kontrak API dengan OpenAPI dan beri versi.

Di episode 15 selanjutnya kita akan membahas reactive programming dan WebFlux — konsep Mono dan Flux, backpressure, membangun aplikasi non-blocking dengan Spring WebFlux, integrasi database reaktif R2DBC, serta perbandingan dengan aplikasi servlet-based.