Redis has become one of the most popular in-memory data structures stores in the world, and for good reason. Whether you’re building a high-performance web application, implementing caching solutions, or managing real-time analytics, Redis provides the speed and flexibility you need. If you’re running Rocky Linux, you’re in for a treat – this enterprise-grade operating system pairs perfectly with Redis to deliver exceptional performance.

In this comprehensive guide, I’ll walk you through everything you need to know about installing Redis on Rocky Linux. We’ll cover multiple installation methods, from the simplest approach using default repositories to more advanced techniques that give you access to the latest Redis features. By the end of this tutorial, you’ll have a fully functional Redis installation that’s properly configured and secured.

What is Redis and Why Use It on Rocky Linux?

Understanding Redis: The In-Memory Database

Redis, which stands for Remote Dictionary Server, is an open-source, in-memory data structure store that serves as a database, cache, and message broker. Unlike traditional databases that store data on disk, Redis keeps everything in memory, which makes it incredibly fast – we’re talking about sub-millisecond response times for most operations.

What sets Redis apart is its versatility. It’s not just a simple key-value store; it supports various data structures including strings, hashes, lists, sets, sorted sets, bitmaps, hyperloglogs, and geospatial indexes. This flexibility makes it perfect for a wide range of use cases, from simple caching to complex real-time applications.

Key Benefits of Redis

The numbers speak for themselves when it comes to Redis performance. Redis can handle over 1 million requests per second on a single instance, making it one of the fastest databases available. Here are the key benefits that make Redis so popular:

Lightning-Fast Performance: Since all data is stored in memory, Redis eliminates the disk I/O bottleneck that slows down traditional databases. This results in microsecond latencies for most operations.

Rich Data Types: Redis supports multiple data structures natively, which means you can implement complex functionality without writing complicated application logic.

High Availability: With built-in replication, Redis Sentinel for monitoring, and Redis Cluster for automatic partitioning, Redis provides enterprise-grade reliability.

Persistence Options: Despite being an in-memory store, Redis offers multiple persistence mechanisms to ensure your data survives server restarts.

Why Rocky Linux is Perfect for Redis

Rocky Linux has quickly established itself as the go-to choice for enterprise environments, especially after the CentOS changes. It’s a community-driven, enterprise-grade operating system that provides binary compatibility with Red Hat Enterprise Linux. This makes it an excellent platform for running Redis in production environments.

The combination of Rocky Linux’s stability and Redis’s performance creates a powerful foundation for high-throughput applications. Rocky Linux’s long-term support cycle aligns perfectly with Redis’s enterprise deployment needs, ensuring you have a stable platform for years to come.

Prerequisites for Installing Redis on Rocky Linux

System Requirements

Before we dive into the installation process, let’s make sure your system meets the basic requirements. The good news is that Redis is relatively lightweight and doesn’t require extensive hardware resources for basic installations.

Minimum System Requirements:

• Rocky Linux 8 or 9 (this guide covers both versions)
• At least 512 MB of RAM (though 2 GB is recommended for production)
• 50 MB of free disk space for the Redis binaries
• Network connectivity for downloading packages

Recommended System Configuration:

• 4 GB or more RAM for production workloads
• SSD storage for persistence files
• Multiple CPU cores for handling concurrent connections

User Permissions and Access

You’ll need either root access or a user account with sudo privileges to install Redis. Most of the commands in this guide will require elevated permissions since we’ll be installing system packages and modifying system configurations.

If you’re using a non-root user, make sure it’s added to the sudoers group. You can verify your sudo access by running:

sudo whoami

If this returns “root”, you’re all set to proceed with the installation.

Method 1: Installing Redis from Default Rocky Linux Repository

The simplest way to install Redis on Rocky Linux is using the packages available in the default repositories. This method ensures compatibility and easy maintenance, though you might not get the absolute latest version of Redis.

Updating Your System

Before installing any new software, it’s always a good practice to update your system packages. This ensures you have the latest security patches and prevents potential conflicts.

sudo dnf update -y

This command will update all installed packages to their latest versions. The -y flag automatically answers “yes” to any prompts, making the process non-interactive.

Installing Redis Using DNF

Rocky Linux includes Redis in its default AppStream repository, making installation straightforward. You can install Redis with a single command:

sudo dnf install redis -y

The DNF package manager will automatically resolve dependencies and install Redis along with any required libraries. The installation typically completes within a minute or two, depending on your internet connection.

Starting and Enabling Redis Service

Once Redis is installed, you need to start the service and configure it to start automatically at boot. Rocky Linux uses systemd for service management, so we’ll use the systemctl command:

sudo systemctl start redis
sudo systemctl enable redis

The first command starts the Redis service immediately, while the second ensures Redis will automatically start whenever your system boots up.

Verifying the Installation

To confirm that Redis is running correctly, check the service status:

sudo systemctl status redis

You should see output indicating that the service is “active (running)”. The default installation will show Redis running on port 6379, which is the standard Redis port.

Method 2: Installing Redis from EPEL Repository

The Extra Packages for Enterprise Linux (EPEL) repository often contains more recent versions of software packages compared to the default repositories. This method is particularly useful if you need features that aren’t available in the base repository version.

Enabling EPEL Repository

First, you need to install the EPEL release package, which adds the EPEL repository to your system:

sudo dnf install -y epel-release

This package configures your system to access the EPEL repository, giving you access to additional software packages maintained by the Fedora community.

Installing Redis via EPEL

Once EPEL is enabled, you can install Redis using the same DNF command:

sudo dnf install -y redis

The system will automatically select the version from EPEL if it’s newer than the one in the default repositories. You can verify which repository is being used by checking the package information before installation.

Service Configuration

The service configuration process is identical to Method 1:

sudo systemctl enable redis
sudo systemctl start redis

EPEL packages follow the same systemd integration standards as base repository packages, so the management commands remain consistent.

Method 3: Installing Latest Redis from Remi Repository

For users who need the absolute latest Redis features, the Remi repository provides access to Redis 7.x and other cutting-edge versions. This method is perfect for development environments or when you need specific features only available in newer releases.

Adding Remi Repository

The Remi repository specializes in providing updated versions of web-related software for Enterprise Linux distributions. Install the repository configuration with:

sudo dnf install https://rpms.remirepo.net/enterprise/remi-release-9.rpm

Note: Replace “9” with “8” if you’re using Rocky Linux 8. This command downloads and installs the repository configuration directly from the Remi project.

Enabling Redis Module

Remi uses modular repositories, allowing you to choose specific versions of software. First, check what Redis versions are available:

sudo dnf module list redis

You’ll see output showing available Redis streams, including versions like remi-7.0, remi-6.2, etc. To enable the latest Redis 7.x version:

sudo dnf module enable -y redis:remi-7.0

Installing Redis 7.x

With the module enabled, install Redis:

sudo dnf install -y redis

This will install Redis 7.x with all the latest features and performance improvements. You can verify the version after installation:

redis-server --version

Checking Available Redis Versions

The modular approach allows you to switch between different Redis versions if needed. You can see all available modules and their status using the module list command mentioned earlier.

Basic Redis Configuration on Rocky Linux

Understanding Redis Configuration File

Redis stores its configuration in /etc/redis/redis.conf. This file contains hundreds of configuration options, but most installations only need to modify a few key settings. Before making any changes, it’s wise to create a backup:

sudo cp /etc/redis/redis.conf /etc/redis/redis.conf.backup

Essential Configuration Settings

The Redis configuration file is well-documented with comments explaining each option. Here are the most important settings you should consider adjusting:

Memory Management: By default, Redis will use all available system memory. For production systems, set a memory limit:

maxmemory 2gb
maxmemory-policy allkeys-lru

Logging: Configure logging to help with troubleshooting:

loglevel notice
logfile /var/log/redis/redis-server.log

Binding Redis to Specific IP Addresses

By default, Redis binds to localhost (127.0.0.1), which means it only accepts connections from the local machine. For security reasons, this is the recommended configuration unless you specifically need remote access.

If you need to allow remote connections, modify the bind directive:

bind 127.0.0.1 192.168.1.100

Replace 192.168.1.100 with your server’s actual IP address. Never bind to 0.0.0.0 (all interfaces) without proper authentication and firewall rules.

Setting Up Password Authentication

Even for local-only installations, setting up password authentication is a security best practice. Add or uncomment the requirepass directive:

requirepass your_strong_password_here

Choose a strong password with a mix of letters, numbers, and special characters. After making this change, restart Redis for the configuration to take effect:

sudo systemctl restart redis

Securing Your Redis Installation

Authentication Setup

Beyond basic password authentication, Redis offers several security features. The AUTH command is the primary authentication mechanism, but you can also configure multiple users with different permissions in Redis 6+.

For basic setups, the requirepass directive we configured earlier provides adequate protection. Clients must authenticate using:

redis-cli
AUTH your_password

Network Security Configuration

Network security is crucial for Redis installations. Here are the key principles:

Principle of Least Privilege: Only bind Redis to interfaces that actually need access. For single-server applications, localhost-only binding is sufficient.

Disable Dangerous Commands: Some Redis commands can be dangerous in production. You can disable or rename them:

rename-command FLUSHDB ""
rename-command FLUSHALL ""
rename-command DEBUG ""

Firewall Configuration

If you need remote access to Redis, configure your firewall to only allow connections from trusted sources. For Rocky Linux using firewalld:

sudo firewall-cmd --permanent --add-rich-rule="rule family="ipv4" source address="192.168.1.0/24" port protocol="tcp" port="6379" accept"
sudo firewall-cmd --reload

This example allows access from the 192.168.1.0/24 network. Adjust the network range according to your needs.

Testing Your Redis Installation

Using Redis CLI

The Redis command-line interface (CLI) is the primary tool for interacting with your Redis server. Connect to your local Redis instance:

redis-cli

If you configured password authentication, you’ll need to authenticate:

AUTH your_password

Basic Redis Commands

Test your installation with these fundamental Redis commands:

PING: Test connectivity

127.0.0.1:6379> PING
PONG

SET and GET: Basic key-value operations

127.0.0.1:6379> SET test_key "Hello, Rocky Linux!"
OK
127.0.0.1:6379> GET test_key
"Hello, Rocky Linux!"

INFO: Get detailed server information

127.0.0.1:6379> INFO server

This command provides extensive information about your Redis server, including version, uptime, and configuration details.

Performance Testing

Redis includes a built-in benchmarking tool. Test your installation’s performance:

redis-benchmark -q -n 10000

This runs a quick benchmark with 10,000 requests. You should see results showing thousands of operations per second, even on modest hardware.

Managing Redis Service on Rocky Linux

Starting and Stopping Redis

Systemd provides consistent service management commands for Redis:

Start Redis:

sudo systemctl start redis

Stop Redis:

sudo systemctl stop redis

Restart Redis (useful after configuration changes):

sudo systemctl restart redis

Enabling Auto-Start on Boot

Ensure Redis starts automatically after system reboots:

sudo systemctl enable redis

To disable auto-start:

sudo systemctl disable redis

Monitoring Redis Status

Check Redis service status and recent log entries:

sudo systemctl status redis -l

The -l flag shows full log lines without truncation, which is helpful for troubleshooting.

Troubleshooting Common Redis Installation Issues

Connection Problems

Issue: “Could not connect to Redis at 127.0.0.1:6379: Connection refused”

Solutions:

1. Verify Redis is running: sudo systemctl status redis
2. Check if Redis is listening on the correct port: sudo netstat -tlnp | grep 6379
3. Review Redis logs: sudo journalctl -u redis -f

Permission Issues

Issue: Redis fails to start due to permission problems

Solutions:

1. Ensure Redis user exists: id redis
2. Check ownership of Redis directories: ls -la /var/lib/redis
3. Reset permissions if necessary: sudo chown -R redis:redis /var/lib/redis

Memory Configuration Problems

Issue: Redis crashes or refuses connections due to memory issues

Solutions:

1. Check available system memory: free -h
2. Review Redis memory configuration in /etc/redis/redis.conf
3. Monitor Redis memory usage: redis-cli INFO memory

For production systems, consider implementing memory monitoring and alerting to prevent out-of-memory situations.

Redis Performance Optimization on Rocky Linux

Memory Management

Proper memory configuration is crucial for Redis performance. The key settings include:

maxmemory: Set this to about 75% of available system RAM to leave room for the operating system and other processes.

maxmemory-policy: Choose the appropriate eviction policy based on your use case:

• allkeys-lru: Good for caching scenarios
• volatile-lru: Evicts only keys with expiration set
• noeviction: Returns errors when memory limit is reached

Persistence Settings

Redis offers two persistence mechanisms, each with different performance characteristics:

RDB vs AOF Persistence

RDB (Redis Database): Creates point-in-time snapshots of your dataset. It’s more compact and faster for restart recovery but may lose data if Redis stops unexpectedly.

AOF (Append Only File): Logs every write operation. It’s more durable but creates larger files and can be slower.

For most production scenarios, enabling both provides the best balance of performance and durability:

save 900 1
save 300 10
save 60 10000
appendonly yes
appendfsync everysec

Frequently Asked Questions (FAQs)

1. What’s the difference between installing Redis from default repositories vs. Remi repository?

The default Rocky Linux repositories typically contain older, more stable versions of Redis that have been thoroughly tested for compatibility. The Remi repository provides access to newer Redis versions with the latest features and performance improvements. Choose default repositories for production stability or Remi for development environments where you need cutting-edge features.

2. How much memory should I allocate to Redis on Rocky Linux?

For production environments, allocate about 75% of available system RAM to Redis, leaving the remainder for the operating system and other processes. For example, on a system with 8 GB RAM, configure Redis with maxmemory 6gb. This prevents out-of-memory conditions while ensuring optimal performance.

3. Is it safe to run Redis without password authentication?

Running Redis without authentication is only acceptable if it’s bound to localhost (127.0.0.1) and used exclusively by local applications. For any other scenario, including development environments that might be accessible from other machines, always configure password authentication using the requirepass directive.

4. How can I monitor Redis performance on Rocky Linux?

Use the built-in INFO command through redis-cli to monitor key metrics like memory usage, connected clients, and operations per second. For production environments, consider implementing monitoring solutions that can track Redis metrics over time and alert on performance issues. The command redis-cli INFO stats provides comprehensive performance statistics.

5. What should I do if Redis fails to start after installation?

First, check the Redis service status with sudo systemctl status redis and review the logs using sudo journalctl -u redis. Common issues include permission problems with Redis directories, configuration file syntax errors, or port conflicts. Ensure the redis user has proper permissions and that port 6379 isn’t being used by another service.