Arsitektur Envoy Service Mesh untuk Zero Trust Microservices

Dalam 15 menit ke depan, kita akan merakit sebuah stack Zero Trust microservices dari nol sampai berjalan mulus. Lupakan sejenak teori jaringan yang njelimet; bayangkan kita sedang berada di dapur operasional sebuah infrastruktur web skala besar yang melayani jutaan request per detik. Kemarin malam, tim keamanan berteriak karena ada lalu lintas lateral antar container yang tidak terenkripsi di dalam cluster, dan kita ditugaskan untuk membereskannya tanpa merusak performa aplikasi Go dan Node.js yang sudah berjalan. Jawabannya bukan dengan mematikan service, melainkan dengan memasang Envoy proxy sebagai sidecar cerdas yang mengatur gerbang keamanan secara ketat.

1. Menu Kita Hari Ini & Alat yang Perlu Disiapkan

Sebelum kita mulai meracik konfigurasi, mari pastikan meja kerja kita bersih dan siap. Kita tidak butuh setup yang rumit. Cukup siapkan Docker dan Docker Compose versi terbaru di mesin lokal Anda—baik itu Linux, macOS, atau WSL2 di Windows. Kita akan mensimulasikan dua microservice backend (misalnya service autentikasi berbasis Node.js dan service pemrosesan data berbasis Go) yang dibungkus dengan sidecar Envoy.

[!IMPORTANT] Pastikan port 8080 (untuk Ingress Gateway) dan port 9901 (untuk Envoy Admin Interface) tidak sedang digunakan oleh service lokal lain seperti Nginx atau Apache.

Bahan utama resep kita hari ini adalah file konfigurasi YAML berformat khusus untuk Envoy, beberapa sertifikat TLS self-signed untuk simulasi mTLS, dan secangkir kopi hangat untuk menemani proses debugging kita.

2. Peta Jalan Singkat: Apa yang Sedang Kita Rakit

Perjalanan kita terbagi menjadi tiga fase utama yang mengalir secara natural. Pertama, kita akan membangun Konfigurasi Ingress Gateway Envoy di pintu masuk terluar, tempat di mana traffic HTTP/HTTPS dari klien publik mendarat sebelum diteruskan ke cluster internal. Kedua, kita menerapkan Mutual TLS (mTLS) Setup untuk memastikan setiap jabat tangan (handshake) antar microservice di dalam mesh terenkripsi end-to-end dan saling memvalidasi identitas. Terakhir, kita meracik Traffic Splitting & Canary Deployment agar kita bisa merilis versi baru service backend secara bertahap tanpa membuat user menyadari adanya pergantian dapur.

Mari kita mulai dengan menyiapkan fondasinya agar perpindahan antar fase terasa mulus tanpa hambatan.

3. Langkah 1: Mempersiapkan Fondasi & Environment

Pertama-tama, buat sebuah direktori kerja baru di terminal Anda dan siapkan struktur folder untuk menyimpan sertifikat SSL dan file konfigurasi YAML kita:

mkdir -p envoy-zero-trust/certs envoy-zero-trust/config
cd envoy-zero-trust

Untuk mensimulasikan lingkungan Zero Trust nyata, kita butuh Certificate Authority (CA) internal guna menerbitkan sertifikat mTLS. Jalankan perintah OpenSSL berikut untuk membuat CA root, sertifikat untuk Ingress Gateway, dan sertifikat untuk service internal kita:

# Buat Root CA
openssl genrsa -out certs/ca.key 4096
openssl req -x509 -new -nodes -key certs/ca.key -sha256 -days 365 -out certs/ca.crt -subj "/CN=RootCA"

# Buat sertifikat untuk Ingress Gateway
openssl genrsa -out certs/ingress.key 2048
openssl req -new -key certs/ingress.key -out certs/ingress.csr -subj "/CN=ingress.mesh.local"
openssl x509 -req -in certs/ingress.csr -CA certs/ca.crt -CAkey certs/ca.key -CAcreateserial -out certs/ingress.crt -days 365 -sha256

Lihat respons terminal Anda—jika file .crt dan .key tercipta tanpa error, itu tandanya identitas kriptografis infrastruktur kita sudah siap. Sekarang, mari kita tuangkan resep inti konfigurasi Envoy.

4. Langkah 2: Meracik Konfigurasi Inti Tanpa Basa-basi

Masuklah ke folder config dan buat file bernama envoy.yaml. Di sinilah otak dari service mesh kita berada. Kita akan mendefinisikan listener untuk Ingress Gateway yang mendengarkan port 8080, serta routing cluster menuju service backend.

admin:
  address:
    socket_address:
      address: 0.0.0.0
      port_value: 9901

static_resources:
  listeners:
    - name: ingress_listener
      address:
        socket_address:
          address: 0.0.0.0
          port_value: 8080
      filter_chains:
        - filters:
            - name: envoy.filters.network.http_connection_manager
              typed_config:
                '@type': type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
                stat_prefix: ingress_http
                route_config:
                  name: local_route
                  virtual_hosts:
                    - name: backend_services
                      domains: ["*"]
                      routes:
                        - match:
                            prefix: "/"
                          route:
                            cluster: backend_service_cluster
                http_filters:
                  - name: envoy.filters.http.router
                    typed_config:
                      '@type': type.googleapis.com/envoy.extensions.filters.http.router.v3.Router

  clusters:
    - name: backend_service_cluster
      connect_timeout: 0.25s
      type: STRICT_DNS
      lb_policy: ROUND_ROBIN
      load_assignment:
        cluster_name: backend_service_cluster
        endpoints:
          - lb_endpoints:
              - endpoint:
                  address:
                    socket_address:
                      address: backend-app
                      port_value: 3000

Konfigurasi di atas baru menangani pintu masuk luar. Untuk melengkapi skema Zero Trust, kita perlu memperkuat lapisan enkripsi di dalam jaringan internal menggunakan mTLS.

5. Langkah 3: Sentuhan Akhir Keamanan & Optimasi

Bagaimana agar komunikasi antar service di balik layar tidak bisa disadap oleh pihak ketiga yang berhasil menyusup ke cluster? Jawabannya ada pada konfigurasi transport_socket di dalam cluster definition Envoy. Kita akan memperbarui konfigurasi untuk memaksa validasi sertifikat klien dan server.

Tambahkan blok transport_socket berikut ke dalam cluster Anda di envoy.yaml:

      transport_socket:
        name: envoy.transport_sockets.tls
        typed_config:
          '@type': type.googleapis.com/envoy.extensions.transport_sockets.tls.v3.UpstreamTlsContext
          common_tls_context:
            validation_context:
              trusted_ca:
                filename: /etc/ssl/certs/ca.crt
            tls_certificates:
              - certificate_chain:
                  filename: /etc/ssl/certs/ingress.crt
                private_key:
                  filename: /etc/ssl/certs/ingress.key

[!TIP] Selalu gunakan volume mounting di Docker untuk menyuplai sertifikat TLS daripada membakarnya langsung (COPY) di dalam image Docker. Ini memudahkan proses rotasi sertifikat tanpa harus rebuild seluruh container.

Sekarang, mari bungkus semuanya dengan docker-compose.yml di direktori utama agar kita bisa menyalakannya dalam satu perintah:

version: '3.8'
services:
  envoy-ingress:
    image: envoyproxy/envoy:v1.28-latest
    ports:
      - "8080:8080"
      - "9901:9901"
    volumes:
      - ./config/envoy.yaml:/etc/envoy/envoy.yaml
      - ./certs:/etc/ssl/certs
    command: ["envoy", "-c", "/etc/envoy/envoy.yaml"]

6. Tes Rasa: Memastikan Semuanya Berjalan Sempurna

Jalankan stack kita dengan perintah klasik:

docker-compose up -d

Perhatikan log container atau buka browser ke http://localhost:9901 untuk melihat Envoy Admin Dashboard. Anda akan melihat metrik runtime, status cluster, dan statistik listener secara real-time. Untuk menguji jalur traffic ingress, kirimkan curl sederhana:

curl -i http://localhost:8080/

Jika Envoy mengembalikan respons (bahkan jika backend-nya belum menyala dan menghasilkan kode 503 Service Unavailable), itu adalah tanda kemenangan mutlak! Artinya, Envoy sudah berhasil berdiri di posisinya, menyaring koneksi, dan siap meneruskan traffic dengan aman.

7. Pertolongan Pertama: Jika Terjadi Kendala Kecil

Kadang kala di lapangan, Anda akan menjumpai error seperti upstream connect error or disconnect/reset before completion saat melakukan curl. Jangan panik.

Pertama, cek apakah service backend Anda benar-benar hidup dan mendengarkan pada port yang sesuai di Docker network. Kedua, periksa apakah nama domain di STRICT_DNS sesuai dengan nama service di Docker Compose. Ketiga, jika Anda mengaktifkan mTLS ketat dan mendapati error handshake failed, pastikan file ca.crt yang dipegang oleh client dan upstream server berasal dari Root CA yang persis sama. Cukup sesuaikan baris konfigurasi tersebut, restart container Envoy, dan infrastruktur Zero Trust Anda kembali kokoh.