FG
🗄️ Databases

Read from slaves with replication

Freshabout 21 hours ago
Mar 14, 20260 views
Confidence Score55%
55%

Problem

Hi, I'm planning to use ioredis with redis-connect for a distributed express application with consistent sessions. My doubt, after reading the docs, I've assumed the following: - Clustering is not needed for session storage, the data won't be enough big. - The majority of the operations will be reads in order to transform cookies into a req.session. having the following nodes: - Node `A` master (with a known ip). - Node `B` slave (replica) of `A` (localhost). - Node `C` slave (replica) of `A` (other node, unknown ip). I can not perform write operations to `B`, even if I set `slave-read-only` to `no`, the updates won't propagate, I need to write to `A`, so... [code block] The ideal behavior would be, I am node `B`, I open a session, so I go `A` and set it, then the client comes in again, and I have to identify the cookie, so I read from `B` (localhost). Is this possible?

Unverified for your environment

Select your OS to check compatibility.

1 Fix

Canonical Fix
Unverified Fix
New Fix – Awaiting Verification

Configure Redis Read from Slaves for Session Management

Medium Risk

Redis slaves are designed to replicate data from the master and are read-only by default. This means that while you can read from the slaves, any write operations must be directed to the master. Since your application requires reading session data from a slave node, you need to ensure that your Redis client is configured to read from the slave nodes effectively while maintaining session consistency.

Awaiting Verification

Be the first to verify this fix

  1. 1

    Configure ioredis for Read from Slaves

    Set up the ioredis client to read from the slave nodes. You can use the `readOnly` option to specify that reads should be directed to the slave nodes.

    javascript
    const Redis = require('ioredis');
const redis = new Redis({
  host: 'A_IP_ADDRESS', // Master node
  port: 6379,
  sentinel: [
    { host: 'B_IP_ADDRESS', port: 26379 }, // Slave node B
    { host: 'C_IP_ADDRESS', port: 26379 }  // Slave node C
  ],
  role: 'slave'
});
  2. 2

    Implement Session Management Logic

    When a user opens a session, write the session data to the master node. When retrieving session data, read from the slave node to minimize latency.

    javascript
    app.use((req, res, next) => {
  const sessionId = req.cookies.sessionId;
  if (sessionId) {
    redis.get(sessionId, (err, sessionData) => {
      if (err) return next(err);
      req.session = JSON.parse(sessionData);
      next();
    });
  } else {
    next();
  }
});
  3. 3

    Handle Session Expiry and Updates

    Ensure that session data is updated on the master node when changes occur. This will keep the slave nodes in sync for read operations.

    javascript
    app.post('/update-session', (req, res) => {
  const sessionId = req.cookies.sessionId;
  const updatedData = req.body;
  redis.set(sessionId, JSON.stringify(updatedData), 'EX', 3600); // Set with expiry
  res.send('Session updated');
});
  4. 4

    Test Read and Write Operations

    Perform tests to ensure that session data can be written to the master and read from the slave without issues. Check for consistency in session data across nodes.

    javascript
    redis.get('test_session_id', (err, data) => {
  console.log('Session Data:', data);
});

Validation

Confirm that session data can be written to the master and read from the slave without errors. Test with multiple clients to ensure that session consistency is maintained across different nodes.

Sign in to verify this fix

Environment

Submitted by

AC

Alex Chen

2450 rep

Tags

redisiorediscache