cPanel Redis Manager documentation

Everything you need to install, configure, and manage v2.5.0 on cPanel and WHM.

Name: cPanel Redis Manager
Brand: UnderHost
Price: 4.95 USD

This documentation covers installation, upgrades, uninstall, configuration, CloudLinux guidance, roadmap details, and release history for cPanel Redis Manager. It is written for server owners, administrators, developers, and hosting teams who need clear deployment and operating guidance for Redis inside cPanel and WHM.

Start with installation View configuration Read changelog

v2.5.0 Install & Upgrade CloudLinux Ready Roadmap Included Release History

Quick path

Installation

Install cPanel Redis Manager on a supported server with the public one-line deployment command.

Open section

Quick path

Uninstall

Remove the Redis Manager plugin cleanly using the documented uninstall workflow.

Open section

Quick path

Configuration

Review Redis-compatible backend selection, memory settings, eviction policies, presets, and deployment behavior.

Open section

Quick path

Redis and Valkey

Choose Redis, Valkey, or Auto-detect from WHM and review backend diagnostics before changing accounts.

Open section

Quick path

CloudLinux

Enable the Redis PHP extension correctly with CloudLinux, Select PHP Version, and CageFS-aware hosting stacks.

Open section

Quick path

WHM Guide

Every WHM administrator function: accounts, backends, provider policy, packages, resellers, recovery, and branding.

Open section

Quick path

cPanel Guide

Every cPanel user function: instance lifecycle, connection details, presets, backups, and application integration.

Open section

Quick path

Roadmap

See the current public release position, next milestone, and the planned direction for Redis Manager.

Open section

Quick path

Changelog

Review recent product releases, public rollout updates, and the features already delivered.

Open section

Quick path

Upgrade Guide

Follow the upgrade path for in-place updates, legacy reinstall cases, and post-upgrade verification.

Open section

Documentation overview

Everything you need to deploy, manage, and maintain Redis Manager on cPanel and WHM.

Start with installation, review upgrade and uninstall guidance, understand configuration and CloudLinux behavior, and follow the current roadmap and release history from one place.

Installation

Deploy Redis Manager on a supported server

Follow the installation flow to validate your license, deploy the cPanel and WHM components, and prepare Redis Manager for production use.

Upgrade

Keep your server on the current release

Use the documented upgrade path for in-place updates, legacy reinstall cases, and post-upgrade verification when moving to the latest public version.

Uninstall

Remove Redis Manager cleanly

Use the approved uninstall workflow to remove the Redis Manager plugin and related components without guessing through server paths or manual cleanup steps.

Configuration

Use safe defaults and adjust when needed

Review how Redis Manager handles defaults, presets, memory settings, and deployment behavior so you know what to expect after installation.

CloudLinux

Enable Redis correctly in customer runtimes

CloudLinux guidance explains how to use Select PHP Version, CageFS refreshes, and the Redis extension so applications can connect properly.

Roadmap & Changelog

Track the release path and product direction

See the current public rollout, the next planned milestone, and the recent changes already delivered in the live Redis Manager package.

Installation

Install cPanel Redis Manager on your server

Important: A valid license is required before installation. Run the installer as root on a supported cPanel and WHM server.

Place your order
Order cPanel Redis Manager for your server. Once activated, you will receive your Redis Manager license key and the installation command for deployment.
Confirm server requirements
Before installing, make sure the server is running a supported cPanel and WHM environment with root SSH access, a supported operating system, and enough available memory for Redis or Valkey workloads.
Enable the PHP Redis extension
Applications will still need the Redis PHP extension enabled in the PHP versions they use. On EasyApache systems, install the matching ea-phpXX-php-redis packages, our installer will try to install them first. On CloudLinux, enable redis in Select PHP Version.
Run the installer as root
Execute the provided installation command over SSH as root. The installer validates the license, deploys the cPanel and WHM plugin files, installs required components, applies migrations, and prepares the Redis Manager runtime automatically.
Verify the deployment
After installation, confirm the WHM interface is available for administrators and that Redis Manager appears inside cPanel for supported accounts. This confirms the plugin deployment and registration completed correctly.
Create your first cache instance
Open Redis Manager in cPanel to initialize an instance, review connection details, apply a preset if needed, and begin using the selected Redis-compatible backend with your website or application.
Connect your application
Update your application to use the host, port, password, and database details shown in cPanel. Once connected, you can monitor activity, review usage, and manage backups directly from the plugin.

Legacy upgrade note

Coming from a release older than v2.0.3?

If your server is still using the first-generation Redis Manager module from before v2.0.3, remove the old cPanel plugin first before installing the current public release.

/usr/local/cpanel/scripts/uninstall_plugin /usr/local/cpanel/base/frontend/jupiter/redis_plugin --theme=jupiter
rm -rf /usr/local/cpanel/base/frontend/jupiter/redis_plugin

This removes the old module interface only. Your existing Redis data, configuration, ports, passwords, and running Redis instances stay intact during this cleanup. Once the legacy module is removed and the current Redis Manager version is installed, the product interface returns and your Redis environments continue normally.

Only required for legacy releases before v2.0.3
Safely removes outdated cPanel plugin interface
No impact on running Redis service
All Redis instances continue running during cleanup
No data loss for cached data or stored keys
Ports, AUTH passwords, and instance configs remain unchanged
Per-account Redis environments stay intact
No need to recreate Redis instances after reinstall
New Redis Manager detects existing instances automatically
cPanel interface is restored after reinstall
WHM integration is rebuilt cleanly
Safe transition from legacy architecture to current system
No downtime required for Redis-backed applications
Session storage and object cache continue working
No manual migration of Redis data required
Supports immediate reinstall after cleanup
Compatible with existing CloudLinux environments
Does not affect MySQL or PHP runtime configuration
Installer reattaches to existing Redis processes
Production-safe cleanup path used in real deployments
Prevents conflicts between old and new plugin versions
Keeps server-level Redis configuration intact
Ensures clean UI and control panel rebuild
Recommended step before any major version upgrade

Uninstall

Remove Redis Manager from your server

Use the approved uninstall command to remove the Redis Manager plugin, services, and related components cleanly.

curl -sSL https://backup.underhost.com/mirror/redis/uninstall.sh | bash -s -- -y

When to use it

Clean removal and redeployment

Use this command when you need to fully remove Redis Manager before reinstalling, migrating, or resetting the server environment.

Removes plugin and WHM integration
Cleans Redis instances and configuration
Prepares server for fresh deployment

Configuration

Start with safe defaults, adjust only when your workload requires it.

cPanel Redis Manager is designed for real hosting environments with predictable behavior, clear control panel visibility, and minimal need for manual tuning after deployment.

Redis and Valkey backend behavior

Redis Manager supports Redis and Valkey as Redis-compatible cache backends.
Valkey is an open source Redis-compatible in-memory cache server developed under the Linux Foundation.
Valkey is useful for newer hosting platforms where Redis packages may be unavailable, deprecated, removed, or replaced in the default repositories.
WHM administrators can choose Auto-detect, Redis, or Valkey from the backend selector.
Auto-detect prefers Valkey for new accounts when both backends are installed, but existing Redis accounts remain Redis-backed.
Designed for common workloads such as object caching, session storage, queues, and repeated data lookups.
Applications must still use a Redis-compatible client or PHP Redis extension to interact with the instance.

When Valkey is installed

As of v2.4.1, fresh installs detect the OS family, major version, Redis package availability, and Valkey package availability before installing a backend.
CloudLinux, AlmaLinux, Rocky Linux, and RHEL-compatible 8/9 systems continue to prefer Redis when Redis packages are available.
CloudLinux 10, AlmaLinux 10, Rocky Linux 10, and future RHEL-compatible 10+ systems can use Valkey automatically when Redis is unavailable or unsupported.
If both Redis and Valkey are available, the WHM backend policy controls the preferred backend for new installations.
If neither Redis nor Valkey is available, installation stops safely and shows repository/package guidance instead of creating a broken partial install.

Existing Redis installations

Upgrades preserve Redis as the active backend when Redis is already in use.
The plugin does not automatically migrate existing Redis accounts to Valkey.
Redis service names, ports, sockets, account configuration, and user data paths are preserved during upgrade.
Administrators can review migration readiness in WHM before planning any manual Redis-to-Valkey transition.

cPanel and WHM access

Users access Redis Manager directly inside cPanel under the Software section.
WHM provides full administrative control including account management, recovery, limits, and global settings.
This separation keeps user workflows simple while maintaining full server-level control.

Memory and performance sizing

Minimum 2GB RAM required, 4GB or more recommended for stable Redis and application performance.
High-traffic websites, APIs, or multi-account servers should allocate additional memory for Redis usage.
Memory sizing should reflect cache size, traffic load, and overall server resource usage.

Configuration and presets

Built-in presets are available for common use cases like WordPress, Laravel, Magento, and generic workloads.
Settings such as memory limits, eviction policies, and databases can be adjusted safely from the interface.
Default configurations are designed to work without requiring immediate manual tuning.

Post-install behavior

Redis Manager becomes available in WHM for admins and in cPanel for users after installation completes.
Redis-compatible instances are isolated per account with their own configuration, port, and authentication.
No manual setup is required for most deployments, allowing immediate use after installation.

Backend diagnostics and migration readiness

WHM shows detected Redis and Valkey server binaries, CLI tools, services, versions, and account counts.
Migration readiness is diagnostic only and does not automatically migrate Redis data to Valkey.
Manual Redis-to-Valkey migration should be planned with service restarts and live cache persistence in mind.

Available in v2.4.1

Valkey support for newer Redis-compatible hosting stacks.

Valkey is an open source Redis-compatible in-memory cache server. As of v2.4.1, the installer selects Valkey for fresh installs on newer operating systems (AlmaLinux/CloudLinux/Rocky 10) and where Redis packages are unavailable or unsupported; AlmaLinux/CloudLinux 8/9 and Ubuntu stay on Redis. Existing Redis installations stay on Redis unless an administrator explicitly changes backend policy.

Valkey is a Linux Foundation project. Logo shown for compatibility context only.

PHP runtime

Enable Redis in the application layer

Redis Manager provides the Redis service and control panel workflow, but applications still need the Redis extension or client library enabled in the PHP versions they use.

Tuning guidance

Adjust only when needed

Most deployments work well with default settings. Review memory usage, application behavior, and traffic patterns before applying targeted configuration changes for heavier workloads.

WHM administrator guide

Every function in the WHM plugin and what it does.

WHM is where administrators manage the whole server: accounts, backend selection, provider policy, packages, resellers, recovery, and branding.

Dashboard

Server-wide overview: how many accounts have a cache instance, how many are running, and aggregate memory use.
A quick health snapshot with links into the account, recovery, and configuration areas.

Accounts

Lists every cPanel account with cache status, port, memory, connections, and health.
Start, stop, or restart an account instance without SSH.
Edit an account configuration (memory limit, eviction policy, databases, and more), with package ceilings enforced.
Migrate a single account between Redis and Valkey with one click: snapshot, switch, verify, and automatic rollback on failure.
Filter by running, stopped, or not configured.

Redis CLI

Run redis-cli or valkey-cli commands against any managed account from WHM, authenticated with the account stored credentials.
Inspect keys, run INFO, or diagnose an instance without logging in as the user.

Backups

Trigger a backup for a single account or for all managed accounts.
Backups are stored per account and are used by restore and before risky operations such as migration.

Recovery Tools

Scan Sessions: check every account plugin session storage and report which accounts are affected.
Repair Affected or single-account repair: fix ownership and permissions on the session directory, including a root-owned parent, so the cPanel plugin can write again. Scan-first and affected-only, never a global reset.
Run Maintenance Scan: detect and auto-fix Redis instance state mismatches.
Per-account recovery: restart, rebuild config from root metadata, reset the AUTH password, and fix file permissions.
Every action is written to the audit log.

Global Config — Cache Backend

Backend mode: Auto-detect, Redis, or Valkey, and the preferred backend when both are installed.
Live detection: which of Redis and Valkey are available, their binaries, services, and versions, plus per-backend account counts.
Migration-readiness notes and any actionable warnings.

Global Config — Provider Policy

Enforcement mode: report-only (default), warn, or enforce.
Default exposure mode: Simple, Developer, or Advanced, controlling how much of the cPanel interface users see.
Existing-Redis grandfathering, so enforcement never affects already-provisioned accounts.
Global cache defaults: memory, eviction policy, databases, backup retention, and history retention.

Packages

Define per-package limits that map to cPanel hosting packages.
Toggle Redis Enabled to include or exclude caching from a package (enforced when policy mode is enforce).
Set max memory, max clients, max databases, and backup retention per package.
Optionally auto-provision a cache instance when an account on the package is created.

Resellers

See cache usage grouped by reseller: account counts, active instances, and total memory.
Set per-reseller quotas: maximum number of instances and maximum total memory (0 means unlimited).
Quotas gate new provisioning only; existing instances are grandfathered; enforced when policy mode is enforce.

Branding

White-label the interface: product name, logo, support URL, and accent colors.
Branding is mirrored to the cPanel plugin so users see your brand.

Plugin Updates

Check the installed version against the latest published release.
Trigger an in-place upgrade from WHM; existing accounts and data are preserved.

cPanel user guide

Every function in the cPanel plugin and what it does.

Each hosting account manages its own cache instance from cPanel: lifecycle, connection details, tuning, backups, and application integration.

Server status and lifecycle

A clear status badge: Online, Offline, Degraded (high memory), or Broken.
Initialize or Start to create and launch the account cache instance; Stop to shut it down.
The backend (Redis or Valkey) is chosen by the hosting provider policy; existing instances keep their backend.

Connection details

Host, port, and the AUTH key needed to connect an application.
The AUTH key is masked by default and can be revealed when needed.

Configuration presets

One-click presets tuned for common workloads: WordPress, Laravel, Magento, Session Cache, and Generic.
Each preset sets a sensible memory policy and options for that use case.

Advanced settings

Adjust memory limit, eviction policy, number of databases, timeout, max clients, and persistence.
Changes are validated and capped by the hosting package limits.
The Advanced section is shown according to the provider exposure mode.

Backups and restore

Create an on-demand backup of the cache data.
List previous backups and restore one, with a safety snapshot taken before overwriting current data.

Usage history and health

Historical graphs of memory, connections, and hit ratio over time.
A health score summarizing instance state.
A one-click diagnostics export (JSON) that is safe for support tickets; credentials are masked.

Application detection and connection helper

Scans public_html for WordPress, WordPress + LiteSpeed Cache, Laravel, and Magento and reports integration status.
Generates ready-to-use connection snippets pre-filled with the account real credentials for WordPress, Laravel, Magento, PHP, Node.js, Python, and LiteSpeed Cache.

Setup preflight

A checklist showing whether the instance is initialized, running, and has authentication configured, with a fix hint for each item.

How the two sides interact

WHM sets policy, cPanel operates within it

Administrators define backend selection, package and reseller limits, and enforcement mode in WHM. Those decisions are propagated to each account, and the cPanel plugin operates within them: it provisions on the chosen backend, honors package and reseller limits, and shows the interface level the provider allows. Existing Redis accounts are always preserved, and enforcement is report-only until an administrator opts in.

WHM Redis Manager security and provider controls

CloudLinux support

Separate the Redis service layer from the PHP runtime layer.

cPanel Redis Manager provides the Redis service, cPanel workflow, and WHM management tools. CloudLinux still controls how the Redis extension is exposed inside customer PHP environments.

CloudLinux guidanceRecommended flow for CloudLinux-based cPanel serverscPanel Redis Manager works on supported CloudLinux-based cPanel and WHM servers when the normal installation requirements are met.
On CloudLinux systems, enable the Redis PHP extension through Select PHP Version for each PHP runtime that needs Redis support.
Installer will automaticly detect if CageFS is enabled, and will refresh CageFS after changing extension availability so users can see the updated PHP environment.
Redis Manager provides the Redis-compatible backend workflow and WHM control layer, but applications still need the Redis extension or compatible client library enabled in their runtime.
Each application connects using the host, port, password, and database details provided by the instance inside cPanel.
WHM remains the administrative surface for broader server control, including defaults, package settings, recovery, security, and operational management.
CloudLinux note: customer PHP extension changes should be described using Select PHP Version, since that is the control users typically see in cPanel.

Roadmap

Current release status, upcoming patches, and the full planned roadmap.

This roadmap includes the active public release, the shipped adoption releases, the Redis-compatible backend milestone in v2.4.1, and the longer-term product direction beyond it.

Current public rollout

v2.5.0 Released

The current stable release keeps Redis installations safe with targeted CloudLinux session diagnostics and affected-user repair.

Scan Sessions reports affected Redis plugin session paths before repair
single-user and affected-user repair avoid global permission resets
targeted CloudLinux session repair remains scan-first and affected-user only

Current release

v2.5.0 Released

Provider enforcement and monetization on top of Redis and Valkey support. Report-only by default; nothing changes for an account until an administrator opts in. Existing Redis accounts are preserved.

package-tier cache availability enforcement (report-only by default)
reseller quotas: max instances and max total memory per reseller
monetization hook events for billing automation
Simple / Developer / Advanced exposure modes for the cPanel UI
one-click guided Redis-to-Valkey migration with automatic rollback
WHM backend selector controls new-account provisioning

Next milestone

v2.6.x Planned

Security and abuse protection: smart resource enforcement, abuse detection, stronger AUTH handling, and improved license and server fingerprinting.

smart resource enforcement and abuse detection
stronger AUTH protection and rate limiting
signed-license improvements and server fingerprinting

Completed milestones

How Redis Manager reached the current public release

The live product is built on top of multiple completed phases covering the original public baseline, installer and migration improvements, WHM integration, stronger account controls, and hosting foundation features.

Commercial direction

Public licensing now follows the monthly and yearly model

cPanel Redis Manager is available at $4.95 per server per month or $49.50 per server per year, while future milestones expand provider controls, package governance, and commercial Redis hosting features.

v2.0.3

Public baseline release with isolated per-account Redis instances, automatic port assignment, AUTH generation, and core lifecycle controls.

v2.0.4

Foundation rewrite that improved process handling and introduced the installer and migration path used by later releases.

v2.1.0

WHM plugin release with server-wide dashboard, account controls, backup tools, recovery features, and global management foundations.

v2.1.1

Internal hardening release with safer write paths, stronger validation, tighter access control, and audit logging improvements.

v2.2.x

User control and stability series adding monitoring, presets, backup and restore, safe config editing, and stronger health-aware instance handling.

v2.3.x

Hosting foundation series introducing package controls, reseller groundwork, branding, usage history, release hardening, and public observability improvements.

Planned later

Longer-term roadmap themes beyond the next milestone.

These later phases show how Redis Manager is expected to expand after the current hosting-control and monetization milestone.

v2.6.x

Security and abuse protection

Resource enforcement, abuse controls, stronger AUTH handling, rate limiting, tracking, and a stronger license model with improved server fingerprinting.

v2.7.x

Deep observability and debugging

Advanced graphs, drill-down visibility, debug mode, slowlog tooling, command visibility, improved health scoring, and stronger support telemetry.

v2.8.x

Infrastructure upgrade

Background worker framework, restart backoff, auto-healing behavior, orphan cleanup, and system maintenance automation.

v2.9.x

Advanced features

Profile systems, config bundles, stronger backup rollback flows, integrity improvements, export and import between servers, and signed configuration validation.

v2.10.x

Developer and integration layer

REST API foundation, webhooks, automation events, Redis version management, and external Redis integration.

v3.0.x

Enterprise and multi-control-panel support

Shared architecture preparation, DirectAdmin support, and cluster, Sentinel, and scaling-oriented deployment features.

Changelog

Recent releases and what changed in Redis Manager.

Review the latest shipped updates in the public release line, including new features, observability improvements, deployment changes, and public rollout updates.

v2.5.0

2026-07-17 - Provider Enforcement and Monetization

package-tier cache availability enforcement, report-only by default
per-reseller quotas: maximum instances and maximum total memory
monetization hook events (backend changed, access denied, quota exceeded) for billing automation
Simple / Developer / Advanced exposure modes that control the cPanel interface
one-click guided Redis-to-Valkey migration with snapshot, verification, and automatic rollback
the WHM backend selector now controls how new accounts are provisioned
existing Redis accounts are always preserved and never migrated automatically

v2.4.2

2026-07-13 - Installer maintenance

the installer self-heals a corrupted migration-tracking file so migrations never re-run on upgrade
Valkey runtime statistics and version parsing verified against real Valkey instances

v2.4.1

2026-07-01 - Recovery Tools reliability

WHM Recovery Tools now detect and repair root-owned session parent directories, resolving the case where a scan reported healthy while cPanel still showed a session-storage error
unconfigured accounts with session issues are now listed so administrators can repair them from WHM
CloudLinux install robustness: reliable PHP CLI detection and OS-matrix-correct backend defaults

v2.4.0

2026-06-24 - Redis and Valkey Compatibility Release

full Valkey backend compatibility while preserving Redis support
OS-aware fresh-install backend selection: AlmaLinux/CloudLinux/Rocky 10 use Valkey; 8/9 and Ubuntu 24.04 use Redis
EasyApache Valkey detection, with native Redis remaining the default on AlmaLinux/CloudLinux 8/9 and Ubuntu
WHM backend selector with Auto-detect, Redis, and Valkey modes
backend diagnostics for Redis and Valkey binaries, CLI tools, services, versions, and account counts
permanent root-cause fix for the non-writable session-storage lockout, plus an automatic session self-heal safety net
Hosted Redis Control Foundation (report-only) for package-tier access, reseller quotas, monetization hooks, and exposure modes
migration-readiness checks without automatic Redis-to-Valkey migration

v2.3.14

2026-06-13 - Recovery session guidance

Account Recovery rows now highlight accounts affected by Redis plugin session storage issues
Session Fix badge added so administrators can identify the exact accounts needing attention
Repair Session button added beside affected accounts for single-account targeted repair
Scan Sessions keeps the summary panel and refreshes Account Recovery with actionable row state

v2.3.13

2026-06-13 - CloudLinux-safe session diagnostics

WHM Recovery now scans Redis plugin session directories before changing anything
single-account repair and affected-account repair replace the broad all-user reset
healthy accounts are skipped and existing .cpanel permissions, ACLs, and immutable attributes are preserved
cPanel users receive a safe administrator-facing repair message without sensitive filesystem details
CloudLinux, CageFS, Isolates, and PHP Selector detection is logged with repair results

v2.3.12

2026-05-15 - WHM plugin session repair

initial WHM Recovery action added for Redis plugin session directories
server-side repair workflow provided an administrator alternative to manual SSH fixes
repair action is CSRF-protected, rate-limited, and logged in the Redis Manager audit trail
superseded by v2.3.13 targeted scan and affected-account repair

v2.3.11

2026-04-30 - Connection helper, app detection, preflight, and diagnostics

Connection Helper Wizard with ready-to-copy snippets for WordPress, Laravel, Magento, PHP, Node.js, Python, and LiteSpeed Cache
Application Detection scans public_html for WordPress, WordPress + LiteSpeed Cache, Laravel, and Magento
Setup Preflight panel checks instance initialization, running state, and auth readiness
Diagnostics Bundle export produces support-safe JSON with passwords masked
CageFS network namespace fix now applies whenever CloudLinux and CageFS are present

v2.3.10

2026-04-28 - CageFS network namespace fix

CageFS NETWORK_NAMESPACE=0 fix applied whenever CloudLinux and /etc/cagefs/cagefs.conf are present
web server detection removed from the CageFS condition so Nginx and LiteSpeed stacks are covered correctly

v2.3.9

2026-04-26 - Redis Health Score and Smart Suggestions

Health Score out of 100 for each Redis instance with grade labels
Smart Suggestions panel with plain-language recommendations
HealthScore.php added for memory, cache hit ratio, connection, uptime, and auth scoring
Health score shown in cPanel and WHM where relevant

v2.3.8

2026-04-23 - Historical graphs and public site refresh

24-hour and 7-day historical graphs for memory usage, connections, and cache hits versus misses
server-wide WHM usage rollups for shared-hosting Redis monitoring
hourly usage collection with cPanel-readable history mirrors
WHM retention controls for lightweight observability storage
homepage, screenshots, pricing, and documentation refreshed for the current public rollout

v2.3.7

2026-04-23 - Hardening and release integrity

public pricing, release messaging, and upgrade guidance aligned with the active public release path
release checklist added for installer reruns, WHM registration, branding propagation, account discovery, and icon deployment
WHM global configuration updated to support in-panel upgrades with streamed installer logs
config verification documented for successful apply, rollback on invalid changes, and deferred apply on stopped instances

v2.3.6

2026-04-22 - Public rollout for the hosting foundation series

cPanel plugin and WHM plugin shipped together as the public production package
installer and uninstaller updated for clean redeploys, in-place upgrades, and broken-install recovery
hosting foundation features promoted publicly, including packages, reseller groundwork, branding, usage history, and centralized licensing
public commercial rollout established at $4.95 per server per month

Earlier release series

The foundation behind the current public rollout.

Earlier releases introduced the installer, WHM integration, account controls, backup and restore, configuration safety, hosting foundations, and the architecture used by the current Redis Manager package.

v2.3.0 - v2.3.5

Hosting foundation series introducing package controls, reseller groundwork, branding features, usage history foundations, centralized licensing, and stronger migration reliability.

v2.2.0 - v2.2.2

User-control and stability series adding validated configuration editing, backup and restore workflows, health-aware monitoring, and tighter permission enforcement.

v2.1.x

WHM introduction and hardening cycle with server-wide controls, account management, backup and recovery tools, logging improvements, stronger validation, and tighter access control.

v2.0.3 - v2.0.4

Public baseline followed by the foundation rewrite that introduced the installer-driven migration path used by the current Redis Manager architecture.

v2.0.0

First commercial public release, marking the point where UnderHost began offering cPanel Redis Manager as a product for sale.

v1.0.0

Initial internal release used only on UnderHost-managed servers and managed customer environments before the public product line began.

Next step after installation

After deployment, connect Redis to WordPress, Magento, Laravel, custom PHP apps, and other supported workloads.

This documentation covers installation and server management, but the next step is enabling Redis inside the applications that will actually use it. Use the integration guidance for WordPress, WooCommerce, Laravel, Magento, custom PHP sites, APIs, and session-based apps, then follow the roadmap, changelog, and upgrade guide as your deployment evolves.

Get Redis Manager Application guides Open verification guide

Application guides

Connect Redis to the applications running on your server.

Once Redis Manager is installed, the next step is connecting your application to the Redis instance created in cPanel. Use the Redis host, port, password, and database details shown in cPanel exactly as provided.

WordPress & WooCommerce

Object cache and store performance

Use Redis for object caching to reduce repeated database queries, improve page speed, and keep busy WordPress and WooCommerce sites more responsive.

Laravel

Cache, sessions, queues, and rate limiting

Laravel can use Redis for application cache, sessions, queues, and other framework features that benefit from fast in-memory storage.

Magento

High-query store optimization

Magento can use Redis to improve caching behavior, backend responsiveness, and repeated data access for larger storefront workloads.

Generic PHP

Sessions, cache, and repeated lookups

Custom PHP applications can use Redis for sessions, caching layers, tokens, queues, and other repeated data operations that should stay fast.

Node & Python

Fast app-side caching and session storage

Node and Python applications can use Redis for caching, session storage, queue workflows, and repeated request optimization using the connection details provided by Redis Manager.

APIs & Dashboards

Faster repeated responses

Redis can help APIs, admin dashboards, and internal tools reduce backend load and improve response times for repeated requests.

Connection helper

Use the Redis details shown in cPanel

Each Redis instance provides the host, port, password, and database details needed for application setup. Replace the placeholder values below with the exact values shown in Redis Manager.

Host: 127.0.0.1
Port: your assigned Redis port
Password: your Redis AUTH password
Database: usually 0 unless your app uses another DB index

Important note

Redis only helps when the application is configured to use it

Redis Manager provides the Redis service and connection details. Your application must still be configured to use Redis for object caching, sessions, queues, or repeated data access.

Framework snippets

Ready-to-use Redis connection examples

Replace the example values below with the Redis host, port, password, and database shown in your Redis Manager cPanel interface.

WordPress

wp-config.php example

define('WP_REDIS_HOST', '127.0.0.1');
define('WP_REDIS_PORT', 6379);
define('WP_REDIS_PASSWORD', 'your_redis_password');
define('WP_REDIS_DATABASE', 0);

Install a Redis object cache plugin, add these values to wp-config.php, then enable object cache from the WordPress admin area.

Laravel

.env example

CACHE_STORE=redis
SESSION_DRIVER=redis
QUEUE_CONNECTION=redis

REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=your_redis_password
REDIS_PORT=6379
REDIS_DB=0

Update your Laravel .env file, then clear and rebuild configuration cache if needed.

Magento

env.php example

'cache' => [
    'frontend' => [
        'default' => [
            'backend' => 'Cm_Cache_Backend_Redis',
            'backend_options' => [
                'server' => '127.0.0.1',
                'port' => '6379',
                'password' => 'your_redis_password',
                'database' => '0',
            ],
        ],
    ],
],

Magento Redis configuration can vary by version and use case, but this shows the standard cache backend structure.

Generic PHP

phpredis example

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

$redis->set('test_key', 'Hello Redis');
echo $redis->get('test_key');

This is the simplest way to connect from a PHP application using the phpredis extension.

Node.js

redis client example

const { createClient } = require('redis');

const client = createClient({
  socket: {
    host: '127.0.0.1',
    port: 6379
  },
  password: 'your_redis_password',
  database: 0
});

client.on('error', (err) => console.error('Redis Client Error', err));

(async () => {
  await client.connect();
  await client.set('test_key', 'Hello Redis');
  const value = await client.get('test_key');
  console.log(value);
  await client.quit();
})();

Use this pattern for Node applications that need Redis for caching, sessions, or job queues.

Python

redis-py example

import redis

r = redis.Redis(
    host='127.0.0.1',
    port=6379,
    password='your_redis_password',
    db=0,
    decode_responses=True
)

r.set('test_key', 'Hello Redis')
print(r.get('test_key'))

Use this pattern for Python apps, APIs, workers, and background tasks that need Redis access.