Admin: New server guide

2026-04-12T15:52:33Z

New server guide

New page

= Installing Redis for Caching =

This guide provides a comprehensive walkthrough on installing, configuring, and utilizing Redis for caching on your Linux server. Redis (Remote Dictionary Server) is an open-source, in-memory data structure store used as a database, cache, and message broker. Its speed and versatility make it an excellent choice for improving application performance.

== Prerequisites ==

Before you begin, ensure you have the following:

* A Linux server with root or sudo privileges. For reliable performance and full control, consider dedicated servers from [https://powervps.net/?from=32 PowerVPS].
* Basic understanding of the Linux command line.
* Internet access on your server to download packages.

== Installation ==

Redis is available in the default repositories of most Linux distributions. We'll cover installation for Debian/Ubuntu and CentOS/RHEL-based systems.

=== Debian/Ubuntu ===

1. Update your package lists:
<pre>sudo apt update</pre>
2. Install Redis Server:
<pre>sudo apt install redis-server</pre>
3. Verify the installation and check the status:
<pre>sudo systemctl status redis-server</pre>
You should see output indicating that the service is active and running. Press `q` to exit the status view.

=== CentOS/RHEL ===

1. Install the EPEL (Extra Packages for Enterprise Linux) repository, which contains Redis:
<pre>sudo yum install epel-release</pre>
For newer RHEL/CentOS versions (like 8+), you might use `dnf`:
<pre>sudo dnf install epel-release</pre>
2. Install Redis:
<pre>sudo yum install redis</pre>
Or for newer systems:
<pre>sudo dnf install redis</pre>
3. Start and enable Redis to run on boot:
<pre>sudo systemctl start redis</pre>
<pre>sudo systemctl enable redis</pre>
4. Verify the installation and check the status:
<pre>sudo systemctl status redis</pre>
Press `q` to exit the status view.

== Basic Configuration ==

The main Redis configuration file is typically located at `/etc/redis/redis.conf` (Debian/Ubuntu) or `/etc/redis.conf` (CentOS/RHEL).

1. Open the configuration file with your preferred text editor (e.g., `nano`, `vim`):
<pre>sudo nano /etc/redis/redis.conf</pre>
or
<pre>sudo nano /etc/redis.conf</pre>

2. Key Configuration Directives:

* '''bind''': By default, Redis binds to `127.0.0.1` (localhost). To allow remote connections, change this to your server's IP address or `0.0.0.0` to listen on all interfaces.
'''Note:''' Binding to all interfaces requires securing your Redis instance with a password and firewall rules.
Example (replace `192.168.1.100` with your server's IP):
<pre>bind 127.0.0.1 192.168.1.100</pre>
or for all interfaces:
<pre>bind 0.0.0.0</pre>

* '''protected-mode''': If `bind` is not set to `127.0.0.1` or `localhost`, this directive is enabled by default (`yes`). It prevents clients from connecting if no password is set. It's recommended to keep this enabled and set a password.

* '''port''': The default port is `6379`. You can change this if needed.
<pre>port 6379</pre>

* '''requirepass''': Uncomment and set a strong password for authentication.
Example:
<pre>requirepass your_strong_password</pre>

* '''maxmemory''': Set a limit on the amount of memory Redis can use. This is crucial for preventing Redis from consuming all available RAM.
Example (set to 1GB):
<pre>maxmemory 1gb</pre>

* '''maxmemory-policy''': Defines how Redis evicts keys when `maxmemory` is reached. Common policies include:
* `noeviction`: Don't evict anything, return errors on write operations.
* `allkeys-lru`: Remove the least recently used (LRU) keys from all keys.
* `volatile-lru`: Remove the LRU keys from keys that have an expire set.
Example:
<pre>maxmemory-policy allkeys-lru</pre>

3. Save the changes and exit the editor.

4. Restart Redis for the changes to take effect:
<pre>sudo systemctl restart redis-server</pre>
or
<pre>sudo systemctl restart redis</pre>

== Testing Redis Connection ==

You can interact with Redis using the `redis-cli` command-line interface.

1. Connect to the Redis server:
<pre>redis-cli</pre>

2. If you set a password, you'll need to authenticate first:
<pre>AUTH your_strong_password</pre>
You should see `OK`.

3. Test with simple commands:
* Set a key:
<pre>SET mykey "Hello Redis!"</pre>
Output: `OK`
* Get the key:
<pre>GET mykey</pre>
Output: `"Hello Redis!"`
* Check server info:
<pre>INFO memory</pre>
This will display memory usage statistics.

4. Exit `redis-cli`:
<pre>QUIT</pre>

== Persistence ==

Redis offers two primary persistence mechanisms to save your data to disk, ensuring it's not lost when Redis restarts or the server reboots.

=== RDB (Redis Database) ===

RDB creates a point-in-time snapshot of your dataset.

* '''Configuration''': In `redis.conf`, find the `save` directive.
* `save 900 1`: Save if at least 1 key changed in 900 seconds (15 minutes).
* `save 300 10`: Save if at least 10 keys changed in 300 seconds (5 minutes).
* `save 60 10000`: Save if at least 10000 keys changed in 60 seconds (1 minute).

You can comment out or modify these lines. To disable RDB persistence entirely, add:
<pre>save ""</pre>

* '''Location''': The RDB snapshot file is named `dump.rdb` and is typically stored in Redis's working directory (often `/var/lib/redis/` on Debian/Ubuntu or `/var/lib/redis/` on CentOS/RHEL).

=== AOF (Append Only File) ===

AOF logs every write operation received by the server.

* '''Configuration''': Enable AOF by setting `appendonly yes` in `redis.conf`.
<pre>appendonly yes</pre>

* '''Sync Policies''': Control how often data is written to the AOF file.
* `appendfsync always`: Sync on every write operation (safest, but slowest).
* `appendfsync everysec`: Sync once per second (default, good balance).
* `appendfsync no`: Let the OS decide when to sync (fastest, least safe).
Example (default):
<pre>appendfsync everysec</pre>

* '''Location''': The AOF file is named `appendonly.aof` and is typically stored in the same directory as the RDB file.

'''Recommendation''': For most use cases, using `appendonly yes` with `appendfsync everysec` is recommended for better durability than RDB alone. You can also use both RDB and AOF for redundancy.

== Use Cases for Redis Caching ==

Redis excels as a cache due to its in-memory nature and high performance.

* '''Database Query Caching''': Cache results of frequently executed database queries to reduce load on your primary database.
* '''Session Management''': Store user session data for web applications, providing faster access than disk-based sessions.
* '''API Response Caching''': Cache responses from external APIs to avoid repeated calls.
* '''Page Caching''': Cache rendered HTML pages for static content.
* '''Rate Limiting''': Implement rate limiting for APIs or user actions.
* '''Leaderboards and Counters''': Utilize Redis's atomic operations for real-time leaderboards and counters.

== Troubleshooting ==

* '''Redis not starting''': Check Redis logs for errors. On Debian/Ubuntu, logs are often at `/var/log/redis/redis-server.log`. On CentOS/RHEL, use `journalctl -u redis`. Common issues include incorrect configuration syntax or insufficient memory.
* '''Cannot connect to Redis''':
* Verify Redis is running: `sudo systemctl status redis-server` (or `redis`).
* Check `bind` directive in `redis.conf`. If not `127.0.0.1`, ensure your firewall allows connections on the Redis port (default 6379).
* Ensure `protected-mode` is `no` or a password is set and used for authentication.
* '''`maxmemory` reached''': If you see errors related to memory limits, you may need to increase `maxmemory` in `redis.conf` (if your server has enough RAM) or tune your `maxmemory-policy` to evict keys more aggressively. For more RAM, consider upgrading your server at [https://powervps.net/?from=32 PowerVPS].
* '''Data loss''': Ensure persistence (RDB or AOF) is enabled and configured correctly if you need data to survive restarts.

== Related Articles ==

* [[Configuring a Firewall]]
* [[Securing Your Linux Server]]
* [[Introduction to Databases]]

[[Category:Database Setup]]
[[Category:Caching]]
[[Category:Performance Tuning]]

{{Exchange Box}}

Installing Redis for Caching - Revision history

Admin: New server guide