# Xây dựng hệ thống resilient với Next.js
> Best practices để đảm bảo tính sẵn sàng cao và hiệu năng trong các ứng dụng web hiện đại.
>
> 2024-08-22 — y7.hk
## Kiến trúc trước
Next.js thường đóng vai trò xương sống của các ứng dụng web hiện đại. Đảm bảo resilience đòi hỏi sự kết hợp giữa quyết định kiến trúc tốt và công cụ đúng đắn.
Bằng cách tận dụng Server Components và error boundary đúng cách, bạn có thể xây dựng các ứng dụng web cực kỳ resilient — degrade một cách duyên dáng thay vì crash toàn bộ.
### Static Generation vs SSR
Bất cứ khi nào có thể, mặc định dùng Incremental Static Regeneration (ISR). Điều này đảm bảo rằng ngay cả khi backend API tạm thời chết, người dùng vẫn thấy phiên bản build thành công gần nhất của trang.
Nhưng trade-off là thật: ISR cho bạn resilience với cái giá là độ tươi dữ liệu. SSR cho bạn độ tươi với cái giá là phụ thuộc cứng vào backend.
```tsx
// app/blog/[slug]/page.tsx
export const revalidate = 300; // 5 phút
export default async function Post({ params }) {
const post = await fetchPost(params.slug); // cache + revalidate
return ;
}
```
Khi origin API của tôi down 40 phút trong một sự cố Cloudflare năm ngoái, mọi trang ISR trên y7.hk vẫn phục vụ HTML cũ-nhưng-hợp-lệ. Các trang SSR của cùng site trả về 500. Thí nghiệm đó tốn của tôi 4% traffic tháng — và thay đổi vĩnh viễn cách tôi nghĩ về chiến lược render.
**Quy tắc ngón tay cái:** ISR cho bất cứ thứ gì chịu được 5–60 phút cũ (bài blog, trang sản phẩm, marketing). Chỉ SSR khi dữ liệu cũ phá vỡ sản phẩm (dashboard live, auth state, dữ liệu real-time).
### Error Boundary là vách ngăn
Không có boundary, một widget hỏng kéo cả trang xuống. Có boundary, mỗi phần fail độc lập.
```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 ??
Phần này tạm không khả dụng
;
}
return this.props.children;
}
}
```
Bọc mỗi đơn vị độc lập — sidebar widget, phần comment, dashboard analytics — trong boundary riêng. Người dùng thấy một ô xám chỗ widget từng ở, không phải màn hình trắng.
Tôi học được điều này theo cách khó khăn trên một Web3 dashboard, nơi một RPC timeout duy nhất làm crash toàn bộ portfolio view. Một boundary quanh price ticker đã có thể cứu session đó.
### Retry cần backoff
Retry mù quáng khuếch đại lỗi. Exponential backoff với jitter phân tán tải và cho upstream thời gian phục hồi.
```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');
}
```
Hai quy tắc tôi tuân theo:
1. **Không bao giờ retry 4xx.** 404 sẽ không thành 200 khi retry.
2. **Giới hạn tổng thời gian chờ.** Nếu người dùng đã nhìn spinner 8+ giây, hiển thị fallback UI và để họ tiếp tục.
### Circuit Breaker chặn lỗi dây chuyền
Retry giải quyết lỗi nhất thời. Circuit breaker giải quyết lỗi dai dẳng. Nếu backend đã fail 30 giây, đừng đập nó nữa — mở circuit và trả response degrade ngay.
```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;
}
}
}
```
Không có breaker, một upstream chậm biến thành một đội Node process bị treo. Có breaker, bạn được fail nhanh và một hệ thống phục hồi ngay khi upstream quay lại.
### Edge caching với stale-while-revalidate
Header `Cache-Control` là lớp resilience rẻ nhất bạn có. `stale-while-revalidate` cho phép edge phục vụ bản cache cuối cùng trong khi fetch bản mới ở background.
```
Cache-Control: public, s-maxage=60, stale-while-revalidate=600
```
Đây là khác biệt giữa "API chết nên site chết" và "API chết nên một số người dùng thấy dữ liệu cũ tới 10 phút".
### Fallback UI là một tính năng
Fallback không phải thứ bạn hiển thị khi mọi thứ hỏng — nó là một phần của thiết kế. Mỗi phần async có ba trạng thái:
- **Loading:** skeleton khớp với layout cuối (không layout shift).
- **Success:** nội dung thật.
- **Error:** phiên bản degrade vẫn cho phép người dùng làm việc.
Nếu widget giá fail, đừng hiển thị lỗi đỏ — hiển thị giá cache gần nhất với badge nhỏ "cập nhật 12 phút trước". Nếu hệ thống comment fail, hiển thị thread read-only và ẩn input box.
### Khả năng offline
Service Worker không chỉ dành cho PWA. Một SW tối thiểu cache app shell và 5 trang vừa visit mang lại khả năng offline thật sự trên wifi khách sạn chập chờn và ở độ cao 10.000 mét — mà nếu bạn là tôi, đó là một phần không nhỏ thời gian duyệt web.
```ts
// sw.ts — cache-first cho static, network-first cho trang
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)));
}
});
```
### Những sự cố thật tôi gặp
- **Sự cố Cloudflare edge KV:** mọi trang phụ thuộc KV trả về 500. Trang ISR sống sót.
- **Upstream CMS rate-limit tôi giữa đợt spike traffic.** Không có breaker; Next.js đập CMS đến khi bị hard IP ban. Giờ mọi external call đều qua breaker với cooldown 30s.
- **Một `` duy nhất làm crash toàn bộ dashboard** khi WebSocket rớt. Sau khi thêm boundary, phần còn lại của UI vẫn sống trong khi ticker âm thầm reconnect.
## Checklist resilience
- [ ] ISR/SSG cho nội dung chịu được 5+ phút cũ
- [ ] `stale-while-revalidate` trên mọi route cache được
- [ ] Error boundary quanh mọi widget độc lập
- [ ] Exponential backoff + jitter cho retry; không retry 4xx
- [ ] Circuit breaker trên mọi external service call
- [ ] Skeleton + fallback + error state cho mọi async UI
- [ ] Service worker cache app shell
- [ ] Kill-switch có tài liệu cho tính năng không quan trọng (analytics, gợi ý)
## Điểm cốt lõi
Resilience không phải tính năng gắn thêm cuối dự án. Nó chính là kiến trúc. Mỗi lớp — rendering, caching, fetching, UI — đều cần failure mode được thiết kế từ đầu. Xây sớm, và những incident đáng lẽ là outage sẽ trở thành sự degrade âm thầm mà không ai nhận ra.