Server configuration
Set up Redis memory, connections and access for WordPress object caching, with matching WordPress settings and Ubuntu commands.
Free, no sign-up. It runs in your browser, so nothing you type is sent to this site.
Nothing you enter leaves your browser.
This tool runs in your browser and needs JavaScript. Turn JavaScript on and reload the page.
This browser cannot make secure random credentials, so the generator is not available. Use a current browser, and open the page over HTTPS.
Choose Ubuntu 24.04 LTS or 26.04 LTS. The configuration and install commands follow this target.
Run the script without arguments to check candidates and simulate installation. Use --install to apply the selected repository and package setup on that Ubuntu server. Review the deployment guide before installing on an existing host.
The initial defaults use the 8 GiB profile. Your Ubuntu version and server preset are remembered across these generators; passwords and other configuration values are never saved in browser storage. Capacities are modelled in GiB (1024 MiB). Larger caches help when they hold useful data; more connections do not make an individual request faster. Compare uncached response time, PHP queueing, database reads, cache hit rates and peak RSS under representative traffic. These are sizing examples, not measured speed claims. Page caching remains opt in until invalidation and private-session exclusions are verified; order durability stays enabled.
Understand what each setting controls. Expand a recommendation for the reasoning and the official reference. Credentials are made in this browser; the page does not contact Redis, send values or keep them after you reload. 70 settings explained.
Checked 15 October 2026. The server family follows your Ubuntu release and package source. Official repository reference: Redis Open Source 8.10 (opens in a new tab) and Redis Object Cache 3.0.0 (opens in a new tab). Standalone Linux, dedicated object-cache instance.
Reserve this instance's budget after accounting for PHP, MariaDB, the OS and other services.
The example adds maxmemory, the selected overhead percentage, the client memory threshold and 64 MiB of base allowance. When disk persistence is selected, it adds another 100% of maxmemory as a copy-on-write planning allowance.
These figures are assumptions. Redis limits are not all preallocated, persistence and large operations vary, and maxmemory is not a hard RSS limit. Inspect peak resident memory, swapping, eviction and client disconnections under representative traffic. This page does not change service or cgroup memory limits.
Section 1 of 6
Plan a Redis instance dedicated to your WordPress site or trusted multisite network.
Separate it from queues, sessions and locks. Database numbers and prefixes are not independent instances.
Controls: Names this cache instance and suggests file paths and a readable prefix. It does not configure DNS.
Keep production and staging separate. Changing this name updates only paths and names that still match the previous suggestions.
WordPress object cache (opens in a new tab)Controls: Selects the WordPress or WooCommerce review checklist.
This is an object cache. Orders, payments and inventory remain authoritative in the application database.
WooCommerce performance (opens in a new tab)Controls: Identifies the current stable server version used by this configuration baseline.
Use the current patched build. This page targets a standalone Linux instance; Sentinel, Cluster and managed-provider policy need their own topology settings.
Redis 8.10 release notes (opens in a new tab)Controls: Keeps this cache separate from queues, sessions, locks and other sites that cannot share a database flush.
The plugin uses FLUSHDB for a normal full flush. Key prefixes and logical database numbers do not provide tenant or resource isolation. Only database 0 is enabled in this recipe.
Redis Object Cache 3.0.0 implementation (opens in a new tab)Controls: Planning allowance available to the whole Redis process, after reserving RAM for PHP, MariaDB, the OS and other services.
Enter the effective service or cgroup limit if it is lower. The generator cannot detect server RAM and does not change a systemd memory limit.
Redis memory limits and eviction (opens in a new tab)Controls: Checks the optional I/O thread count against the CPU allocation.
Extra I/O threads help only after network I/O becomes a measured bottleneck; command execution is not made parallel by this setting.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: dir
Controls: Working directory for optional RDB and AOF files. It must exist and be writable by the service account.
Use a dedicated service identity or permissions appropriate to your host. Keep persistence files outside website roots and preserve them during configuration changes. Use a folder just for this instance, not /var/lib/redis, which the Ubuntu redis-server service already uses. Redis will not start until the folder exists.
Redis persistence (opens in a new tab)Redis setting: aclfile
Controls: Absolute server path to the users.acl file generated with this bundle.
The config and ACL file must be deployed together. Grant only the Redis service and authorized operators access; the WordPress PHP worker does not need to read it. The configuration file goes in the same folder, so use a folder just for this instance, not /etc/redis. Redis will not start without this file.
Redis ACLs (opens in a new tab)No settings are available in this section with the current choices.
No matching settings in this section.
Section 2 of 6
Set a useful cache limit while reserving memory for clients, fragmentation and background work.
maxmemory is not an RSS limit. Observe real memory and eviction behavior under representative traffic.
Redis setting: maxmemory
Controls: The Redis maxmemory threshold used by the selected eviction policy. It is not a hard process-RSS limit.
Allocator fragmentation, client buffers and persistence work need additional RAM. Check used_memory, used_memory_rss, evictions and cache misses under real traffic.
Redis memory limits and eviction (opens in a new tab)Redis setting: maxmemory-policy
Controls: Chooses which keys Redis removes when the memory threshold is exceeded.
Object-cache entries must be disposable. LRU favors recently used keys; LFU favors frequently used keys; LRM tracks modification recency. Noeviction instead rejects memory-growing writes, which can surface as application errors.
Redis memory limits and eviction (opens in a new tab)Redis setting: maxmemory-samples
Controls: Number of candidate keys sampled for approximate eviction decisions.
More samples can improve approximation at a CPU cost. Measure hit rate and latency before changing it. Volatile-only policies are omitted because many WordPress keys have no TTL.
Redis memory limits and eviction (opens in a new tab)Controls: Extra allowance over maxmemory for fragmentation and allocations in the illustrative memory model.
This is not a Redis directive or a measured ceiling. Some workloads require more; compare peak RSS and actual allocation behavior.
Redis memory limits and eviction (opens in a new tab)Redis setting: maxmemory-clients
Controls: Uses maxmemory-clients to disconnect the largest client buffers when aggregate client memory grows too far.
The threshold is not reserved in advance and may be exceeded temporarily. Disconnections can fail requests, so test large cached objects and imports.
Redis client memory limits (opens in a new tab)Redis setting: lazyfree-lazy-eviction
Controls: Offloads eligible value-memory reclamation during eviction to background work.
This reduces some synchronous free work, but pending frees can temporarily raise memory use. Watch lazyfree_pending_objects and latency.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: lazyfree-lazy-expire
Controls: Offloads eligible expired-value reclamation.
Expiry still follows key TTLs. Background freeing does not increase available physical RAM or guarantee a latency improvement.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: lazyfree-lazy-user-flush
Controls: Makes a plain FLUSHDB release old values asynchronously; keys disappear from the selected database immediately.
This does not make flushing prefix-scoped. A full WordPress flush still affects the entire selected database and may briefly increase pending-free memory.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: activedefrag
Controls: Enables active allocator defragmentation when the Redis build supports it.
Requires a compatible jemalloc build. Check allocator and fragmentation metrics first; it adds CPU work and is not a substitute for headroom. The Ubuntu redis-server package is not built for it, and Redis will not start if it is enabled there. The Redis official repository build uses Redis’s own jemalloc.
Redis 8.10 configuration reference (opens in a new tab)No settings are available in this section with the current choices.
No matching settings in this section.
Section 3 of 6
Use a local socket or a restricted listener, with certificate verification for remote PHP.
Authentication is always required. TLS and Unix permissions complement the ACL rules.
Controls: Uses a local Unix socket, loopback-only TCP, or a TLS-only private-network listener.
All modes require ACL credentials. Public wildcard binding and remote plaintext TCP are not generated. Firewall restrictions remain a host responsibility.
Redis security (opens in a new tab)Redis setting: unixsocket / WP_REDIS_PATH
Controls: Local endpoint used by Redis and WP_REDIS_PATH. TCP is disabled in this mode.
Create nothing by hand: the generated service unit makes the socket folder at every boot, because /run is cleared on restart. Use a file inside a folder reserved for this cache, such as /run/redis-sites/example.com/redis.sock. The PHP worker needs directory traversal and socket read/write access through a deliberate group.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: unixsocketperm
Controls: Limits access to the Unix socket file. Parent-directory permissions are configured separately.
Do not make the socket world-writable. Review group membership and directory ownership; a file mode alone does not grant access through the parent directories.
Redis security (opens in a new tab)Redis setting: port
Controls: Redis TCP port on 127.0.0.1, also used by the WordPress snippet.
A port change is not an access control. This mode stays on loopback; choose TLS for a separate application host. Port 6379 belongs to the redis-server service that the Ubuntu package starts when it is installed, so a second instance cannot use it.
Redis security (opens in a new tab)Redis setting: bind
Controls: The private address on this Redis host used by the TLS listener.
Only RFC1918 IPv4 addresses are accepted here. Permit the actual application hosts at the firewall and verify that the client hostname resolves to this server. Redis will not start if the server does not have this address; the generated service waits for the network to be online first.
Redis security (opens in a new tab)Redis setting: tls-port
Controls: Encrypted listener used by remote clients; the plaintext port is set to 0.
Use a Redis build with TLS support. Authentication remains required even when TLS or client certificates are enabled.
Redis TLS (opens in a new tab)Redis setting: WP_REDIS_HOST
Controls: Hostname used by the PHP client for connection, certificate-name verification and TLS peer identity.
Resolve this name to the private Redis interface. Do not disable peer or peer-name verification to work around certificate errors.
Redis TLS (opens in a new tab)Redis setting: tls-cert-file
Controls: Server-side path to the public certificate chain for Redis TLS.
The generator only accepts paths; it does not create or install certificates. Ensure the service can read the file and the chain matches the configured key. Redis will not start if the file is missing or the redis account cannot read it.
Redis TLS (opens in a new tab)Redis setting: tls-key-file
Controls: Server-side path to the key corresponding to the Redis certificate.
Keep key content out of this form and outside website directories. Only the service identity and authorized operators should read it. Redis will not start if the file is missing or the redis account cannot read it.
Redis TLS (opens in a new tab)Redis setting: tls-ca-cert-file
Controls: CA bundle used by the Redis TLS context and optional client-certificate verification.
Server and client files may live at different paths. PHP also needs its own trusted CA file. Redis will not start if the file is missing or the redis account cannot read it.
Redis TLS (opens in a new tab)Redis setting: WP_REDIS_SSL_CONTEXT
Controls: Trusted CA bundle emitted into WP_REDIS_SSL_CONTEXT with peer checks enabled.
Use an absolute path readable by PHP. The snippet keeps verify_peer and verify_peer_name true, and allow_self_signed false.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: tls-auth-clients
Controls: Adds mutual TLS on top of ACL authentication.
Enable only when application and administration clients have valid client certificates signed by the server’s trusted CA.
Redis TLS (opens in a new tab)Controls: Certificate the WordPress PHP connection presents for mutual TLS.
Every PHP worker that connects must be able to read the configured certificate and key. Administration clients need their own client identity.
Redis Object Cache 3.0.0 settings (opens in a new tab)Controls: Private key for the PHP client’s mutual-TLS certificate.
Do not put the key in public uploads or this browser. The generated snippet contains a path only.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: maxclients
Controls: Caps accepted client connections for the instance.
Persistent PHP connections can remain open per worker. Include cron, CLI, health checks and operations, and confirm the service file-descriptor limit.
Redis client memory limits (opens in a new tab)Redis setting: tcp-keepalive
Controls: Helps detect dead TCP peers; it does not configure application read timeouts.
The value has no effect on Unix sockets. Tune using observed network failure behavior rather than lowering every timeout together.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: timeout
Controls: Disconnects idle clients when nonzero; 0 leaves idle connections open.
Aggressive idle timeouts can clash with persistent connections and reconnect handling. App connect/read timeouts are separate controls.
Redis client memory limits (opens in a new tab)Redis setting: client-output-buffer-limit normal
Controls: Disconnects a normal client if its queued output exceeds this threshold.
Slow readers and large cached responses can hit it. This is an output-buffer limit, not a maximum stored-value size.
Redis client memory limits (opens in a new tab)Controls: Output threshold that must remain exceeded for the soft-limit duration before disconnecting a normal client.
Test bulk cache retrievals and imports. A smaller limit can turn large legitimate responses into disconnections.
Redis client memory limits (opens in a new tab)Controls: How long a client can stay above the configured soft output threshold.
Monitor slow client behavior and request errors; connection drops can surface in WordPress.
Redis client memory limits (opens in a new tab)No settings are available in this section with the current choices.
No matching settings in this section.
Section 4 of 6
Use a cache identity for WordPress and a separate, privileged identity for operations.
Passwords are generated in this browser. The ACL file stores SHA-256 verifiers; exports include private credentials.
Controls: Dedicated Redis identity used by the WordPress object-cache connection.
This user gets the explicit cache command allowlist and key prefix. It cannot configure Redis, administer ACLs, shut down the service or FLUSHALL.
Redis ACLs (opens in a new tab)Controls: Secret used by the PHP client; its SHA-256 verifier is stored in users.acl.
Generation uses browser cryptographic randomness. Downloads contain the PHP credential and a private credentials file; save them securely.
Redis ACLs (opens in a new tab)Controls: Privileged operator identity, kept separate from application credentials.
This operator can change server state. The WordPress snippet contains only the application identity. Store this credential outside WordPress.
Redis ACLs (opens in a new tab)Controls: Secret for privileged Redis administration. The ACL file holds a SHA-256 verifier.
The private credentials.txt export records both secrets for delivery to your secure credential store. This page does not persist or transmit them.
Redis ACLs (opens in a new tab)No settings are available in this section with the current choices.
No matching settings in this section.
Section 5 of 6
Generate matching settings for Redis Object Cache, with explicit connection and cache behavior.
This does not cache HTML pages or make orders authoritative in Redis. Preserve application cache invalidation.
Redis setting: WP_REDIS_PREFIX
Controls: Namespace used by WP_REDIS_PREFIX and the application ACL key pattern.
Changing it leaves old keys behind. Prefix patterns do not restrict FLUSHDB, INFO or SCAN metadata; instance isolation is still required.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: databases / WP_REDIS_DATABASE
Controls: Database selected by the plugin; this recipe enables exactly one logical database.
All clients share the same eviction budget and server process. Different logical database numbers are not independent services or security boundaries.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_CLIENT
Controls: Chooses the client used by Redis Object Cache 3.0.0.
Install a compatible client and the plugin/drop-in before using the snippet. This page generates configuration only and does not install PHP extensions.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_TIMEOUT
Controls: Time allowed to establish the Redis connection.
Use a finite value and test cache failure behavior. Very short limits can fail healthy connections; long limits can stall checkout during an outage.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_READ_TIMEOUT
Controls: Time the plugin’s client waits for Redis responses.
Check slow commands, network latency and fork pauses before simply increasing this. It is not a PHP request timeout.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_PERSISTENT
Controls: Reuses supported client connections across PHP requests.
Persistent connections can reduce connection setup but remain open per worker. A unique connection identifier is emitted when enabled to avoid sharing connection state between sites.
Redis Object Cache 3.0.0 settings (opens in a new tab)Controls: Stable identifier used for this site’s persistent PHP connection pool.
Different credentials, TLS modes or environments should not share the same connection identity. Restart workers when changing connection semantics.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_MAXTTL
Controls: Optional upper limit on object-cache expiration; 0 leaves the plugin’s cap disabled.
The plugin and application own cache invalidation. Forcing a short cap does not fix stale-data bugs, and cached values are separate from database retention.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_IGBINARY
Controls: Requests the igbinary extension for object serialization.
Every reader and writer must understand the same format. Coordinate a controlled cache flush when changing serializers; mixed formats can break cached values.
Redis Object Cache 3.0.0 settings (opens in a new tab)Controls: Records that all relevant PHP workers have igbinary support and the format transition has been planned.
CLI and PHP-FPM can load different extensions. Do not infer readiness from a browser checkbox alone; test on staging.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_IGNORED_GROUPS
Controls: Groups the plugin should keep request-local rather than persist in Redis, one group per line.
Use the exact names documented by the responsible plugin. Broadly excluding WooCommerce groups can remove useful caching without fixing incorrect invalidation.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_DISABLE_BANNERS
Controls: Changes Redis Object Cache admin presentation.
This is not a security, correctness or performance optimization.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_DISABLE_METRICS
Controls: Turns off the plugin’s own metrics collection and display.
Redis server metrics remain separate. Turn off plugin metrics only when you deliberately prefer less collection or have another observability source.
Redis Object Cache 3.0.0 settings (opens in a new tab)Redis setting: WP_REDIS_DISABLED
Controls: Emits the plugin’s emergency switch to bypass its Redis cache.
Keep an outage procedure and account for the extra database load. The server itself is not stopped and existing Redis keys are not deleted.
Redis Object Cache 3.0.0 settings (opens in a new tab)Controls: Leaves unsupported failure suppression and selective Lua flushing out of the snippet.
The plugin authors mark these options unsupported and warns of corruption or slow flushing. The generator does not treat either as a routine optimization.
Redis Object Cache 3.0.0 settings (opens in a new tab)No settings are available in this section with the current choices.
No matching settings in this section.
Section 6 of 6
Choose disk persistence deliberately and gather the evidence needed to tune the cache.
A cold cache increases database load. Test restart, outage and warm-up behavior before deployment.
Controls: Chooses no disk persistence, RDB snapshots, AOF logging, or both.
Persistent object caching means sharing objects across PHP requests; it does not require disk persistence. Restarting an unpersisted cache is cold. Durable queues and authoritative application data need a separate design.
Redis persistence (opens in a new tab)Redis setting: save
Controls: Snapshot rule interval, subject to the minimum changed-key count.
Forking and copy-on-write need RAM headroom. Existing RDB files must be reviewed even after snapshot scheduling is disabled.
Redis persistence (opens in a new tab)Controls: Changed-key threshold paired with the snapshot interval.
A rule is eligible only when both time and changes conditions are met. RDB snapshots can lose changes since the last completed save.
Redis persistence (opens in a new tab)Redis setting: appendfsync
Controls: Controls when append-only log writes are synchronized to storage.
Everysec can lose about a second of recent writes on failure. Always costs more I/O. Neither makes WordPress orders authoritative in Redis. Fsync is not disabled during rewrites.
Redis persistence (opens in a new tab)Redis setting: auto-aof-rewrite-percentage
Controls: Schedules a rewrite after sufficient AOF growth above the previous base size.
Monitor rewrite duration, free disk, fork pauses and copy-on-write memory. Rewrites do not eliminate the need for storage capacity planning.
Redis persistence (opens in a new tab)Redis setting: auto-aof-rewrite-min-size
Controls: Minimum AOF size before automatic rewrite can be triggered.
Smaller thresholds can cause frequent rewrites. Existing AOF files and restart behavior require deliberate review when switching persistence modes.
Redis persistence (opens in a new tab)Redis setting: io-threads
Controls: Thread count for socket reads, writes and protocol processing in the target release.
Use more only with sufficient CPU and load-test tail latency. No legacy io-threads-do-reads flag is emitted.
Redis 8.10 configuration reference (opens in a new tab)Controls: Writes logs to standard output for the service manager, or to a protected file.
The generated config keeps daemonize no and supervised no; let the actual service unit own process supervision and adapt it explicitly.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: logfile
Controls: Writable server-side file for Redis log messages.
Create the directory with service permissions and configure host log rotation. The generator creates neither files nor rotation jobs on your server. Redis will not start if the folder does not exist or the redis account cannot write to it.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: loglevel
Controls: Verbosity of Redis server log messages.
Use verbose or debug only for a bounded investigation. More logs can increase disk use and expose operational details.
Redis 8.10 configuration reference (opens in a new tab)Redis setting: slowlog-log-slower-than
Controls: Server execution time required to record a command in the slow log; 10000 microseconds is 10 ms.
The slow log excludes network I/O. It can contain command arguments and sensitive values; restrict access and do not publish raw entries.
Redis latency diagnosis (opens in a new tab)Redis setting: slowlog-max-len
Controls: Number of slow command records kept in Redis memory.
Use bounded collection and an operations account. This is not application request tracing or a latency service-level guarantee.
Redis latency diagnosis (opens in a new tab)Redis setting: latency-monitor-threshold
Controls: Records Redis internal latency events above this threshold; 0 disables monitoring.
Use LATENCY LATEST and related diagnostics to investigate event-loop stalls and fork delays alongside application timing.
Redis latency diagnosis (opens in a new tab)Redis setting: key-memory-histograms
Controls: Enables per-type memory-allocation histogram information in INFO keysizes on the current Redis target.
This startup setting adds instrumentation. WordPress object-cache values are generally serialized strings; Compact Hash and search/vector features do not automatically optimize those values.
Redis 8.10 configuration reference (opens in a new tab)No settings are available in this section with the current choices.
No matching settings in this section.
Matching server, ACL and WordPress settings, ready for review.
Private bundle. The WordPress snippet and the credentials file contain passwords. Save the bundle you intend to use somewhere safe before you close or reload this page, because new credentials are made each time. Keep exports outside website directories and public repositories.
Use a dedicated cache instance and review the service unit, permissions, TLS files and memory budget. Test in isolation before deployment. This page does not install Redis, enable the WordPress drop-in or change a server.
install-ubuntu.sh --install first. It installs the packages and creates the instance folders that are missing. Redis will not start without the folder of redis.conf and users.acl, the data folder, the log folder (when logging to a file) and the TLS files (in TLS mode).redis.conf and users.acl together, then install redis-site.service. The service unit makes the Unix socket folder at every start, because /run is cleared on restart. Keep WordPress's operations credential separate.wp-redis-config.php before wp-settings.php loads, removing duplicate definitions. Install the Redis Object Cache plugin and a compatible PHP client, then use its supported drop-in activation flow.wp redis status, the read-only diagnostics and staging application tests. Coordinate service and PHP worker restarts when changing endpoints, credentials or serializers.The application ACL restricts ordinary keyed operations to the configured prefix. Full plugin flushes use FLUSHDB, which is not constrained by that prefix. INFO and SCAN can reveal metadata too. Use this recipe only for one dedicated site or trusted multisite cache boundary.
Keep orders, payments and inventory authoritative in MariaDB. Test products, pricing, coupons, cart, checkout, stock, refunds, callbacks, administration and scheduled jobs with warm, cold and unavailable cache states. Preserve the application's invalidation and documented non-persistent groups.
Object caching shares application values between PHP requests. It does not create public HTML caching, enable HPOS or replace private-page cache exclusions. Queues, locks and durable sessions belong on a separately designed Redis instance with an appropriate persistence and eviction policy.
The generated snippet includes ACL username and password authentication, transport, prefix, database, timeouts, optional persistent connections, igbinary and supported preferences. The plugin's unsupported WP_REDIS_GRACEFUL and WP_REDIS_SELECTIVE_FLUSH are left out. The emergency bypass stays available as WP_REDIS_DISABLED.
Plugin configuration reference (opens in a new tab), WooCommerce performance (opens in a new tab)
The cache can be shared across PHP requests while remaining disposable across Redis restarts. RDB and AOF are optional warm-start choices here. Enabling them adds disk, fork and copy-on-write requirements. Disabling them does not delete old files; review startup behavior and existing RDB and AOF data before changing modes.
The current target supports all-keys LRU, LFU and LRM eviction (LRM from Redis 8.6), ACL password verifiers, bounded client memory, background freeing, optional I/O threads, TLS and memory histograms (from Redis 8.6). Compact Hash and search, vector and JSON features do not automatically improve serialized WordPress cache values, so unrelated modules are not loaded.
Review peak RSS, evictions, hit and miss deltas, rejected connections, pending frees, slow commands, fork delays and application timing. Slow logs can contain sensitive arguments. The read-only diagnostics avoid KEYS *, MONITOR and cache-changing commands.
Memory and eviction (opens in a new tab), Persistence tradeoffs (opens in a new tab)
Select the Ubuntu version, package source and memory profile, leaving room for the other services on the server.
Choose the connection method, authentication, memory limit, eviction policy and persistence.
Install the packages, check the generated files and set up a compatible WordPress object cache plugin before you test the connection.
This free Redis config generator targets WordPress object caching on Ubuntu 24.04 LTS and 26.04 LTS. It writes the server settings next to the matching WordPress connection values, so the socket or host, the login details and the cache prefix can be checked together. Memory and eviction choices stay editable for your real workload.
A Redis server on its own does not turn on WordPress object caching: you also need a compatible object cache plugin or drop-in. An object cache is not a full page cache. Never expose Redis to the internet without authentication, and do not use cache eviction settings for data that must never be lost. Files that hold passwords or access list secrets must stay private.
Build database, security and WordPress settings.
Plan database memory and connection settings.
Choose PHP extensions and runtime settings.
StackMattic sponsors these free tools. If you would rather not set up and look after the server yourself, StackMattic runs managed WordPress and server hosting.