Khi nghe Next.js, suy nghĩ đầu tiên có thể là static websites hoặc React-driven frontends. Nhưng đó mới chỉ một phần câu chuyện. Next.js cũng có thể power full-featured backend APIs mà bạn có thể host và scale như bất kỳ backend service nào khác.
Trong bài trước, tôi walkthrough xây dựng Next.js API và deploy với Sevalla. Ví dụ lưu data trong PostgreSQL database và handle request trực tiếp. Điều đó chạy ổn, nhưng khi traffic tăng, APIs hit database mỗi request có thể chậm lại.
Đây là lúc caching xuất hiện. Bằng cách thêm Redis làm cache layer, chúng ta có thể làm Next.js API nhanh và hiệu quả hơn nhiều. Trong bài này, chúng ta sẽ xem cách thêm Redis caching vào API, deploy với Sevalla, và show cải thiện đo lường được.
Bài trước tôi giải thích API chi tiết. Vì vậy bạn có thể dùng repository này làm base cho project này.
Mục lục
Tại sao Caching quan trọng
Redis là gì?
Thiết lập Project
Provisioning Redis
Cập nhật Cache khi Read
Cập nhật Cache khi Write
Deploy lên Sevalla
Tại sao Redis hợp với Next.js APIs
Kết luận
Tại sao Caching quan trọng
Mỗi lần API hit database, nó tốn thời gian và tài nguyên. Databases giỏi lưu trữ và query structured data, nhưng không tối ưu cho speed at scale khi cần serve hàng nghìn read requests per second.
Caching giải quyết bằng cách giữ frequently accessed data trong memory. Thay vì hỏi database mỗi lần, API có thể trả data trực tiếp từ cache nếu available. Redis hoàn hảo cho việc này vì là in-memory key-value store thiết kế cho performance.
Ví dụ, nếu fetch list users từ database mỗi request, có thể mất 200ms chạy query và trả results. Với Redis caching, request đầu lưu result vào memory, và các request sau trả cùng data trong dưới 10ms. Đó là cải thiện một порядок magnitude.
Redis là gì?
Redis là in-memory data store hoạt động như database siêu nhanh. Thay vì read/write từ disk, nó giữ data trong memory, khiến nó cực nhanh. Đó là lý do nó thường dùng làm cache, nơi speed quan trọng hơn long-term storage.
Nó thiết kế handle high-throughput workloads với very low latency, nghĩa là respond trong microseconds. Làm cho nó perfect fit cho use cases như caching API responses, lưu session data, hoặc thậm chí power real-time applications như chat systems và leaderboards.
Khác với traditional database, Redis focus vào simplicity và speed. Nó lưu data as key-value pairs, nên bạn có thể fetch/update values nhanh mà không viết complex queries. Vì support advanced data types như lists, sets, và hashes, nó linh hoạt hơn plain key-value store.
Kết hợp với API như chúng ta build trong Next.js, Redis giúp giảm load trên main database và deliver blazing-fast responses cho clients.
Thiết lập Project
Clone repository:
git clone git@github.com:manishmshiva/nextjs-api-pgsql.git next-api
Vào directory và npm install packages.
cd next-api
npm i
Tạo file .env thêm database URL từ Sevalla vào env variable.
cat .env
File .env nên trông như sau:
PGSQL_URL=postgres://:-@asia-east1-001.proxy.kinsta.app:30503/
Đảm bảo app chạy như mong đợi bằng cách start app và làm vài API requests.
Start app:
npm run dev
Đảm bảo database connected. Vào localhost:3000 trên browser. Nên trả JSON sau:

Tạo user mới. Dùng Postman gửi POST request với JSON:
{"id":"d9553bb7-2c72-4d92-876b-9c3b40a8c62c","name":"Larry","email":"larry@example.com","age":"25"}

Đảm bảo record tạo bằng cách vào localhost:3000/users trên browser.

Tuyệt. Bây giờ cache APIs này dùng Redis.
Provisioning Redis
Vào Sevalla dashboard click "Databases". Chọn "Redis" từ list, để các option khác default.

Khi database tạo xong, bật "external connection" option và copy publicly accessible URL.

Trong .env trông như sau:
REDIS_URL=redis://default:@:
Cài Redis client cho Node.js:
npm install ioredis
Bây giờ có thể connect Redis và dùng làm cache layer cho users API. Xem cách implement caching.
Cập nhật Cache khi Read
File users/route.ts updated dùng Redis:
import { NextResponse } from "next/server";
import { Client } from "pg";
import Redis from "ioredis";
const redis = new Redis(process.env.REDIS_URL!);
async function readUsers() {
const client = new Client({ connectionString: process.env.PGSQL_URL, });
await client.connect();
try {
const result = await client.query("SELECT id, name, email, age FROM users");
return result.rows;
} finally {
await client.end();
}
}
export async function GET() {
try {
// Check cache first
const cached = await redis.get("users");
if (cached) {
return NextResponse.json(JSON.parse(cached));
}
// Fallback to database if not cached
const users = await readUsers();
// Store result in cache with 60s TTL
await redis.set("users", JSON.stringify(users), "EX", 60);
return NextResponse.json(users);
} catch (err) {
return NextResponse.json({ error: "Failed to fetch users" }, { status: 500 });
}
}
Khi hit /users:
- API check Redis trước.
- Nếu data tồn tại, trả về ngay lập tức.
- Nếu không, query PostgreSQL, lưu result vào Redis, rồi trả về.
Làm repeated requests cực nhanh. Bạn có thể adjust cache expiry (EX 60) tùy theo data cần fresh như nào.
Không có Redis caching, fetch /users mười lần nghĩa là mười database queries. Mỗi cái mất ~150-200ms tùy database size và network latency.
Với Redis, request đầu vẫn ~200ms vì populate cache. Nhưng mọi request sau đó gần instant, thường dưới 10ms. Đó là cải thiện 20x.
Speedup này quan trọng khi API face hundreds hoặc thousands requests per second. Caching không chỉ giảm latency mà cũng nhẹ load trên database.
Cập nhật Cache khi Write
Hiện tại chỉ GET requests dùng cache. Nhưng nếu add users mới? Cache vẫn trả old data.
Giải pháp: update hoặc clear cache khi write xảy ra. Update POST handler:
export async function POST(req: Request) {
try {
const body = await req.json();
const client = new Client({ connectionString: process.env.PGSQL_URL, });
await client.connect();
const query = `
INSERT INTO users (id, name, email, age)
VALUES ($1, $2, $3, $4)
RETURNING *;
`;
const result = await client.query(query, [
body.id, body.name, body.email, body.age,
]);
await client.end();
// Invalidate cache so next GET fetches fresh data
await redis.del("users");
return NextResponse.json(result.rows[0]);
} catch (err) {
return NextResponse.json({ error: "Failed to add user" }, { status: 500 });
}
}
Bây giờ khi user mới tạo, cache cho users bị clear. GET request tiếp theo sẽ fetch từ database, refresh cache, rồi tiếp tục serve cached data.
Deploy lên Sevalla
Push code lên GitHub hoặc fork repository của tôi. Vào Sevalla tạo app mới.

Chọn repository từ dropdown và check "Automatic deployment on commit". Đảm bảo deploy tự động mỗi khi push code. Chọn "Hobby" dưới resources section.

Click "Create" không phải "Create and deploy". Chưa thêm PostgreSQL URL và Redis URL làm env variables, nên app sẽ crash nếu deploy ngay.
Vào section "Environment variables" thêm key "PGSQL_URL" và URL trong value. Làm tương tự cho "REDIS_URL" key và Redis URL.

Quay lại section "Overview" click "Deploy now".

Khi deployment xong, click "Visit app" lấy live URL API. Thay localhost:3000 bằng URL mới trong Postman test API.
Tại sao Redis hợp với Next.js APIs
Redis nhẹ, blazing fast, perfect cho caching API responses. Trong context Next.js, nó fit tự nhiên vì:
- API routes chạy server-side nơi Redis có thể query trực tiếp.
- Caching logic đơn giản thêm quanh database calls.
- Redis dùng được hơn caching – rate limiting, session storage, pub/sub cũng common patterns.
Kết hợp Next.js, PostgreSQL, và Redis trên Sevalla, bạn có stack nhanh, scalable, dễ deploy.
Kết luận
Caching không chỉ optimization – nó necessity cho real-world APIs. Next.js giúp build robust backend APIs deploy dễ dàng. Bằng cách thêm Redis vào mix, những APIs đó handle scale không breaking a sweat.
Sevalla gói gọn mọi thứ bằng cách cung cấp managed PostgreSQL, Redis, và app hosting ở một chỗ. Vài env variables và GitHub repo, bạn từ local dev đến production-ready, cached API trong vài phút.
Hy vọng bạn thích bài này. Đăng ký newsletter AI miễn phí của tôi TuringTalks.ai cho thêm hands-on tutorials về AI. Cũng tìm tôi trên Linkedin.
Học code miễn phí. Chương trình open source freeCodeCamp đã giúp hơn 40.000 người có việc developer. Bắt đầu ngay