Trong bài viết này, chúng ta sẽ xây dựng một dịch vụ REST API xác thực tối thiểu nhưng đầy đủ chức năng, tận dụng Next.js API Routes và Upstash Redis, sẽ dùng như một hệ thống lưu trữ/cache siêu nhanh cho dữ liệu, xác thực người dùng, và xử lý JWT. Lưu ý dự án này không có frontend, chỉ expose API có thể query bằng nhiều client.
Yêu cầu trước
Để theo dõi hướng dẫn, bạn cần:
- Tài khoản Upstash — Đăng ký miễn phí tại đây
- Kiến thức cơ bản về Redis
- Kiến thức cơ bản về Next.js API Routes
- Kiến thức cơ bản về quy trình xác thực và ủy quyền
- Công cụ tùy chọn để tạo HTTP request
Upstash Redis là gì
Upstash là một cơ sở dữ liệu in-memory serverless trên đám mây dựa trên Redis. Chúng ta sẽ dùng nó để lưu dữ liệu phục vụ API, cũng như lưu user base và user tokens.
Chúng ta sẽ xây dựng gì
Chúng ta sẽ code một dịch vụ REST API cho phép client app request dữ liệu (trong trường hợp này là danh sách phim); bảo vệ endpoint bằng JWT, code service login để lấy token, và triển khai quy trình refresh token.
Chúng ta KHÔNG tập trung vào phát triển client (vì xây dựng dịch vụ 'không quan điểm'), nhưng sẽ cung cấp spec dịch vụ để ai cũng có thể xây client cho nó.
Repository và Demo
Để theo dõi, bạn có thể clone repository dự án
Source trên GitHub
Bạn cũng có thể thử demo tại URL sau:
https://upstash-dwov9jbiq-popland.vercel.app/api/auth/signin
Để kết nối dịch vụ, tạo POST HTTP Request truyền username (me@home.org) và password (password) như ví dụ sau (dùng Postman):
Thiết lập Database Redis
Trước hết, đăng ký Upstash Redis (free plan đủ test), đăng nhập console, tạo database mới:
Click "Create database", đặt tên MovieManager, set Global. Thêm dữ liệu giả dùng Upstash CLI
Thêm một số phim làm Redis hash (cơ bản là object) dùng lệnh HMSET:
hmset movie:'Dr. Strangelove' director 'Stanley Kubrick' year 1964
hmset movie:'2001: A Space Odyssey' director 'Stanley Kubrick' year 1968
hmset movie:'Pulp Fiction' director 'Quentin Tarantino' year 1994
hmset movie:'Django Unchained' director 'Quentin Tarantino' year 2012
Thêm user được phép truy cập dữ liệu, user cũng là Redis hash:
hmset user:'me@home.org' password $2b$10$zctxUVDyy3jzvSp68oKpMOnkyra4R.NzOFVh9aii3Y43X7XtetoyK level 0
Lưu ý: Mật khẩu được mã hóa bằng bcrypt (plaintext là password), thường user đăng ký qua website, ở ví dụ này không cung cấp endpoint register
Mọi lệnh nhập Upstash CLI đều trả OK, nếu đúng và vào Data Browser chọn Hash, sẽ thấy danh sách data đã insert
Quy trình Authorization
Như đã nói, endpoint không công khai, cần cách xác thực và ủy quyền. Cho xác thực cung cấp endpoint login; cho ủy quyền, endpoint bảo vệ yêu cầu Authorization Header gửi kèm request. Chi tiết quy trình:
- User request endpoint sign-in, post username và password
- Server thử xác thực user, nếu hợp lệ tạo và trả về JWT (JSON Web Token) và Refresh Token, Refresh Token cũng lưu trên Upstash Redis instance
- Client nhận token, lưu trữ ở đâu đó (trách nhiệm client)
- Client request endpoint bảo vệ, gửi JWT trong Header
- Server nhận JWT, verify, nếu pass trả về data client yêu cầu
- Khi JWT hết hạn hoặc sắp hết hạn, client có thể request JWT mới không cần re-login, bằng cách gửi Refresh Token đến endpoint cụ thể
- Server nhận Refresh Token, verify, nếu pass cấp JWT mới và Refresh Token mới, gửi về client, và lưu Refresh Token mới lại
JWT và Refresh Token cùng format, thông tin gần giống nhưng dùng hai key khác nhau (setup trong .env) và hai expiration khác nhau: JWT ngắn (vì token dùng nhiều nhất trong session, làm hết hạn sớm nếu bị chặn) và Refresh Token dài. Thời gian phụ thuộc mức độ bảo mật; thường JWT hết hạn dưới 1 giờ, Refresh Token có thể kéo dài 1 tháng. Nếu cả hai hết hạn, user phải login lại.
Thiết lập dự án
Xong Redis database, bắt đầu init dự án; trước hết tạo Next.js project mới:
npx create-next-app upstash-jwt
Vào thư mục upstash-jwt mới tạo và cài modules cần thiết:
npm i bcrypt jsonwebtoken @upstash/redis
Tạo file .env.local lưu keys và điền đúng data
SECRET_TOKEN=
SECRET_RTOKEN=
UPSTASH_REDIS_REST_URL=
UPSTASH_REDIS_REST_TOKEN=
Tạo SECRET_TOKEN và SECRET_RTOKEN dùng để generate JWT, nhớ giữ bí mật và rất random/khó đoán, có thể dùng chuỗi 64bit hex. Lấy UPSTASH_REDIS_REST_URL và UPSTASH_REDIS_REST_TOKEN từ Upstash Console, tab Details, phần Rest API:
Bây giờ layout endpoints:
POST /auth/signin Login user, cần email và password truyền JSON object {"email":"email", "password": "password"}, trả JSON object với info user, JWT, Refresh Token.
GET /movies/ Trả danh sách phim JSON, yêu cầu JWT hợp lệ truyền trong header format: Authorization: Bearer xxx
GET /movies/$ID Trả chi tiết phim với id $ID
POST /auth/refresh Tạo và trả JWT mới, Refresh Token truyền qua param refreshToken.
Code cho API routes
Bắt đầu endpoint sign in, tạo file pages/api/auth/signin.js như sau:
import bcrypt from "bcrypt";
import { addToList, generateAccessToken, generateRefreshToken, redis, } from "../../../utils";
export default async (req, res) => {
if (req.method === "GET") {
res.status(405).send("Not Allowed");
} else {
console.log(req.body.user);
try {
const user = await redis.hgetall(`user:${req.body.user}`);
if (user) {
const validPassword = bcrypt.compare(req.body.password, user.password);
if (validPassword) {
const token = generateAccessToken(req.body.user, user.level);
const refreshToken = generateRefreshToken(req.body.user, user.level);
const refresh = await addToList(req.body.user, refreshToken);
const content = { user: req.body.user, level: user.level, };
res.status(200).json({ message: "Logged in", content: content, JWT: token, refresh: refreshToken, });
} else {
res.status(400).json({ error: "Invalid Password" });
}
} else {
res.status(401).json({ error: "User not found" });
}
} catch (error) {
res.status(500).send("Internal Server Error");
}
}
};
Endpoint sign-in chỉ chấp nhận POST với hai param: user và password. Trước hết check user có trong Redis không:
const user = await redis.hgetall(`user:${req.body.user}`);
Nếu user tồn tại, so sánh password mã hóa:
const validPassword = bcrypt.compare(req.body.password, user.password);
Nếu password khớp, coi như user authenticated, gửi về JWT và refresh Token, cũng lưu refresh token trong Redis instance. Dùng các function trong file external utils.js
Trách nhiệm client lưu token trả về, dùng cho authorization khi cần, refresh khi hết hạn
Có function generate Access Token generateAccessToken, generate Refresh Token generateRefreshToken, và lưu refresh Token trong Redis addToList. File utils.js này cũng chứa các utility function và reference khác (như kết nối Redis, verify token, refresh, v.v.):
import { Redis } from "@upstash/redis";
import jwt from "jsonwebtoken";
export const redis = new Redis({
url: process.env.UPSTASH_REDIS_REST_URL,
token: process.env.UPSTASH_REDIS_REST_TOKEN,
});
export function generateAccessToken(username, email, level) {
return jwt.sign(
{ user: username, email: email, level: level },
process.env.SECRET_TOKEN,
{ expiresIn: "1h", },
);
}
export function generateRefreshToken(username, email, level) {
return jwt.sign(
{ user: username, email: email, level: level },
process.env.SECRET_RTOKEN,
{ expiresIn: "30d", },
);
}
export async function addToList(user, refresher) {
try {
await redis.hset("refresh:" + user, { refresh: refresher });
} catch (error) {
console.log(error);
}
}
export async function tokenRefresh(refreshtoken, res) {
var decoded = "";
try {
decoded = jwt.verify(refreshtoken, process.env.SECRET_RTOKEN);
} catch (error) {
return res.status(401).send("Can't refresh. Invalid Token");
}
if (decoded) {
try {
const rtoken = await redis.hget("refresh:" + decoded.user, "refresh");
console.log(rtoken);
if (rtoken !== refreshtoken) {
return res.status(401).send("Can't refresh. Invalid Token");
} else {
const user = await redis.hgetall(`user:${decoded.user}`);
console.log(user);
const token = generateAccessToken(decoded.user, user.level);
const refreshToken = generateRefreshToken(decoded.user, user.level);
const refresh = await addToList(decoded.user, refreshToken);
const content = { user: decoded.user, level: user.level, };
return { message: "Token Refreshed", content: content, JWT: token, refresh: refreshToken, };
}
} catch (error) {
console.log(error);
}
}
}
export async function verifyToken(token, res) {
try {
const decoded = jwt.verify(token, process.env.SECRET_TOKEN);
return decoded;
} catch (err) {
return res.status(405).send("Token is invalid");
}
}
Bây giờ dùng tool (như Postman) test sign-in, POST đến https://localhost:3000/api/auth/signin truyền username (me@home.org) và password (password), nhận JSON object chứa user details kèm JWT và Refresh Token:
Nếu đúng, trong Redis database sẽ thấy Hash entry mới cho Refresh Token vừa tạo:
Tiếp theo, hoàn thiện authentication bằng route refresh token refresh.js
import { redis, tokenRefresh } from "../../../utils";
export default async (req, res) => {
if (req.method === "GET") {
res.status(405).send("Not Allowed");
} else {
console.log(req.body.refresh);
const refresp = await tokenRefresh(req.body.refresh, res);
res.status(200).json(refresp);
}
};
Dùng function tokenRefresh từ utils.js, verify token valid và decode được, check Redis xem user có refresh token (đã lưu trước bằng addToList), nếu đúng generate JWT mới, refresh Token mới (và lưu lại Redis) gửi về client.
Test endpoint này dùng tool, POST đến https://localhost:3000/api/auth/refresh truyền refresh Token param:
Bây giờ client giả định có thể login và refresh token, xem cách token dùng để request có xác thực.
Tạo API route mới: api/movies/[[...id]].js dùng để lấy danh sách phim và chi tiết phim:
import { redis, verifyToken } from "../../../utils";
export default async (req, res) => {
var id;
console.log(req.query);
if (req.query.id) {
id = req.query.id[0];
}
var decoded = "";
const authHeader = req.headers["authorization"];
const token = authHeader && authHeader.split(" ")[1];
if (!token) {
return res.status(403).send("A token is required for authentication");
} else {
decoded = await verifyToken(token, res);
}
if (decoded) {
if (id) {
try {
const result = await redis.hgetall(id);
console.log(result);
return res.status(200).json(result);
} catch (error) {
return res.status(500).send("Internal Server Error");
}
} else {
try {
const result = await redis.scan(0, { match: "movie:*" });
return res.status(200).json(result);
} catch (error) {
return res.status(500).send("Internal Server Error");
}
}
}
};
Dùng function verifyToken từ utils.js giới hạn truy cập API endpoint chỉ cho user cung cấp Token hợp lệ. Làm vài sample query, đầu tiên lấy danh sách phim
const result = await redis.scan(0, { match: 'movie:*' });
Thứ hai lấy chi tiết một phim, dựa trên id param trong URL request:
const result = await redis.hgetall(id);
Cả hai request phụ thuộc user status check qua verifyToken nhưng bạn có thể mix, ví dụ list public, detail bảo vệ. Vì cũng có level lưu trong user (và token) nên có thể có nhiều cấp authorization. Thử lấy danh sách phim:
Và chi tiết một phim:
Góc nhìn Client
Như đã nói, chúng ta chỉ tập trung phần server, đây là scope chính của API, nó nên trừu tượng, không phải website. Cách client request data (ngôn ngữ, thư viện, v.v.) là lựa chọn của client developer, chúng ta cung cấp danh sách endpoint, những gì endpoint expect, và endpoint trả về. Việc handle data, refresh delay, v.v. là chiến lược của client.
Tiếp theo là gì
Đây chỉ là ví dụ cơ bản workflow API bảo vệ. Từ đây chỉ cải thiện: tối ưu lưu data trên Redis, cải thiện bảo mật login bằng cách lưu user data trên Redis instance khác, check và validate data user gửi trước hết, thêm endpoint, trả data dạng GraphQL, build client cho API, giới hạn số call tối đa mỗi giờ, dùng level để giới hạn truy cập... mở rộng và cải tiến vô tận!