Tác giả: Tarique Ejaz
Hiệu suất là một tham số thiết yếu cần xem xét khi bạn thiết kế bất kỳ phần mềm nào. Nó đặc biệt quan trọng khi nói đến những gì xảy ra behind-the-scenes (phía sau màn hình).
Chúng ta, với tư cách là developers và technologists, áp dụng nhiều tweaks và triển khai khác nhau để cải thiện hiệu suất. Đây là nơi caching xuất hiện.
Caching được định nghĩa là cơ chế lưu trữ dữ liệu hoặc files trong vị trí lưu trữ tạm thời từ đó nó có thể được truy cập ngay lập tức khi cần thiết.
Caching đã trở thành must-have trong web applications ngày nay. Chúng ta có thể dùng Redis để supercharge (siêu tăng tốc) web APIs của chúng ta – được xây dựng dùng Node.js và MongoDB.
"Caching rõ ràng vẫn sẽ đóng vai trò siêu quan trọng 100 đến 200 năm sau này."
Redis: Tổng quan cho người bình thường
Redis, theo tài liệu chính thức, được định nghĩa là in-memory data structure store được dùng như database, message broker, hoặc cache storage. Nó hỗ trợ các cấu trúc dữ liệu như strings, hashes, lists, sets, sorted sets với range queries, bitmaps, hyperloglogs, geospatial indexes với radius queries và streams.
Ồ, đó là khá nhiều cấu trúc dữ liệu. Chỉ để đơn giản hóa, hầu như tất cả các cấu trúc dữ liệu được hỗ trợ có thể gộp thành một dạng string hoặc dạng khác. Bạn sẽ rõ hơn khi chúng ta chạy qua triển khai.
Nhưng một điều rõ ràng. Redis mạnh mẽ, và khi dùng đúng cách có thể làm ứng dụng của chúng ta không chỉ nhanh hơn mà còn hiệu quả đến kinh ngạc. Đủ nói. Hãy bám tay vào code.
Hablemos Code (Hãy nói về Code)
Trước khi bắt đầu, bạn sẽ cần cài đặt redis trên hệ thống local của bạn. Bạn có thể làm theo quy trình thiết lập nhanh này để get redis up and running.
Xong? Cool. Hãy bắt đầu. Chúng ta có một ứng dụng đơn giản tạo bằng Express dùng instance trong MongoDB Atlas để đọc và ghi dữ liệu.
Chúng ta có hai major APIs được tạo trong file route /blogs.
...
// GET - Lấy tất cả blog posts cho user cần thiết
blogsRouter.route('/:user')
.get(async (req, res, next) => {
const blogs = await Blog.find({ user: req.params.user });
res.status(200).json({ blogs, });
});
// POST - Tạo blog post mới
blogsRouter.route('/')
.post(async (req, res, next) => {
const existingBlog = await Blog.findOne({ title: req.body.title });
if (!existingBlog) {
let newBlog = new Blog(req.body);
const result = await newBlog.save();
return res.status(200).json({
message: `Blog ${result.id} is successfully created`,
result,
});
}
res.status(200).json({ message: 'Blog with same title exists', });
});
...
Rắc rối một chút Redis Goodness
Chúng ta bắt đầu bằng cách tải npm package redis để kết nối đến local redis server.
const mongoose = require('mongoose');
const redis = require('redis');
const util = require('util');
const redisUrl = 'redis://127.0.0.1:6379';
const client = redis.createClient(redisUrl);
client.hget = util.promisify(client.hget);
...
Chúng ta dùng hàm utils.promisify để biến hàm client.hget trả về promise thay vì callback. Bạn có thể đọc thêm về promisification ở đây.
Kết nối Redis đã sẵn sàng. Trước khi viết thêm caching code, hãy lùi một bước và cố gắng hiểu yêu cầu chúng ta cần đáp ứng và thách thức có thể gặp.
Chiến lược caching của chúng ta nên có thể giải quyết các điểm sau.
- Cache request cho tất cả blog posts của một user cụ thể
Xóa cache mỗi khi blog post mới được tạo
Thách thức có thể gặp khi thực hiện chiến lược:
Cách đúng để handle key creation cho việc lưu cache data
- Cache expiration logic và forced expiration để duy trì cache freshness
- Triển khai caching logic có thể tái sử dụng
Được rồi. Chúng ta đã note các điểm và redis đã kết nối. Tới bước tiếp theo.
Ghi đè Default Mongoose Exec Function
Chúng ta muốn caching logic của mình reusable (tái sử dụng). Và không chỉ reusable, chúng ta cũng muốn nó là checkpoint đầu tiên trước khi làm bất kỳ query nào đến database. Điều này dễ dàng làm được bằng một hack đơn giản piggy-backing onto mongoose exec function.
...
const exec = mongoose.Query.prototype.exec;
...
mongoose.Query.prototype.exec = async function() {
...
const result = await exec.apply(this, arguments);
console.log('Data Source: Database');
return result;
}
...
Chúng ta dùng prototype object của mongoose để thêm caching logic code của chúng ta làm execution đầu tiên trong query.
Thêm Cache như một Query
Để chỉ ra queries nào nên được cache, chúng ta tạo một mongoose query. Chúng ta cung cấp khả năng truyền user để dùng làm hash-key thông qua object options.
Lưu ý: Hashkey đóng vai trò identifier cho hash data structure, nói dễ hiểu, có thể nói là parent key cho một tập hợp key-value pairs. Do đó, cho phép caching số lượng lớn query-value set. Bạn có thể đọc thêm về hashes trong redis ở đây.
...
mongoose.Query.prototype.cache = function(options = {}) {
this.enableCache = true;
this.hashKey = JSON.stringify(options.key || 'default');
return this;
};
...
Đã làm vậy, chúng ta có thể dễ dàng dùng query cache(<options argument>) cùng với queries chúng ta muốn cache theo cách sau.
...
const blogs = await Blog
.find({ user: req.params.user })
.cache({ key: req.params.user });
...
Xây dựng Cache Logic
Chúng ta đã thiết lập common reusable query để chỉ ra queries nào cần cache. Hãy tiến lên và viết central caching logic.
...
mongoose.Query.prototype.exec = async function() {
if (!this.enableCache) {
console.log('Data Source: Database');
return exec.apply(this, arguments);
}
const key = JSON.stringify(Object.assign({}, this.getQuery(), {
collection: this.mongooseCollection.name,
}));
const cachedValue = await client.hget(this.hashKey, key);
if (cachedValue) {
const parsedCache = JSON.parse(cachedValue);
console.log('Data Source: Cache');
return Array.isArray(parsedCache) ? parsedCache.map(doc => new this.model(doc)) : new this.model(parsedCache);
}
const result = await exec.apply(this, arguments);
client.hmset(this.hashKey, key, JSON.stringify(result), 'EX', 300);
console.log('Data Source: Database');
return result;
};
...
Bất cứ khi nào chúng ta dùng query cache() cùng với main query, chúng ta set key enableCache thành true.
Nếu key là false, chúng ta trả về main exec query như mặc định. Nếu không, chúng ta trước tiên hình thành key cho việc fetch và lưu/refresh cache data.
Chúng ta dùng tên collection cùng với default query làm key name cho sự unique. Hash-key dùng là tên user mà chúng ta đã set trước đó trong định nghĩa hàm cache().
Dữ liệu cached được fetch dùng hàm client.hget() yêu cầu hash-key và key kết quả làm tham số.
Lưu ý: Chúng ta luôn dùng JSON.parse() khi fetch bất kỳ dữ liệu nào từ redis. Và tương tự, chúng ta dùng JSON.stringify() trên key và data trước khi lưu bất cứ thứ gì vào redis. Điều này làm vì redis không hỗ trợ JSON data structures.
Khi đã có cached data, chúng ta phải biến đổi mỗi cached object thành mongoose model. Điều này có thể làm đơn giản bằng cách dùng new this.model(<object>).
Nếu cache không chứa dữ liệu cần thiết, chúng ta query database. Sau đó, sau khi trả dữ liệu cho API, chúng ta refresh cache dùng client.hmset(). Chúng ta cũng đặt default cache expiration time 300 giây. Điều này có thể tùy chỉnh dựa trên caching strategy của bạn.
Caching logic đã sẵn sàng. Chúng ta cũng đã đặt default expiration time. Tiếp theo, chúng ta xem forced cache expiration bất cứ khi nào blog post mới được tạo.
Forced Cache Expiration (Buộc Cache Hết hạn)
Trong một số trường hợp, như khi user tạo blog post mới, user mong đợi bài mới nên có sẵn khi họ fetch tất cả posts.
Để làm vậy, chúng ta phải xóa cache liên quan đến user đó và cập nhật với dữ liệu mới. Vì vậy chúng ta phải force expiration. Chúng ta có thể làm điều đó bằng cách invoke hàm del() do redis cung cấp.
...
module.exports = {
clearCache(hashKey) {
console.log('Cache cleaned');
client.del(JSON.stringify(hashKey));
}
}
...
Chúng ta cũng phải nhớ rằng chúng ta sẽ force expiration trên nhiều routes. Một cách extensible là dùng clearCache() này như middleware và gọi nó một khi bất kỳ query liên quan đến route nào đã hoàn thành execution.
const { clearCache } = require('../services/cache');
module.exports = async (req, res, next) => {
// chờ route handler chạy xong
await next();
clearCache(req.body.user);
}
Middleware này có thể dễ dàng gọi trên route cụ thể theo cách sau.
...
blogsRouter.route('/')
.post(cleanCache, async (req, res, next) => {
...
}
...
Và chúng ta xong. Tôi đồng ý đó là khá nhiều code. Nhưng với phần cuối đó, chúng ta đã thiết lập redis với ứng dụng và lo cho hầu như tất cả thách thức có thể. Đã đến lúc xem caching strategy của chúng ta in action.
Redis In Action
Chúng ta dùng Postman làm API client để xem caching strategy của chúng ta in action. Let's go. Hãy chạy qua các API operations, một một.
- Chúng ta tạo blog post mới dùng route
/blogs
Tạo Blog Post Mới
- Chúng ta sau đó fetch tất cả blog posts liên quan đến user
tejaz
Fetch tất cả Blog Posts cho User tejaz
- Chúng ta fetch tất cả blog posts cho user
tejazmột lần nữa.
Fetch all Blog Posts cho User tejaz Once More
Bạn có thể rõ ràng thấy khi chúng ta fetch từ cache, thời gian lấy đã giảm từ 409ms xuống 24ms. Điều này supercharges API của bạn bằng cách giảm thời gian gần 95%.
Thêm vào đó, chúng ta rõ ràng thấy cache expiration và update operations hoạt động như mong đợi.
Bạn có thể tìm complete source code trong folder redis-express ở đây.
Kết luận
Caching là bước bắt buộc cho bất kỳ ứng dụng performance-efficient và data-intensive nào. Redis giúp bạn dễ dàng đạt được điều này trong web applications. Nó là công cụ siêu mạnh, và nếu dùng đúng nó chắc chắn cung cấp trải nghiệm tuyệt vời cho developers cũng như users khắp nơi.
Bạn có thể tìm complete set redis commands ở đây. Bạn có thể dùng nó với redis-cli để monitor cache data và application processes của bạn.
Các khả năng do bất kỳ technology cụ thể nào cung cấp thực sự là vô tận. Nếu bạn có thắc mắc, bạn có thể liên hệ tôi trên [LinkedIn](https://www.linkedin.com/in/tarique-ejaz/).
Trong lúc đó, keep coding.
Học lập trình miễn phí. Chương trình mở của freeCodeCamp đã giúp hơn 40.000 người tìm được việc làm với tư cách là lập trình viên. Bắt đầu ngay hôm nay.