Install Redis & Memcached on Your VPS — A Fast, Secure Step-by-Step Guide

Caching is one of the most effective ways to reduce latency and scale web applications. Two of the most widely used in-memory stores are Redis and Memcached. Both offer sub-millisecond reads, but differ in features, persistence model, and operational considerations. This guide walks you through installing, securing, tuning, and operating Redis and Memcached on a VPS, with practical commands and configuration recommendations tailored for production workloads.

Why use an in-memory store on a VPS?

An in-memory cache reduces database load, speeds up API responses, and improves user experience. On a VPS, running Redis or Memcached close to your application minimizes network latency compared with remote managed services and gives you full control over configuration, upgrades, and persistence. For many sites and microservices hosted on a VPS, colocating the cache leads to consistent performance and predictable costs.

Core differences and when to choose which

Before installation, decide which server fits your needs:

• Redis – an in-memory data structure server supporting strings, lists, sets, sorted sets, hashes, bitmaps, streams, Lua scripting, transactions, and persistence (RDB/AOF). Best for complex data models, pub/sub, leaderboards, rate limiting with precision, and when you need persistence or replication.
• Memcached – a simple, high-performance key-value cache with fixed eviction policies. It is extremely fast for volatile caching of strings or serialized objects and has a very small operational surface. Use Memcached if you only need a pure cache layer and want very fast, low-latency access without persistence.

Prerequisites and initial hardening

These instructions assume you have a VPS running a modern Linux distribution such as Ubuntu 22.04 LTS or Debian 12, with root or sudo privileges. Before installing:

• Update packages: sudo apt update && sudo apt upgrade -y.
• Create a non-root user for operations: adduser deployer && usermod -aG sudo deployer.
• Enable a basic firewall (UFW) and allow SSH: sudo ufw allow OpenSSH && sudo ufw enable.
• Decide on network access: ideally restrict Redis/Memcached to localhost or private network; expose only if necessary and secure with authentication and firewall rules.

Installing Redis

On Debian/Ubuntu, install the packaged Redis server: sudo apt install redis-server -y. After installation, systemd will manage the service as redis-server. Confirm it is running with sudo systemctl status redis-server.

Basic Redis configuration changes

Edit /etc/redis/redis.conf to adjust production settings:

• Bind only required interfaces. For local-only usage set: bind 127.0.0.1 ::1. For private network use, replace with the private IP address.
• Enable authentication: set requirepass <strong-password>. Use a strong password or preferably configure TLS + ACLs for multi-client setups.
• Configure persistence: RDB snapshots are enabled by default. For safer durability, enable AOF by setting appendonly yes. AOF gives better durability with trade-offs in disk I/O.
• Set maxmemory and eviction policy: maxmemory 4gb and maxmemory-policy volatile-lru or allkeys-lru depending on whether you want to preserve non-expiring keys.
• Adjust supervised system accordingly: supervised systemd is recommended for systemd-managed systems.

Securing Redis

Redis has historically been targeted by bots when exposed to the public net. For secure operation:

• Do not expose Redis to the public internet. Use firewall rules: sudo ufw allow from 10.0.0.0/8 to any port 6379 or allow only application server IPs.
• Use TLS if you must expose Redis across untrusted networks. For modern Redis versions, enable TLS by compiling with TLS support or using packages with TLS enabled, and configure tls-cert-file, tls-key-file, and tls-ca-cert-file.
• Use Redis ACLs (available since Redis 6) to create users with limited command sets: ACL SETUSER readonly on >password ~* +@read.
• Run Redis as a non-root user (packaged installs do this). Ensure file permissions on DB and AOF files are restricted to the Redis user.

Performance tuning tips

On a VPS, memory and CPU are finite resources. Tune Redis to match your VPS profile:

• Set vm.overcommit_memory = 1 in /etc/sysctl.conf to avoid OOM issues when Redis forks for persistence.
• Disable transparent hugepages: add echo never > /sys/kernel/mm/transparent_hugepage/enabled in a startup script to avoid latency spikes.
• Configure persistence frequency: if using AOF, set appendfsync everysec for a good compromise between durability and IO.
• Monitor with INFO and slowlog: redis-cli INFO and redis-cli SLOWLOG GET 10.

Installing Memcached

Install Memcached on Debian/Ubuntu with sudo apt install memcached libmemcached-tools -y. The memcached service runs as memcached and listens on port 11211 by default.

Memcached configuration

Configuration on Debian is in /etc/memcached.conf. Key production settings:

• Set memory limit: -m 2048 to allocate 2GB of RAM to Memcached.
• Bind interface: change -l 127.0.0.1 to a private IP if needed.
• Adjust the number of connections: -c 1024 to increase max concurrent connections.
• Set a lower idle timeout with -I or other flags as needed per workload.

Securing Memcached

Memcached lacks native authentication and encryption in most deploys, so security relies on network isolation:

• Always bind Memcached to localhost or a private network. Do not expose 11211 to the public internet.
• Use UFW or iptables to restrict access to trusted hosts only.
• For multi-VPS secure setups, place Memcached behind a VPN, SSH tunnel, or a private VPC network offered by your VPS provider.

High-availability, replication, and backups

Redis supports replication and Redis Sentinel for automated failover. For persistent setups, plan backups and replication topology:

• Use master-replica replication for read scaling and resilience: configure replicaof <master-ip> <port> on replicas.
• Run Sentinel processes on three or more distinct servers to detect master failure and coordinate failover.
• Schedule RDB or AOF backups to remote storage (object store or another VPS). Use redis-cli BGSAVE and copy the dump.rdb or appendonly.aof safely to backups.

Memcached does not provide persistence or native replication; caching strategy should account for cache warm-up and eviction. Use consistent hashing or client libraries that support server pools to distribute keys across multiple Memcached instances for scalability.

Client libraries and integration

Most languages have mature clients for both Redis and Memcached:

• PHP: phpredis (Redis), Memcached extension (libmemcached)
• Python: redis-py (Redis), python-memcached / pymemcache (Memcached)
• Node.js: ioredis / node-redis (Redis), memjs (Memcached)
• Java: Jedis / Lettuce (Redis), spymemcached (Memcached)

When integrating, use connection pooling and retry/backoff logic. For Redis, prefer pipelining and Lua scripts for atomic multi-key operations. For Memcached, avoid storing very large objects; split or compress data when necessary.

Benchmarking and monitoring

Before and after deploying, benchmark and monitor to catch bottlenecks:

• Use memtier_benchmark for Memcached and redis-benchmark or memtier for Redis.
• Track latency percentiles (p50/p95/p99) and throughput (ops/sec). Aim for single-digit millisecond or sub-millisecond p99 for in-memory caches depending on network and VPS class.
• Monitor memory usage, eviction metrics, hit/miss rates, and fragmentation. For Redis, use the INFO command and tools like Prometheus exporters and Grafana dashboards.

Choosing the right VPS and sizing advice

Select a VPS with enough RAM to hold your working set. Key considerations:

• Memory is the primary resource: a cache instance should have enough headroom beyond the maxmemory setting. For Redis with persistence and AOF, ensure adequate disk I/O as well.
• SSD disks and good IOPS help with persistence and log rewrites. For Memcached, disk is less relevant but fast networking matters.
• Use a VPS provider with private networking options if your application and cache run on separate instances to keep traffic on a fast, isolated network.

For example deployments, small web apps can start with 2–4 GB RAM caches, while high-traffic sites often run 8 GB or more per cache instance. Consider sharding or clustering across multiple VPS instances for very large data sets.

Summary

Redis and Memcached are powerful tools for improving application responsiveness when deployed on a VPS. Use Redis when you need rich data structures, persistence, pub/sub, or replication. Use Memcached when you need a simple, extremely fast, volatile cache. In all cases, prioritize securing network access, tuning memory and eviction policies, and monitoring operational metrics.

For low-latency performance and full control, deploy your cache on a reliable VPS with sufficient RAM and private networking. If you want to start quickly on a USA-hosted VPS, check VPS.DO’s offerings here: USA VPS at VPS.DO. For more about VPS.DO, visit VPS.DO.