Strangler Pattern: Modernisasi Aplikasi Legacy dengan Aman

• Architecture • By TryzTech Team
ArchitectureLegacy CodeMigrationRefactoringBackend
Bagikan

Daftar Isi

Kenapa Modernisasi Legacy Sering Gagal

Modernisasi aplikasi legacy jarang gagal karena tim kekurangan teknologi baru. Lebih sering, kegagalannya muncul karena tim mencoba mengganti terlalu banyak hal sekaligus. Sistem lama sudah melayani user, menyimpan data penting, menjalankan proses operasional, dan sering kali menyimpan pengetahuan bisnis yang tidak tertulis di dokumentasi mana pun.

Rewrite total terlihat menggoda karena memberi ilusi awal yang bersih. Tim bisa memakai framework baru, struktur folder baru, database baru, dan deployment pipeline baru. Masalahnya, aplikasi lama biasanya tidak hanya berisi kode buruk. Di dalamnya ada aturan diskon khusus, pengecualian proses finance, format data lama dari partner, dan perilaku kecil yang sudah dianggap normal oleh user.

Ketika semua itu diganti dalam satu proyek besar, risiko bisnis ikut membesar. Sistem baru belum tentu memahami semua edge case, sementara sistem lama tetap harus dijaga sampai pengganti siap. Akhirnya tim membayar dua biaya sekaligus: biaya membangun sistem baru dan biaya mempertahankan sistem lama.

Strangler Pattern menawarkan jalan yang lebih realistis: bukan mengganti seluruh aplikasi sekaligus, tetapi memindahkan capability satu per satu sampai sistem lama tidak lagi punya alasan untuk hidup.

Apa Itu Strangler Pattern

Strangler Pattern adalah pola modernisasi yang mengganti sistem lama secara bertahap dengan menempatkan layer pengarah di depan sistem tersebut. Layer ini bisa berupa reverse proxy, API gateway, facade, routing service, atau adapter di dalam aplikasi. Awalnya, hampir semua request tetap diarahkan ke sistem lama. Lalu, satu per satu alur tertentu dipindahkan ke implementasi baru.

Nama pola ini terinspirasi dari tanaman strangler fig yang tumbuh mengelilingi pohon lama sampai akhirnya struktur baru mengambil alih. Dalam konteks software, sistem baru tidak langsung menggantikan sistem lama. Ia tumbuh di sekelilingnya, menerima sebagian traffic, membuktikan dirinya stabil, lalu mengambil tanggung jawab lebih besar secara bertahap.

Hal penting: Strangler Pattern bukan sekadar memecah monolith menjadi microservice. Pola ini lebih luas dari itu. Kamu bisa memakainya untuk memindahkan modul dari framework lama ke framework baru, mengganti aplikasi desktop menjadi web app, memisahkan reporting dari core transaction system, atau memigrasikan endpoint tertentu ke layanan baru.

Ukuran keberhasilannya bukan “berapa banyak service baru yang dibuat”, tetapi apakah user bisa berpindah ke perilaku baru tanpa gangguan besar, dan apakah sistem lama benar-benar bisa dikurangi tanggung jawabnya.

Cara Kerja Strangler Pattern di Sistem Nyata

Strangler Pattern biasanya punya tiga bagian utama: entry point, sistem lama, dan sistem baru. Entry point adalah tempat semua request masuk dan diputuskan arahnya. Pada aplikasi web, entry point bisa berupa API gateway. Pada aplikasi backend internal, entry point bisa berupa facade atau service boundary. Pada aplikasi yang belum punya boundary jelas, langkah pertama sering kali adalah membuat boundary tersebut.

Alur awalnya sederhana. Semua request masuk ke entry point, lalu diteruskan ke sistem legacy seperti sebelumnya. Setelah itu, tim memilih satu capability kecil untuk dibangun ulang. Ketika capability baru sudah siap, entry point mulai mengarahkan request tertentu ke implementasi baru. Request lain tetap masuk ke sistem lama.

Contohnya, sebuah aplikasi e-commerce lama memiliki modul order, payment, invoice, report, dan customer support dalam satu monolith. Tim tidak perlu memindahkan semuanya sekaligus. Mereka bisa mulai dari report karena sifatnya read-heavy, risiko transaksi lebih rendah, dan sering menjadi bottleneck. Setelah report stabil di sistem baru, tim bisa memindahkan invoice, lalu sebagian proses order.

Kunci dari pendekatan ini adalah coexistence. Selama masa transisi, sistem lama dan sistem baru berjalan berdampingan. Karena itu, desain migration path sama pentingnya dengan desain sistem baru itu sendiri.

Diagram Arsitektur Strangler Pattern

Berikut gambaran bagaimana routing layer mengarahkan traffic antara aplikasi legacy dan capability baru selama proses modernisasi:

flowchart TD
    Client["Client Request (Web / Mobile / Partner)"] --> Gateway["API Gateway / Reverse Proxy"]
    
    subgraph Monolith ["Legacy Monolith System"]
        OldOrders["Order Service"]
        OldInvoices["Invoice Service"]
        OldReports["Reporting Module (Deprecated)"]
    end
    
    subgraph Strangler ["New Cloud-Native Service"]
        NewReports["Modern Reporting Service"]
        NewReportsDB[("Reporting Read DB")]
    end

    Gateway -- "Route: /api/orders/*, /api/invoices/*" --> Monolith
    Gateway -- "Route: /api/reports/*" --> NewReports
    NewReports --> NewReportsDB
    Monolith -. "CDC / Domain Events" .-> NewReportsDB

Pada fase awal, seluruh traffic masuk ke Monolith lama. Begitu modul report selesai dibangun dan divalidasi, gateway membelokkan route /api/reports/* ke service baru, sementara aliran data transaksi disinkronkan secara asinkron di background.

Kapan Strangler Pattern Cocok Dipakai

Strangler Pattern cocok ketika aplikasi lama masih penting bagi bisnis, tetapi sudah terlalu mahal untuk dikembangkan dengan cara lama. Misalnya, setiap perubahan kecil di modul checkout membutuhkan regression test manual berhari-hari, atau tim baru sulit onboarding karena struktur sistem terlalu kusut.

Pola ini juga cocok ketika organisasi tidak bisa menerima downtime besar. Jika aplikasi melayani transaksi harian, operasi gudang, payment, atau customer support, big bang rewrite hampir selalu terlalu berisiko. Dengan Strangler Pattern, traffic bisa dipindahkan bertahap, dimulai dari segmen kecil, user internal, region tertentu, atau jenis request tertentu.

Namun pola ini tidak selalu tepat. Jika sistem lama sangat kecil, jarang berubah, dan tidak menghambat roadmap, rewrite bertahap bisa menjadi overhead yang tidak perlu. Jika batas antar capability benar-benar tidak bisa dipisahkan tanpa merombak data model besar-besaran, tim mungkin perlu melakukan refactoring internal lebih dulu sebelum menerapkan Strangler Pattern.

Tanda paling sehat untuk memakai pola ini adalah ketika kamu bisa menunjuk capability yang jelas: “report penjualan”, “invoice generation”, “customer profile”, “search product”, atau “payment notification”. Semakin kabur capability-nya, semakin sulit routing dan ownership-nya.

Mulai dari Capability yang Tepat

Kesalahan awal yang sering terjadi adalah memilih bagian paling menyakitkan sebagai target pertama. Secara emosional itu masuk akal, tetapi secara engineering belum tentu bijak. Target pertama sebaiknya cukup bernilai untuk membuktikan pola migrasi, tetapi cukup rendah risiko agar tim bisa belajar tanpa mempertaruhkan core revenue.

Capability awal yang baik biasanya punya beberapa ciri. Boundary input dan output-nya relatif jelas. Dampaknya ke user bisa diukur. Ketergantungannya ke data transaksi utama tidak terlalu rumit. Jika gagal, rollback bisa dilakukan cepat. Contoh yang sering cocok adalah report, notification, search, export data, atau read-only customer profile.

Hindari memulai dari capability yang terlalu sentral seperti payment settlement, stock reservation, atau order state machine, kecuali tim sudah punya observability dan safety net yang kuat. Bagian-bagian ini bisa menjadi target berikutnya setelah pola routing, monitoring, dan rollback terbukti bekerja.

Sebelum membangun implementasi baru, tulis kontrak capability-nya. Apa input yang diterima? Apa output yang dijanjikan? Error apa yang mungkin terjadi? Siapa owner datanya? Bagaimana cara membandingkan hasil sistem baru dengan sistem lama? Kontrak ini akan menjadi pegangan saat traffic mulai dialihkan.

Tahapan Implementasi Strangler Pattern

Tahap pertama adalah membuat entry point yang bisa mengontrol traffic. Jangan langsung memindahkan logic. Pastikan dulu semua request bisa melewati pintu yang sama, log-nya terlihat, dan routing bisa diubah tanpa deploy besar. Pada tahap ini, sistem baru belum perlu melakukan apa-apa. Ia cukup memberi tim kendali atas arah traffic.

Tahap kedua adalah membangun capability baru dengan scope kecil. Implementasi baru sebaiknya memenuhi satu kebutuhan end-to-end, bukan setengah modul yang belum bisa dipakai. Jika targetnya report penjualan, buat satu jenis report yang benar-benar bisa melayani user tertentu, bukan fondasi abstrak untuk semua report masa depan.

Tahap ketiga adalah menjalankan shadow mode jika memungkinkan. Dalam mode ini, request utama tetap dilayani sistem lama, tetapi sistem baru menerima salinan request atau menjalankan kalkulasi paralel. Hasilnya dibandingkan untuk menemukan perbedaan perilaku sebelum user bergantung pada sistem baru.

Tahap keempat adalah partial rollout. Arahkan sebagian traffic ke sistem baru: user internal dulu, tenant tertentu, region tertentu, atau endpoint tertentu. Pantau error rate, latency, data mismatch, dan feedback user. Jika metric aman, naikkan persentase traffic secara bertahap.

Tahap terakhir adalah retirement. Setelah capability lama tidak menerima traffic, jangan biarkan kodenya menjadi museum. Hapus route lama, matikan job yang tidak dipakai, cabut konfigurasi, rapikan dashboard, dan dokumentasikan keputusan. Sistem legacy hanya benar-benar mengecil ketika bagian lama yang sudah tidak dipakai ikut dipensiunkan.

Data Ownership dan Konsistensi

Bagian tersulit dari Strangler Pattern biasanya bukan routing, melainkan data. Saat sistem lama dan baru hidup berdampingan, pertanyaan paling penting adalah: siapa pemilik data untuk capability ini?

Jika sistem baru hanya membaca data dari database lama, migrasi bisa dimulai lebih sederhana. Namun pendekatan ini punya batas. Sistem baru tetap bergantung pada schema lama, sehingga perubahan di database legacy bisa merusak layanan baru. Untuk jangka panjang, tim perlu menentukan kapan sistem baru memiliki model data sendiri.

Jika sistem baru mulai menulis data, risiko meningkat. Dual-write, yaitu menulis ke sistem lama dan baru sekaligus, terlihat praktis tetapi sering menjadi sumber inkonsistensi. Salah satu write bisa berhasil sementara yang lain gagal. Retry bisa menyebabkan duplikasi. Urutan event bisa berbeda. Karena itu, dual-write perlu dipakai sangat hati-hati, dengan idempotency key, reconciliation job, dan alert untuk mismatch.

Alternatif yang sering lebih aman adalah event-driven migration. Sistem lama tetap menjadi source of truth sementara, lalu menerbitkan event yang dikonsumsi sistem baru untuk membangun projection atau read model. Setelah sistem baru terbukti konsisten, ownership bisa dipindahkan secara eksplisit.

Prinsipnya: jangan biarkan dua sistem sama-sama merasa menjadi pemilik data yang sama tanpa aturan yang jelas. Coexistence boleh sementara, tetapi ownership harus eksplisit.

Testing, Observability, dan Rollback

Strangler Pattern hanya aman jika tim bisa melihat apa yang terjadi. Tanpa observability, partial rollout berubah menjadi tebak-tebakan. Minimal, setiap capability baru perlu punya metric untuk request count, error rate, latency, timeout, data mismatch, dan fallback ke sistem lama.

Testing juga perlu mencakup perilaku lama. Characterization test berguna untuk menangkap cara sistem legacy bekerja saat ini, termasuk perilaku yang terlihat aneh tetapi sudah diandalkan user. Untuk capability baru, tambahkan contract test di boundary agar input-output tetap stabil meskipun implementasi di belakangnya berubah.

Saat rollout, siapkan rollback yang nyata. Rollback bukan hanya “deploy ulang versi lama”. Dalam Strangler Pattern, rollback sering berarti mengubah routing agar traffic kembali ke legacy, mematikan feature flag, menghentikan consumer event, atau menjalankan reconciliation untuk data yang sudah terlanjur ditulis.

Setiap tahap rollout sebaiknya punya stop condition. Misalnya: error rate naik di atas 1%, latency p95 lebih lambat 30% dari baseline, mismatch data melewati ambang tertentu, atau ada complaint user dari segmen pilot. Dengan stop condition yang jelas, tim tidak perlu berdebat panjang ketika sinyal buruk muncul.

Contoh: Memisahkan Modul Report dari Aplikasi Lama

Bayangkan sebuah aplikasi internal untuk e-commerce. Semua operasi masuk ke monolith lama: order, payment, customer service, inventory, dan reporting. Modul report makin lambat karena query-nya berat dan berjalan di database transaksi yang sama. Setiap kali report besar dijalankan, checkout ikut melambat.

Tim memutuskan memakai Strangler Pattern. Pertama, mereka membuat route /reports/* lewat gateway baru, tetapi semua request masih diteruskan ke monolith. Tujuannya bukan langsung mengganti report, melainkan mendapatkan kendali routing dan metric dasar.

Berikutnya, mereka memilih satu report: sales summary harian. Sistem baru membaca event order dan payment, lalu membangun read model khusus untuk reporting (menerapkan pola CQRS). Selama beberapa minggu, sistem baru berjalan dalam shadow mode. Hasil sales summary dari sistem lama dan baru dibandingkan setiap hari. Ketika selisih muncul, tim menemukan beberapa aturan lama yang tidak terdokumentasi, seperti order internal yang harus dikecualikan dari revenue.

Setelah hasil konsisten, report tersebut dibuka untuk tim internal. Gateway mengarahkan user finance tertentu ke sistem baru, sementara user lain tetap memakai monolith. Metric menunjukkan latency turun dan beban database transaksi berkurang. Setelah stabil, traffic report dipindahkan sepenuhnya.

Langkah terakhir adalah membersihkan. Query report lama dihapus, scheduled job yang tidak dipakai dimatikan, dashboard lama diberi label deprecated, dan dokumentasi ownership diperbarui. Inilah bagian yang sering dilupakan, padahal di sinilah modernisasi benar-benar menghasilkan pengurangan kompleksitas.

Contoh Konfigurasi Routing Reverse Proxy

Layer routing tidak selalu memerlukan API gateway yang kompleks. Pada infrastruktur nyata, reverse proxy seperti Nginx sering menjadi pilihan awal tercepat untuk mencegat dan membagi traffic antara monolith dan service baru:

upstream legacy_monolith {
    server 10.0.1.10:8000 max_fails=3 fail_timeout=10s;
    keepalive 32;
}

upstream modern_reporting_service {
    server 10.0.2.20:8080 max_fails=3 fail_timeout=10s;
    keepalive 32;
}

server {
    listen 80;
    server_name api.tokoonline.internal;

    # 1. Capability yang dialihkan ke implementasi baru (Strangler target)
    location /api/v1/reports/ {
        proxy_pass http://modern_reporting_service;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        
        # Timeout agresif agar masalah pada service baru tidak menggantung client
        proxy_connect_timeout 3s;
        proxy_read_timeout 15s;
    }

    # 2. Default: semua endpoint lain tetap masuk ke monolith legacy
    location / {
        proxy_pass http://legacy_monolith;
        proxy_http_version 1.1;
        proxy_set_header Connection "";
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

Contoh Kode: Shadow Mode dan Output Comparison

Jika kamu melakukan routing di level kode (In-App Facade), terapkan pola shadow mode sebelum user nyata diarahkan ke implementasi baru. Request primer tetap dilayani sistem lama, sementara sistem baru dipanggil di background untuk memverifikasi akurasi data:

interface SalesSummaryRequest {
  startDate: string;
  endDate: string;
  storeId: string;
}

interface SalesSummaryReport {
  totalRevenue: number;
  totalOrders: number;
  taxCalculated: number;
}

class ReportingFacade {
  constructor(
    private legacyService: LegacyReportingService,
    private modernService: ModernReportingService,
    private logger: AuditLogger
  ) {}

  async getDailySalesReport(req: SalesSummaryRequest): Promise<SalesSummaryReport> {
    // 1. Eksekusi sistem legacy sebagai source of truth utama
    const legacyResult = await this.legacyService.generateReport(req);

    // 2. Jalankan sistem baru di background (non-blocking / shadow run)
    this.runShadowCheck(req, legacyResult).catch(err => {
      this.logger.warn('Gagal menjalankan shadow check:', err);
    });

    // 3. User tetap menerima hasil terverifikasi dari legacy
    return legacyResult;
  }

  private async runShadowCheck(req: SalesSummaryRequest, expected: SalesSummaryReport) {
    const startTime = performance.now();
    const actual = await this.modernService.generateReport(req);
    const duration = performance.now() - startTime;

    // Evaluasi integritas data
    const isMismatch =
      actual.totalRevenue !== expected.totalRevenue ||
      actual.totalOrders !== expected.totalOrders;

    if (isMismatch) {
      this.logger.error('Mismatch data terdeteksi antara legacy dan sistem baru!', {
        request: req,
        expected,
        actual,
        diff: {
          revenueDelta: actual.totalRevenue - expected.totalRevenue,
          ordersDelta: actual.totalOrders - expected.totalOrders,
        },
      });
    } else {
      this.logger.info('Shadow execution cocok sempurna', { durationMs: duration });
    }
  }
}

Kesalahan Umum Saat Menjalankan Strangler Pattern

Kesalahan pertama adalah membuat sistem baru terlalu besar sebelum menerima traffic nyata. Tim menghabiskan bulan untuk membangun platform baru yang “akan siap untuk semua use case”, tetapi belum satu pun user berpindah. Strangler Pattern bekerja paling baik ketika sistem baru segera melayani capability kecil dan belajar dari traffic aktual.

Kesalahan kedua adalah tidak punya retirement plan. Jika setiap migrasi hanya menambah service baru tanpa mematikan bagian lama, kompleksitas total justru naik. Modernisasi bukan hanya menambah yang baru, tetapi juga mengurangi yang lama.

Kesalahan ketiga adalah meremehkan data consistency. Routing bisa diubah dalam hitungan menit, tetapi memperbaiki data yang berbeda antara dua sistem bisa memakan minggu. Karena itu, reconciliation, audit log, dan ownership data harus dibahas sejak awal.

Kesalahan keempat adalah tidak melibatkan tim operasional dan bisnis. Sistem legacy sering punya proses manual di sekitarnya: export CSV, approval finance, batch upload, atau laporan bulanan. Jika proses ini tidak dipetakan, sistem baru bisa terlihat benar secara teknis tetapi gagal dipakai di dunia nyata.

Kesalahan kelima adalah menganggap Strangler Pattern sebagai alasan untuk membuat microservice sebanyak mungkin. Setiap service baru membawa biaya: deployment, monitoring, on-call, security patch, dan dokumentasi. Buat service baru ketika boundary dan ownership-nya jelas, bukan karena pola migrasi terasa lebih modern.

Checklist Sebelum Sistem Lama Dipensiunkan

Sebelum mematikan capability lama, pastikan tidak ada traffic aktif yang masih masuk ke route legacy. Cek log, gateway metric, consumer group, cron job, batch job, dan integrasi partner. Banyak sistem lama tetap hidup bukan karena user utama memakainya, tetapi karena ada proses kecil yang berjalan sebulan sekali.

Pastikan data sudah direkonsiliasi. Jika sistem baru punya database sendiri, bandingkan record penting, status akhir, total agregat, dan edge case yang pernah bermasalah. Untuk domain sensitif seperti payment atau invoice, minta validasi dari owner bisnis, bukan hanya dari engineer.

Pastikan dokumentasi ownership diperbarui. Siapa yang menjaga capability baru? Dashboard mana yang harus dilihat saat incident? Alert mana yang menggantikan alert lama? Runbook mana yang tidak berlaku lagi? Tanpa jawaban ini, tim on-call akan kebingungan saat masalah pertama muncul.

Terakhir, hapus yang lama secara benar. Matikan route, hapus konfigurasi, archive dashboard, cabut secret yang tidak dipakai, dan bersihkan kode jika aman. Jangan hanya menambahkan komentar “deprecated” lalu membiarkannya bertahun-tahun. Setiap bagian legacy yang tidak dipensiunkan akan menjadi beban kognitif untuk tim berikutnya.

Kesimpulan

Strangler Pattern adalah strategi modernisasi yang pragmatis: pindahkan sistem lama sedikit demi sedikit, sambil menjaga user tetap bisa bekerja. Pola ini membantu tim menghindari risiko big bang rewrite, tetapi tetap membutuhkan disiplin tinggi pada routing, data ownership, observability, rollback, dan retirement.

Mulailah dari capability kecil yang jelas, buat entry point yang bisa mengontrol traffic, jalankan sistem baru berdampingan dengan legacy, lalu pindahkan traffic secara bertahap. Setelah stabil, jangan lupa bagian paling penting: pensiunkan kode lama agar kompleksitas benar-benar turun.

Jika kamu sedang merapikan legacy code di level function dan modul, baca juga panduan refactor legacy code dengan aman. Untuk konteks boundary aplikasi yang lebih luas, Strangler Pattern bisa dipadukan dengan pendekatan seperti Hexagonal Architecture: Ports and Adapters atau transisi menuju Microservices Architecture ketika organisasi dan domain-nya sudah siap.

Lanjutkan membaca topik yang masih satu konteks.

Jangan Ketinggalan Info Terbaru

Dapatkan artikel teknologi, tips, dan insights menarik langsung ke email Kamu.