Azure Cache for Redis idling and reconnecting even when I have a ping setup to wake it up

Question

I have a NodeJS app running in Azure Container Apps that uses Azure Cache for Redis. This connection gets interrupted every 10 minutes and the application has to reconnect. I have a ping setup as per this article in the documentation https://learn.microsoft.com/en-us/azure/azure-cache-for-redis/cache-best-practices-connection#idle-timeout .

When using monitor in the caches' cli I can see the pings are coming in. I've also tried not using the RedisClient's ping functionality and just setting a key-value pair every ping interval - this has not worked and the cache still idles. Any ideas about what could be causing this or how to fix it?

Answer 1

Here, I Configured a connection pool to efficiently manage and reuse Redis connections. Adjust the max and min values based on your application's requirements. This example uses the generic-pool library.

Azure Cache for Redis idling and reconnecting

• Here, I have built a web server using Express and interacting with a Redis cache. This code structure use as a starting point for building scalable and maintainable applications.

const express = require('express');
const redis = require('redis');
const genericPool = require('generic-pool');

// Create a Redis connection pool
const redisPool = genericPool.createPool({
  create: () => redis.createClient({ host: '<your-redis-host>', port: 6379 }),
  destroy: (client) => client.quit(),
}, { max: 10, min: 2 });

// Create an Express application
const app = express();

// Middleware to acquire a Redis client from the pool
app.use((req, res, next) => {
  redisPool.acquire().then((client) => {
    req.redisClient = client;
    next();
  }).catch((err) => {
    console.error('Error acquiring Redis client:', err);
    res.status(500).send('Internal Server Error');
  });
});

// Routes
app.get('/', (req, res) => {
  // Example route using Redis client
  const { redisClient } = req;
  redisClient.get('exampleKey', (err, result) => {
    if (err) {
      console.error('Error getting value from Redis:', err);
      res.status(500).send('Internal Server Error');
    } else {
      res.send(`Value from Redis: ${result}`);
    }

    // Release the Redis client back to the pool
    redisPool.release(redisClient);
  });
});

// Error handling middleware
app.use((err, req, res, next) => {
  console.error('Error:', err);
  res.status(500).send('Internal Server Error');
});

// Start the Express server
const port = process.env.PORT || 3000;
app.listen(port, () => {
  console.log(`Server listening on port ${port}`);
});

You can also use the connection pool to create and reuse connections.

async function performRedisOperation() {
  let client;
  try {
    client = await pool.acquire();
    // Perform Redis operation using 'client'
    // Example: client.get('key', (err, reply) => { /* handle response */ });
  } catch (error) {
    console.error('Error acquiring Redis connection:', error);
  } finally {
    if (client) {
      await pool.release(client);
    }
  }
}

// Schedule periodic Redis operations
setInterval(performRedisOperation, 600000); // 10 minutes

• This output indicates that the application is successfully connecting to Redis, performing operations every 10 minutes.