# Membangun Sistem Resilient dengan Next.js > Praktik terbaik untuk memastikan ketersediaan tinggi dan performa pada aplikasi web modern. > > 2024-08-22 — y7.hk ## Arsitektur Dulu Next.js sering menjadi tulang punggung aplikasi web modern. Memastikan resiliensi membutuhkan campuran keputusan arsitektur yang baik dan tooling yang tepat. Dengan memanfaatkan Server Components dan error boundary yang benar, kamu bisa membangun aplikasi web yang sangat resilient — degrade dengan anggun alih-alih crash total. ### Static Generation vs SSR Bila memungkinkan, default ke Incremental Static Regeneration (ISR). Ini menjamin bahwa meski backend API-mu sedang tidak tersedia, pengguna tetap melihat versi terakhir yang berhasil di-build. Tapi tradeoff-nya nyata: ISR memberimu resiliensi dengan harga kesegaran data. SSR memberimu kesegaran dengan harga ketergantungan keras pada backend. ```tsx // app/blog/[slug]/page.tsx export const revalidate = 300; // 5 menit export default async function Post({ params }) { const post = await fetchPost(params.slug); // cached + revalidated return
; } ``` Ketika origin API-ku down selama 40 menit saat insiden Cloudflare tahun lalu, semua halaman ISR di y7.hk tetap menyajikan HTML yang stale-tapi-valid. Halaman SSR di situs yang sama mengembalikan 500. Eksperimen itu membuatku kehilangan 4% traffic bulanan — dan mengubah selamanya cara kupikir tentang strategi rendering. **Aturan praktis:** ISR untuk konten yang bisa toleran basi 5–60 menit (posting blog, halaman produk, marketing). SSR hanya saat data basi merusak produk (dashboard live, auth state, data real-time). ### Error Boundary adalah Sekat Isolasi Tanpa boundary, satu widget yang gagal menjatuhkan seluruh halaman. Dengan boundary, tiap bagian gagal secara independen. ```tsx // app/components/Section.tsx 'use client'; import { Component, ReactNode } from 'react'; export class Section extends Component< { children: ReactNode; fallback?: ReactNode }, { hasError: boolean } > { state = { hasError: false }; static getDerivedStateFromError() { return { hasError: true }; } render() { if (this.state.hasError) { return this.props.fallback ??
Bagian ini tidak tersedia
; } return this.props.children; } } ``` Bungkus setiap unit independen — widget sidebar, bagian komentar, dashboard analytics — ke boundary-nya masing-masing. Pengguna melihat kotak abu-abu di tempat widget tadi, bukan layar kosong. Aku belajar ini dengan cara keras di dashboard Web3, di mana satu RPC timeout meruntuhkan seluruh portfolio view. Satu boundary di sekitar price ticker bisa menyelamatkan sesi itu. ### Retry Butuh Backoff Retry buta memperbesar kegagalan. Exponential backoff dengan jitter menyebarkan beban dan memberi ruang bagi upstream untuk pulih. ```ts async function fetchWithRetry( fn: () => Promise, attempts = 3, baseDelay = 300 ): Promise { for (let i = 0; i < attempts; i++) { try { return await fn(); } catch (err) { if (i === attempts - 1) throw err; const jitter = Math.random() * baseDelay; await new Promise(r => setTimeout(r, baseDelay * 2 ** i + jitter)); } } throw new Error('unreachable'); } ``` Dua aturan yang kuikuti: 1. **Jangan pernah retry 4xx.** 404 tidak akan jadi 200 saat retry. 2. **Batasi total waktu tunggu.** Kalau pengguna sudah menatap spinner 8+ detik, tampilkan fallback UI dan biarkan mereka lanjut. ### Circuit Breaker Memutus Kegagalan Berantai Retry menyelesaikan error sementara. Circuit breaker menyelesaikan error persisten. Kalau backend sudah gagal 30 detik, berhenti menghajarnya — buka circuit dan sajikan respons degrade segera. ```ts class Breaker { private failures = 0; private openUntil = 0; constructor(private threshold = 5, private cooldown = 30_000) {} async call(fn: () => Promise): Promise { if (Date.now() < this.openUntil) throw new Error('Circuit open'); try { const result = await fn(); this.failures = 0; return result; } catch (e) { if (++this.failures >= this.threshold) { this.openUntil = Date.now() + this.cooldown; } throw e; } } } ``` Tanpa breaker, upstream yang lambat berubah menjadi armada proses Node yang hang. Dengan breaker, kamu dapat kegagalan cepat dan sistem yang pulih begitu upstream kembali. ### Edge Caching dengan stale-while-revalidate Header `Cache-Control` adalah lapisan resiliensi termurah yang kamu punya. `stale-while-revalidate` memungkinkan edge menyajikan salinan cache terakhir sambil mengambil versi segar di background. ``` Cache-Control: public, s-maxage=60, stale-while-revalidate=600 ``` Ini bedanya antara "API down jadi situs down" dan "API down jadi sebagian pengguna melihat data berusia 10 menit". ### Fallback UI sebagai Fitur Fallback bukan sesuatu yang kamu tampilkan saat ada yang rusak — itu bagian dari desain. Setiap bagian async punya tiga state: - **Loading:** skeleton yang cocok dengan layout akhir (tanpa layout shift). - **Success:** konten asli. - **Error:** versi degrade yang tetap memungkinkan pengguna bekerja. Kalau widget harga gagal, jangan tampilkan error merah — tampilkan harga cache terakhir dengan badge kecil "diperbarui 12 menit lalu". Kalau sistem komentar gagal, tampilkan thread read-only dan sembunyikan input box. ### Toleransi Offline Service Worker bukan cuma untuk PWA. SW minimal yang meng-cache app shell dan 5 halaman terakhir memberimu toleransi offline nyata di wifi hotel yang goyah dan penerbangan 10.000 meter — yang kalau kamu seperti saya, adalah persentase browsing yang tidak sepele. ```ts // sw.ts — cache-first untuk static, network-first untuk halaman self.addEventListener('fetch', (e) => { const url = new URL(e.request.url); if (url.pathname.startsWith('/_next/static/')) { e.respondWith(caches.match(e.request).then(r => r ?? fetch(e.request))); } }); ``` ### Kegagalan Nyata yang Pernah Kualami - **Outage Cloudflare edge KV:** setiap halaman yang bergantung pada KV mengembalikan 500. Halaman ISR bertahan. - **Upstream CMS merate-limit aku saat traffic spike.** Tidak ada breaker; Next.js terus menghajar CMS sampai aku kena hard IP ban. Sekarang setiap panggilan eksternal lewat breaker dengan cooldown 30 detik. - **Satu `` meruntuhkan seluruh dashboard** saat WebSocket terputus. Setelah menambahkan boundary, sisa UI tetap hidup sementara ticker diam-diam reconnect. ## Checklist Resiliensi - [ ] ISR/SSG untuk konten yang toleran basi 5+ menit - [ ] `stale-while-revalidate` di setiap route yang bisa di-cache - [ ] Error boundary di sekitar setiap widget independen - [ ] Exponential backoff + jitter pada retry; jangan retry 4xx - [ ] Circuit breaker di setiap panggilan layanan eksternal - [ ] Skeleton + fallback + state error untuk setiap UI async - [ ] Service worker yang meng-cache app shell - [ ] Kill-switch terdokumentasi untuk fitur non-kritis (analytics, rekomendasi) ## Intinya Resiliensi bukan fitur yang dibaut di akhir. Itu adalah arsitekturnya sendiri. Setiap lapisan — rendering, caching, fetching, UI — mendapat failure mode yang dirancang sejak awal. Bangun itu lebih awal, dan insiden yang tadinya bisa jadi outage berubah jadi degrade sunyi yang tidak disadari siapa pun.