How to set up Redis as object cache on a Linux VPS

In-memory object caching is one of the best cost-benefit optimizations for any web application that runs repeated queries, renders expensive fragments, or serializes sessions. Redis has become the de facto standard — single-threaded, sub-millisecond latency, native support in almost every PHP, Node.js, Python, or Ruby framework.

This tutorial shows how to install Redis 7.x on an Ubuntu 24.04 LTS VPS, apply basic hardening (authentication, local bind, memory limits), and integrate it with PHP and Node.js applications. The focus is using it as an object cache — not as a persistent database or a queue broker, although the base configuration works as a starting point for those too.

Estimated execution time: 20 to 30 minutes, including tests. You finish with Redis running, authenticated, with a discard policy configured and a working integration example.

Prerequisites

If you’ve never worked with Redis before, it’s worth knowing the primary types: strings, hashes, lists, sets, and sorted sets. For object caching, 90% of usage is strings (a value serialized as JSON or in the client’s native format). The rest shows up in specific cases like leaderboards, lightweight queues, and counters.

Installing Redis

This section covers installation via the official Ubuntu repository. The packaged version (7.x) is good enough for object caching without reservations — you only need the upstream repository if you want features from very recent versions like Redis Functions or specific modules.

sudo apt update
sudo apt install -y redis-server

sudo systemctl status redis-server
redis-cli ping

sudo systemctl enable redis-server

Security and limit configuration

Redis installed straight from apt comes with reasonable defaults for development but insecure for production: no password, persistence enabled, no memory limit. Let’s adjust that.

sudo nano /etc/redis/redis.conf

bind 127.0.0.1 ::1
protected-mode yes
port 6379
requirepass YourStrongRandomPassword32Chars
maxmemory 256mb
maxmemory-policy allkeys-lru

# save 3600 1 300 100 60 10000
save ""

sudo systemctl restart redis-server
redis-cli -a YourStrongRandomPassword32Chars ping

Integration with PHP

PHP uses either the phpredis extension (native C, more performant) or the predis/predis library via Composer (pure PHP, more portable). For object caching in production, phpredis wins by a significant margin.

sudo apt install -y php-redis
sudo systemctl restart php8.3-fpm

<?php
$redis = new Redis();
$redis->connect('127.0.0.1', 6379);
$redis->auth('YourStrongRandomPassword32Chars');

$key = 'user:42:profile';
$cached = $redis->get($key);

if ($cached === false) {
    $data = ['id' => 42, 'name' => 'John', 'plan' => 'pro'];
    $redis->setex($key, 3600, json_encode($data));
    echo "Cache MISS — populated\n";
} else {
    echo "Cache HIT: " . $cached . "\n";
}

Integration with Node.js

In Node.js the recommended client is the official redis (v4+) — asynchronous, maintained by Redis Inc., TypeScript-compatible. Older applications using ioredis remain supported, but for new projects use the official one.

npm install redis

import { createClient } from 'redis';

const client = createClient({
  url: 'redis://:[email protected]:6379'
});

client.on('error', (err) => console.error('Redis error:', err));
await client.connect();

const key = 'session:abc123';
const cached = await client.get(key);

if (!cached) {
  await client.setEx(key, 1800, JSON.stringify({ userId: 42 }));
  console.log('MISS — populated');
} else {
  console.log('HIT:', cached);
}

Verification and monitoring

After configuring and integrating, it’s worth confirming that the cache is actually being used — Redis internal metrics help detect low hit ratios or memory pressure.

redis-cli -a YourStrongRandomPassword32Chars
> INFO stats
> INFO memory
> DBSIZE

Troubleshooting

Error “MISCONF Redis is configured to save RDB snapshots”

This appears when RDB persistence is enabled but the disk is full or has no write permission. If you disabled persistence in Step 05, this should not happen — confirm that save "" was saved and the service was restarted. In an emergency, CONFIG SET stop-writes-on-bgsave-error no allows writes to keep going while you fix the disk.

Connection refused from an application in another Docker container

By default we set bind 127.0.0.1 — this blocks connections coming from other containers. Solutions: use host network in the application container, run Redis also in a container sharing the network, or expand the bind to include the bridge interface (bind 127.0.0.1 172.17.0.1) with a firewall closing the port on the external interface.

Intermittent high latency

It’s usually I/O from the RDB snapshot during bgsave. Check with INFO persistence whether rdb_last_bgsave_status is OK and how long it took. If persistence is required but snapshots cause spikes, consider AOF with appendfsync everysec, which has a more consistent I/O profile.

Next steps

With Redis running as an object cache, it’s worth exploring:

• Layered cache strategies (local memory + Redis + database) with libraries like symfony/cache in PHP or cache-manager in Node
• Redis pub/sub for cache invalidation across multiple application servers
• Master-replica replication for scalable reads when a single instance is no longer enough
• Rate limiting with INCR + TTL — it replaces homemade implementations with superior performance

If you’re running this in production and need a dedicated instance with automatic VPS snapshots, consistent latency, and DDoS protection at the edge, Hostini VPS deliver that by default — NVMe storage, network with packet filtering, and daily backups at no extra cost.