How do you implement a distributed lock with Redis?

Question

Accepted Answer

**Distributed lock** — prevent concurrent access across multiple servers.

```javascript
const Redis = require("ioredis");
const { v4: uuidv4 } = require("uuid");

class DistributedLock {
    constructor(redis) {
        this.redis = redis;
    }

async acquire(key, ttlMs = 10000) {
        const value = uuidv4();
        const acquired = await this.redis.set(
            `lock:${key}`,
            value,
            "PX",
            ttlMs,
            "NX"
        );
        return acquired ? value : null;
    }

async release(key, value) {
        const script = `
            if redis.call("get", KEYS[1]) == ARGV[1] then
                return redis.call("del", KEYS[1])
            else
                return 0
            end
        `;
        return this.redis.eval(script, 1, `lock:${key}`, value);
    }

async withLock(key, fn, ttlMs = 10000) {
        const lockValue = await this.acquire(key, ttlMs);
        if (!lockValue) throw new Error("Could not acquire lock");

try {
            return await fn();
        } finally {
            await this.release(key, lockValue);
        }
    }
}

// Usage
const lock = new DistributedLock(redis);

await lock.withLock("order:123", async () => {
    // Only one server processes this at a time
    const order = await db.getOrder(123);
    await processPayment(order);
});
```

Node.js: How do you implement a distributed lock with Redis?