Computer >> Hướng Dẫn Máy Tính >  >> Lập Trình >> Redis

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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):

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

Click "Create database", đặt tên MovieManager, set Global. Thêm dữ liệu giả dùng Upstash CLI

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

Nếu đúng, trong Redis database sẽ thấy Hash entry mới cho Refresh Token vừa tạo:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

Và chi tiết một phim:

Xây dựng API Xác thực An toàn, Nhanh với Next.js Routes & Upstash Redis

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!