What is the best way to run Redis on Kubernetes?

The best approach depends on your requirements. For production environments, we recommend using a Kubernetes operator such as the Redis Operator by Spotahome or OT-Container-Kit, which automate deployment, failover, and scaling. For simpler setups, Bitnami Helm charts provide a well-tested starting point. Key considerations include using StatefulSets for stable network identities, PersistentVolumeClaims for data durability, and proper resource requests/limits for predictable performance.

How does Redis achieve high availability on Kubernetes?

Redis achieves high availability on Kubernetes through Redis Sentinel or Redis Cluster mode. Sentinel monitors master instances and automatically promotes a replica when the master fails, typically completing failover in under 30 seconds. Redis Cluster distributes data across multiple shards with built-in replication. Kubernetes operators manage these topologies by handling pod scheduling, anti-affinity rules, and automated failover orchestration to ensure continuous availability.

Should I use Redis Cluster or Redis Sentinel on Kubernetes?

Redis Sentinel is ideal when your dataset fits on a single node and you need automatic failover with read replicas. It provides a master-replica topology with monitoring and automatic promotion. Redis Cluster is better when you need to shard data across multiple nodes for horizontal scaling, as it automatically partitions data across up to 1000 nodes. On Kubernetes, both are well-supported by operators and Helm charts, but Redis Cluster adds complexity with hash slots and client-side routing.

How do I handle persistent storage for Redis on Kubernetes?

Use PersistentVolumeClaims (PVCs) with StatefulSets to ensure data survives pod restarts and rescheduling. Choose a StorageClass that matches your performance needs — SSD-backed storage is recommended for Redis workloads. Configure Redis with AOF (Append-Only File) persistence for durability, or RDB snapshots for periodic backups. For production, enable both AOF and RDB. Ensure your PVC reclaim policy is set to Retain to prevent data loss during cluster operations.

What resources should I allocate for Redis pods on Kubernetes?

Redis is single-threaded for command processing, so allocate 1-2 CPU cores per pod. Memory should be set to at least 1.5x your expected dataset size to account for fragmentation, copy-on-write during persistence, and output buffers. Set memory requests equal to limits to avoid OOM kills. Use maxmemory configuration to cap Redis memory usage below the pod limit, and configure an appropriate eviction policy (e.g., allkeys-lru for caching workloads).

How do I monitor Redis running on Kubernetes?

Deploy the Redis Exporter as a sidecar container to expose Redis metrics in Prometheus format. Key metrics to monitor include memory usage, connected clients, keyspace hits/misses, replication lag, and command latency. Use Grafana dashboards for visualization and set up alerts for high memory usage, replication disconnects, and elevated latency. Kubernetes-native monitoring with tools like Prometheus Operator and kube-state-metrics provides pod-level health and resource utilization alongside Redis-specific metrics.

Redis on Kubernetes

Redis onKubernetes

In short: Running Redis on Kubernetes means deploying Redis as StatefulSets with stable pod identities and PersistentVolumeClaims for AOF/RDB durability, in either Sentinel (master-replica with auto-promotion) or Cluster (sharded) mode. Operators like Spotahome or OT-Container-Kit — or Bitnami Helm charts — automate failover, anti-affinity placement, and Prometheus monitoring.

Deploy production-grade Redis on Kubernetes with sub-millisecond latency, automated failover, and persistent storage. Operator-managed Redis Cluster and Sentinel for cloud-native in-memory workloads.

Get Started Today Compare Operators

Executive Direct Answer · Redis on Kubernetes Engineering Heuristic

JusDB delivers enterprise Redis on Kubernetes engineering utilizing production-grade operators and cloud-native stateful patterns. Certified Database Reliability Engineers architect multi-pod Sentinel and Cluster consensus, tune host kernel memory (vm.overcommit_memory, disabled THP), configure local NVMe persistent volumes, and orchestrate zero-downtime rolling upgrades backed by contractual 15-minute Sev-1 response SLAs and SOC 2 compliance.

Uptime: 99.99% Availability SLA·Operator: Cloud-Native CRD Orchestrated·Storage: Local NVMe Persistent Volumes·Failover: Sub-5s Sentinel Quorum·Compliance: ISO 27001 & SOC 2

Sub-ms

Latency

Auto-Failover

HA Guarantee

Persistent

Storage

Redis on K8s Architecture

Redis Operator

Lifecycle Management

StatefulSets

Stable Pod Identity

Sentinel / Cluster

HA Topology

PersistentVolumes

Data Durability

Operator-Managed, Cloud-Native Architecture

Comprehensive Redis on Kubernetes Services

From operator deployment to production monitoring, we provide end-to-end Redis on Kubernetes solutions for high-performance in-memory workloads.

Operator Deployment

Deploy and configure Redis operators for automated lifecycle management on Kubernetes

Spotahome Redis Operator setup
OT-Container-Kit operator deployment
Custom Resource Definition (CRD) config
RBAC and service account setup

Helm Chart Management

Production-ready Helm chart deployments with customized values for your environment

Bitnami Redis Helm chart tuning
Custom values.yaml configuration
Helm release lifecycle management
Chart version upgrades and rollbacks

Redis Cluster & Sentinel on K8s

High-availability Redis topologies with automatic failover and data sharding on Kubernetes

Redis Sentinel HA deployment
Redis Cluster with hash slot sharding
Pod anti-affinity and topology spread
Automatic failover orchestration

Storage & Persistence

Persistent storage configuration for Redis data durability across pod restarts and rescheduling

PersistentVolumeClaim configuration
StorageClass selection and tuning
AOF and RDB persistence setup
Volume snapshot and restore policies

Monitoring on K8s

Comprehensive Redis monitoring with Prometheus, Grafana, and Kubernetes-native observability

Redis Exporter sidecar deployment
Prometheus ServiceMonitor setup
Grafana dashboard provisioning
Alerting for latency and memory

Backup & DR

Automated backup strategies and disaster recovery planning for Redis on Kubernetes

Scheduled RDB snapshot backups
Cross-region backup replication
Point-in-time recovery with AOF
Disaster recovery runbooks

The case for K8s

Why Run Redis on Kubernetes?

Kubernetes provides the orchestration layer that makes Redis deployments resilient, scalable, and operationally efficient in cloud-native environments.

Sub-Millisecond In-Memory Performance

Redis delivers sub-millisecond read and write latency for caching, session management, and real-time analytics. Running on Kubernetes with proper resource allocation ensures consistent performance even under heavy load.

Automated Failover & Self-Healing

Kubernetes operators manage Redis Sentinel and Cluster failover automatically. When a master pod fails, a replica is promoted and traffic is rerouted without manual intervention, minimizing downtime to seconds.

Declarative Infrastructure as Code

Define your entire Redis topology as Kubernetes manifests. Operators reconcile desired state continuously, enabling GitOps workflows, reproducible deployments, and consistent environments across dev, staging, and production.

Elastic Scaling

Scale Redis replicas horizontally with a single kubectl command or HPA policy. Redis Cluster mode supports adding shards online with automatic hash slot rebalancing for linear capacity growth.

Redis on K8s Key Metrics

Read Latency(In-memory access)

<1ms

Failover Time(Sentinel auto-promote)

<30s

Throughput(Operations per second)

100K+

Max Cluster Nodes(Redis Cluster mode)

1000

Persistence(Dual durability)

AOF+RDB

Rolling Upgrades(Zero downtime)

Yes

The comparison

Redis Kubernetes Operators Comparison

Choose the right operator or Helm chart for your Redis on Kubernetes deployment based on your requirements and operational maturity.

Full Operator

Redis Operator by Spotahome

Production-grade operator for Redis Sentinel

Redis Sentinel HA management

Automatic failover orchestration

Custom Resource Definitions (CRDs)

Prometheus metrics integration

Pod disruption budget support

TLS and auth configuration

Best for: Sentinel-based HA deployments

Full Operator

OT-Container-Kit Operator

Feature-rich operator for Cluster and Sentinel

Redis Cluster and Sentinel modes

Standalone Redis support

External storage integration

Redis Exporter sidecar built-in

Init container for configuration

Active community and documentation

Best for: Multi-mode Redis deployments

Helm Chart

Bitnami Helm Charts

Battle-tested Helm charts for Redis and Redis Cluster

Standalone, Sentinel, and Cluster charts

Extensive values.yaml customization

Built-in metrics and health checks

NetworkPolicy and PodSecurityPolicy

TLS encryption support

Maintained, widely-deployed Helm charts

Best for: Quick, reliable Helm-based deploys

The Method

Our Redis on Kubernetes Implementation Process

A proven methodology for deploying production-ready Redis on Kubernetes with comprehensive testing and validation.

Assessment & Planning

Analyze workload patterns, data size, latency requirements, and HA needs. Select the optimal Redis topology (Sentinel vs Cluster) and operator or Helm chart strategy.

K8s Deployment

Deploy Redis using your chosen operator or Helm chart. Configure StatefulSets, PVCs, resource limits, network policies, TLS, and authentication for your environment.

Testing & Validation

Run failover simulations, chaos engineering tests, and performance benchmarks. Validate persistence, replication lag, and recovery times against SLA targets.

Production & Observability

Go live with full monitoring via Prometheus and Grafana. Configure alerting, backup schedules, and incident runbooks. Provide training and ongoing support.

Comparative Matrix · Redis on Kubernetes

How JusDB DBRE Kubernetes Engineering compares to alternative paths.

Running stateful Redis on Kubernetes without expert DBRE operators risks unfenced node eviction data loss, Transparent Huge Pages latency stalls, and multi-node drain quorum splits. Here is how our certified cloud-native engineering compares across core evaluation vectors:

Evaluation Vector	JusDB DBRE	In-House DBA	Legacy Agency	Developer Generalist
Operator Selection (OT-CONTAINER-KIT vs Spotlight vs Helm)	Expert architecture and deployment of OT-CONTAINER-KIT, Redis Enterprise, or Spotahome CRDs with custom reconciliation controllers, fine-tuned StatefulSets, and automated failover orchestration.	Deploys generic Bitnami Helm charts with default values; struggles with CRD schema version upgrades and unmanaged pod restart loops.	Installs deprecated operators or static manifests without CRD lifecycle management; manual intervention required for every topology adjustment.	Runs Redis as standard Kubernetes Deployments with ephemeral storage; all data and state are destroyed whenever pods reschedule.
Sentinel / Cluster Multi-Pod Quorum Synchronization	3 or 5-pod odd-quorum Sentinel mesh or 16,384-slot Cluster gossiping across independent availability zones with calibrated down-after-milliseconds to eliminate split-brain states.	Even-numbered Sentinel pods co-located on the same Kubernetes worker nodes; network partitions cause 50/50 quorum deadlocks.	Single Sentinel instance monitoring pods; transient container restarts disable automatic failover cluster-wide.	Sentinel co-located inside the Redis container; pod eviction simultaneously terminates both data node and quorum voter.
Local NVMe vs StorageClass StatefulSet Topology	High-IOPS local NVMe persistent volumes with local-storage StorageClasses and volumeBindingMode: WaitForFirstConsumer, paired with non-blocking AOF/RDB persistence and zero EBS latency spikes.	Generic network-attached cloud block storage (gp3/pd-standard) subject to burst-balance exhaustion and high p99 fsync latency stalls.	Default dynamic PVC provisioning without tuning reclaim policies or volume binding modes; volume detach stalls lock pods in Terminating states.	emptyDir ephemeral storage; full data loss on pod restart with zero persistence recovery path.
Zero-Downtime Rolling Stateful Upgrades	Orchestrated rolling upgrades leveraging PodDisruptionBudgets (maxUnavailable: 1), replica-first failover promotion, and pre-stop lifecycle hooks preventing client request drops.	Manual kubectl rollout restart causing simultaneous primary restarts, write rejections, and uncoordinated Sentinel elections.	Scheduled complete cluster maintenance shutdowns; services experience 30+ minutes of total application cache unavailability.	Triggering default StatefulSet rolling updates without failover coordination; primary pod killed abruptly while serving production writes.
Anti-Affinity & Multi-AZ Failure Domain Scheduling	Strict requiredDuringSchedulingIgnoredDuringExecution podAntiAffinity and topologySpreadConstraints across availability zones (topology.kubernetes.io/zone) preventing correlated node failures.	Soft preferred anti-affinity rules allowing Kubernetes scheduler to pack multiple primary and replica pods onto a single degraded node.	Default scheduler configuration without topology spread; node drains during cluster autoscaling take down entire Redis shards.	Zero affinity rules; all Redis pods scheduled onto the same spot instance, resulting in simultaneous catastrophic cluster death.
Cloud-Native Prometheus & Redis Exporter Telemetry	Co-located Redis Exporter sidecars, custom Prometheus ServiceMonitors, Grafana SLO dashboards, and alerts for replication lag, memory fragmentation, and O(N) slowlogs.	Basic Kubernetes pod CPU and memory alerts; blind to internal Redis event-loop stalls, replication buffer drops, and command latency.	Third-party APM agents injecting heavy polling overhead into single-threaded Redis processes.	No Redis-specific metrics; discovers memory exhaustion only after the Linux kernel OOM killer terminates the pod.

Kubernetes Failure Modes

Critical Redis on Kubernetes Risks We Eliminate

Operating in-memory Redis inside containerized Kubernetes clusters introduces kernel, scheduling, and quorum failure vectors. We engineer resilience into every layer to eliminate these production risks:

P1 Critical

Node Eviction Triggering Unfenced Primary Failover & Data Loss

During Kubernetes cluster autoscaling or node pool maintenance, a node draining operation abruptly terminates a Redis primary pod without fencing writes. Clients continue writing to the evicted pod until timeouts fire, resulting in un-replicated write loss when Sentinel promotes a replica.

JusDB Engineering Mitigation:

JusDB configures preStop container lifecycle hooks that execute redis-cli failover prior to SIGTERM, pairs pods with strict PodDisruptionBudgets (PDBs), and tunes min-replicas-to-write to fence orphaned primaries.

P1 Critical

Transparent Huge Pages (THP) Latency Jitter & Memory Bloat

Kubernetes worker nodes running Linux kernels with Transparent Huge Pages (THP) enabled force memory allocation into 2MB pages. When Redis executes background BGSAVE or AOF rewrites, Copy-on-Write (COW) memory allocation triggers extreme latency spikes up to hundreds of milliseconds and severe memory fragmentation.

JusDB Engineering Mitigation:

JusDB deploys privileged initContainers or DaemonSets on Redis node pools to permanently disable THP via echo never > /sys/kernel/mm/transparent_hugepage/enabled and tune vm.overcommit_memory=1 at boot.

P2 High

Sentinel Quorum Split During Simultaneous Multi-Node Drain

Cluster upgrades draining multiple worker nodes concurrently terminate a majority of Sentinel pods if anti-affinity or topology spread rules are omitted. Without quorum (e.g., 2 out of 3 Sentinels lost), Sentinel cannot elect a new primary during pod restarts, freezing write traffic indefinitely.

JusDB Engineering Mitigation:

JusDB enforces strict podAntiAffinity and topologySpreadConstraints across availability zones, ensuring no two Sentinel pods share a single failure domain or node, and mandates odd-numbered 3 or 5-pod monitor topologies.

Telemetry Runbooks · Kubernetes & Sentinel Diagnostics

Our DBREs execute non-blocking diagnostic commands to inspect Redis Kubernetes custom resources, pod placement, and Sentinel cluster quorum integrity:

Kubernetes: Redis Pod & StatefulSet Health Telemetry

Kubectl · Pod & CRD Telemetry

Inspects Redis custom resource definitions (CRDs), StatefulSet status, pod readiness, node distribution, and restart counts in the Redis namespace.

# 1. Inspect Redis custom resources and pod placement across worker nodes
kubectl get redis,pods -n redis-system -o wide

Redis: Sentinel Monitored Masters & Quorum Verification

Sentinel · Quorum Audit

Connects to the Sentinel cluster to verify monitored master status, replica link states, and tests that sufficient quorum exists to authorize a primary failover.

# 1. Query Sentinel for primary status, IP address, and connected replica count
redis-cli -p 26379 sentinel master mymaster

# 2. Verify that Sentinel quorum is satisfied and failover voting can proceed
redis-cli -p 26379 sentinel ckquorum mymaster

FAQ

Redis on Kubernetes — Frequently Asked Questions

Common questions about deploying, managing, and scaling Redis on Kubernetes.

Ready to Deploy Redis on Kubernetes?

Let our experts deploy and manage production-grade Redis on your Kubernetes cluster with automated failover, persistent storage, and comprehensive monitoring.

Start Your Project Schedule Consultation

Related Redis Services

Explore more ways our Redis experts can help with your database infrastructure.

Redis Consulting Redis Migration

View all Redis services