สร้าง URL Shortener ประสิทธิภาพสูงด้วย Node.js และ Redis Distributed Caching

สร้างไฟล์ .env ใน project root:

PORT=3000
REDIS_HOST_1=localhost
REDIS_PORT_1=6379
REDIS_HOST_2=localhost
REDIS_PORT_2=6380
REDIS_HOST_3=localhost
REDIS_PORT_3=6381

ตัวแปรเหล่านี้กำหนด Redis hosts และ ports ที่เราจะใช้

Step 2: Setting Up Redis Instances

เราใช้ Docker จำลอง distributed environment ด้วย multiple Redis instances

รันคำสั่งต่อไปนี้เพื่อเริ่มสาม Redis containers:

docker run -p 6379:6379 --name redis1 -d redis
docker run -p 6380:6379 --name redis2 -d redis
docker run -p 6381:6379 --name redis3 -d redis

จะตั้งค่าสาม Redis instances รันบน ports ต่างกัน เราจะใช้ instances นี้ implement consistent hashing และ sharding

Step 3: Implementing the URL Shortener Service

สร้าง main application file index.js:

require('dotenv').config();
const express = require('express');
const redis = require('redis');
const shortid = require('shortid');
const app = express();
app.use(express.json());
const redisClients = [
    redis.createClient({ host: process.env.REDIS_HOST_1, port: process.env.REDIS_PORT_1 }),
    redis.createClient({ host: process.env.REDIS_HOST_2, port: process.env.REDIS_PORT_2 }),
    redis.createClient({ host: process.env.REDIS_HOST_3, port: process.env.REDIS_PORT_3 })
];
// Hash function แจกแจง keys ระหว่าง Redis clients
function getRedisClient(key) {
    const hash = key.split('').reduce((acc, char) => acc + char.charCodeAt(0), 0);
    return redisClients[hash % redisClients.length];
}
// Endpoint shorten URL
app.post('/shorten', async (req, res) => {
    const { url } = req.body;
    if (!url) return res.status(400).send('URL is required');
    const shortId = shortid.generate();
    const redisClient = getRedisClient(shortId);
    await redisClient.set(shortId, url);
    res.json({ shortUrl: `https://localhost:${process.env.PORT}/${shortId}` });
});
// Endpoint retrieve original URL
app.get('/:shortId', async (req, res) => {
    const { shortId } = req.params;
    const redisClient = getRedisClient(shortId);
    redisClient.get(shortId, (err, url) => {
        if (err || !url) {
            return res.status(404).send('URL not found');
        }
        res.redirect(url);
    });
});
app.listen(process.env.PORT, () => {
    console.log(`Server running on port ${process.env.PORT}`);
});

ในโค้ดนี้ เรามี:

1. Consistent Hashing:

   • เราแจกแจง keys (shortened URLs) ข้าม multiple Redis clients ด้วย hash function เรียบง่าย
   • Hash function รับรองว่า URLs แจกแจงอย่างสม่ำเสมอข้าม Redis instances

2. URL Shortening:

   • Endpoint /shorten รับ long URL สร้าง short ID ด้วย library shortid
   • Shortened URL เก็บในหนึ่งใน Redis instances ผ่าน hash function ของเรา

3. URL Redirection:

   • Endpoint /:shortId ดึง original URL จาก cache และ redirect user
   • หา URL ไม่เจอใน cache ส่งคืน response 404

Step 4: Implementing Cache Invalidation

ใน real-world application URLs อาจหมดอายุหรือเปลี่ยนแปลงตามเวลา เพื่อจัดการนี้ เราต้อง implement cache invalidation

เพิ่ม Expiry ให้ Cached URLs

แก้ไข index.js ให้ตั้ง expiration time สำหรับแต่ละ cached entry:

// Endpoint shorten URL พร้อม expiration
app.post('/shorten', async (req, res) => {
    const { url, ttl } = req.body; // ttl (time-to-live) เป็น optional
    if (!url) return res.status(400).send('URL is required');
    const shortId = shortid.generate();
    const redisClient = getRedisClient(shortId);
    await redisClient.set(shortId, url, 'EX', ttl || 3600); // Default TTL 1 ชั่วโมง
    res.json({ shortUrl: `https://localhost:${process.env.PORT}/${shortId}` });
});

• TTL (Time-To-Live): เราตั้ง default expiration time 1 ชั่วโมง สำหรับ shortened URL ทุกอัน คุณ customize TTL ต่อ URL ได้หากต้องการ

• Cache Invalidation: เมื่อ TTL หมดอายุ entry จะถูกลบออกจาก cache อัตโนมัติ

Step 5: Monitoring Cache Metrics

เพื่อ monitor cache hits และ misses เราเพิ่ม logging ใน endpoints ใน index.js:

app.get('/:shortId', async (req, res) => {
    const { shortId } = req.params;
    const redisClient = getRedisClient(shortId);
    redisClient.get(shortId, (err, url) => {
        if (err || !url) {
            console.log(`Cache miss for key: ${shortId}`);
            return res.status(404).send('URL not found');
        }
        console.log(`Cache hit for key: ${shortId}`);
        res.redirect(url);
    });
});

โค้ดนี้ทำอะไร:

• Cache Hits: หากเจอ URL ใน cache คือ cache hit

• Cache Misses: หา URL ไม่เจอ คือ cache miss

• Logging นี้ช่วย monitor performance ของ distributed cache ของคุณ

Step 6: Testing the Application

1. Start Redis instances:

docker start redis1 redis2 redis3

2. Run Node.js server:

node index.js

3. Test endpoints ด้วย curl หรือ Postman:

   • Shorten a URL:

     POST https://localhost:3000/shorten
     Body: { "url": "https://example.com" }

   • Access the shortened URL:

     GET https://localhost:3000/{shortId}

Conclusion: What You've Learned

ยินดีด้วย! คุณสร้าง URL shortener service ที่ scalable พร้อม distributed caching ด้วย Node.js และ Redis เรียบร้อยแล้ว ตลอด tutorial นี้ คุณได้เรียนรู้ว่า:

1. Implement consistent hashing แจกแจง cache entries ข้าม multiple Redis instances
2. Optimize application ด้วย cache invalidation strategies เก็บข้อมูล up-to-date
3. ใช้ Docker จำลอง distributed environment ด้วย multiple Redis nodes
4. Monitor cache hits and misses เพื่อ optimize performance

Next Steps:

• Add a Database: เก็บ URLs ใน database เพื่อ persistence นอกเหนือจาก cache

• Implement Analytics: Track click counts และ analytics สำหรับ shortened URLs

• Deploy to the Cloud: ปรับใช้แอปพลิเคชันด้วย Kubernetes สำหรับ auto-scaling และ resilience

Happy coding!

Learn to code for free. freeCodeCamp's open source curriculum has helped more than 40,000 people get jobs as developers. Get started