Free audit

View Audit Scope
Valkey on K8sOperators & Helm · Pinned QoS · EKS / GKE / AKS

Valkey on Kubernetes Consulting & SRE Services

JusDB designs, deploys, and operates production Valkey 8.0 clusters on Kubernetes across Amazon EKS, Google GKE, Azure AKS, and bare-metal OpenShift. Our engineers configure Valkey Operators and Bitnami/community Helm charts, enforce Pinned QoS pod memory limits with 30% copy-on-write BGSAVE headroom, pin StatefulSet replicas across failure zones, and automate rolling upgrades with PodDisruptionBudgets.

The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance.

  • NDA before access
  • Read-only by default
  • Written scope before work starts

Valkey on Kubernetes operational controls

Select a K8s subsystem to inspect

cgroup v2 Memory & CoW Headroom

maxmemory = 68% Limit

Kubernetes OOMKills any Valkey pod with Exit Code 137 the instant RSS + BGSAVE copy-on-write fork pages + client buffers exceed resources.limits.memory.

We enforce Pinned QoS (requests == limits), disable worker-node THP via DaemonSet/NodeConfig, and cap valkey.conf maxmemory at 65-70% of the pod memory limit.

Inspect Valkey StatefulSet & cgroup manifest

Verified against Kubernetes cgroup v2 and Valkey 8.0 StatefulSet specifications.

Kubernetes stacks covered
Amazon EKS, Google GKE, Azure AKS, OpenShift, Valkey Operators, Bitnami Helm charts, and Karpenter node pools
Initial-response targets
15 minutes for a critical (P1) incident under a 24x7 support agreement; 2 to 4 hours in business hours. See details
Coverage hours
Business hours (03:30–12:30 UTC) by default; 24x7 on-call available under a 24x7 support agreement

Selected clients

  • Innoviti
  • Blitz
  • Freecharge
  • Nango
  • Recochain
  • Screen Facts
  • Nexora
  • WeCredit

Production failure modes

Common Valkey on Kubernetes failures we resolve

Kubernetes treats containers as disposable processes, whereas stateful Valkey clusters depend on stable peer identities, unthrottled event loops, and cgroup headroom for copy-on-write forks.

Valkey on Kubernetes production symptoms, root causes, and first diagnostic actions
Kubernetes / Valkey signalWhat is usually happeningWhere we start
OOMKilled (Exit 137)Valkey primary pod killed by kubelet during RDB BGSAVE or AOF rewriteHelm chart sets maxmemory to 90-99% of resources.limits.memory. When BGSAVE forks, copy-on-write pages and replica output buffers push cgroup memory past the pod limit.Set Pinned QoS (requests == limits), lower maxmemory to 65-70% of pod RAM limit, enable lazyfree-lazy-*, and disable Transparent Huge Pages on the K8s node pool.
CLUSTERDOWN on RescheduleRolling node upgrade or pod restart leaves Valkey Cluster slots unassignedHardcoded Pod IPs in nodes.conf become unreachable after pod replacement, or the kubelet evicts both the primary and replica of the same hash-slot range before failover finishes.Configure Valkey 8.0 cluster-preferred-endpoint-type hostname with a headless Service, enforce anti-affinity per shard pair, and add a preStop failover hook.
CFS CPU Throttlingp99 latency spikes to 25ms+ despite low average node CPU utilizationSetting a tight Kubernetes CPU limit (resources.limits.cpu) on a Valkey 8.0 pod running io-threads causes the Linux CFS scheduler to throttle all threads within the 100ms quota period.Inspect container_cpu_cfs_throttled_periods_total in Prometheus, remove hard CPU limits or use static CPU Manager policy (cpuset) on dedicated cache worker nodes.
PVC Attach DeadlockRescheduled Valkey pod stays stuck in ContainerCreating / Multi-Attach errorDuring an abrupt EC2/GCE node failure, the cloud CSI driver takes minutes to detach the ReadWriteOnce EBS/PD volume while Sentinel or Cluster has already promoted a new primary.Configure node-problem-detector taint eviction timeouts, evaluate local NVMe ephemeral storage with anti-affinity replicas, and tune repl-diskless-sync.
CoreDNS & conntrack DropsIntermittent ETIMEDOUT and connection resets from microservice podsHigh-churn short-lived connections from serverless or PHP/Python pods exhaust node nf_conntrack tables and flood CoreDNS with 5-tuple search-path lookups.Deploy NodeLocal DNSCache, set ndots: 2 on client workloads, enable persistent connection pooling with TCP keepalives, and tune kube-proxy IPVS mode.
Probe Failover Loopkubelet livenessProbe restarts a busy Valkey pod during dataset load or AOF rewriteAn aggressive 1-second valkey-cli PING livenessProbe times out during startup RDB loading or a brief Lua stall, causing kubelet to kill and restart the pod in a loop.Separate startupProbe (allowing large RDB/AOF load times) from livenessProbe, increase timeoutSeconds >= 5, and gate traffic routing on readinessProbe.

Technical scope

What does our Valkey on Kubernetes service include?

We engineer production-grade Valkey StatefulSets, Operator CRDs, worker node sysctl profiles, and GitOps upgrade pipelines tailored to your EKS, GKE, or AKS environment.

  • Valkey Operator & Helm chart architecture

    We select, customize, and harden the right Kubernetes deployment controller for your topology, whether standalone, Sentinel HA, or 16,384-slot Valkey Cluster.

    • Deploy and audit Hyperspike Valkey Operator, OT-Container-Kit, or Bitnami Valkey Helm charts
    • Configure GitOps-ready ArgoCD and Flux manifests with immutable ConfigMap checksums

    Valkey Operator · Bitnami Helm · StatefulSet · ArgoCD / Flux

    Valkey Cluster engineering
  • Pinned QoS, cgroup v2 & OOM immunity

    Container cgroups do not forgive memory spikes. We model pod memory limits against dataset heap, jemalloc fragmentation, client buffers, and BGSAVE CoW forks.

    • Enforce Pinned QoS (requests == limits) and size maxmemory at 65-70% of pod RAM
    • Provision dedicated node pools with Transparent Huge Pages disabled and vm.overcommit_memory=1

    Pinned QoS · cgroup v2 · DaemonSet sysctl · maxmemory-policy

    Valkey performance tuning
  • Zone-aware scheduling & Karpenter protection

    AValkey replica is useless if Kubernetes schedules it onto the same physical hypervisor as its primary. We enforce strict fault-domain isolation.

    • Configure podAntiAffinity and topologySpreadConstraints across 3 Availability Zones
    • Lock pods against Karpenter consolidation with do-not-disrupt annotations and PDBs

    topologySpreadConstraints · podAntiAffinity · PodDisruptionBudget · Karpenter

  • Headless DNS, CNI & external client routing

    We eliminate kube-proxy iptables bottlenecks and Pod IP churn across Cilium, Calico, AWS VPC CNI, and GKE Dataplane V2 environments.

    • Configure Valkey 8.0 cluster-announce-hostname and headless Services for stable peer discovery
    • Enable Valkey 8.0 io-threads for mutual TLS (mTLS) and tune client topology refresh

    Headless Service · Cilium eBPF · cluster-announce-hostname · mTLS

  • CSI storage classes & persistence offloading

    Whether you run pure ephemeral caching or durable AOF + RDB state, we align CSI PersistentVolumeClaims and snapshot schedules with your recovery objectives.

    • Benchmark EBS gp3/io2, GCP Hyperdisk/pd-ssd, Azure Premium SSD v2, and local NVMe RAID
    • Automate off-cluster RDB/AOF backups to S3, GCS, or Azure Blob via CronJob or Operator

    StorageClass · EBS CSI / pd-ssd · Local NVMe · S3 CronJob backup

  • Prometheus ServiceMonitor & rolling upgrades

    We wire Kubernetes-native observability and zero-stall lifecycle playbooks so node image patching and Valkey minor upgrades run without dropping traffic.

    • Deploy redis_exporter sidecars with kube-prometheus-stack ServiceMonitor and PrometheusRule
    • Write preStop hooks that trigger graceful CLUSTER FAILOVER or Sentinel switchover before SIGTERM

    ServiceMonitor · PrometheusRule · preStop hook · kubectl drain drills

    Valkey high availability

Shared responsibility & response targets

Where default Helm charts stop and what JusDB engineers run

Installing a community Helm chart or Operator CRD gets a pod running in minutes, but surviving node drains, BGSAVE memory spikes, and AZ outages requires stateful SRE hardening.

Comparison between default Kubernetes Helm/Operator setups and what JusDB database engineers configure
Kubernetes subsystemWhere default charts stopWhat JusDB engineers run
Pod memory limits & Exit 137 OOMKillsDefault Helm values leave resources.limits unset (BestEffort/Burstable) or set maxmemory equal to the container memory limit.Enforces Pinned QoS, reserves 30-35% cgroup headroom for CoW BGSAVE forks and replica buffers, and tunes jemalloc activedefrag.
Primary/replica placement across AZsSchedules StatefulSet pods onto whichever node has free CPU/RAM, often co-locating a shard primary and its replica in one zone.Writes hard podAntiAffinity and topologySpreadConstraints per shard pair so a single node or AZ outage never takes down both copies.
Worker node kernel & THP tuningStandard EKS, GKE, and AKS managed node groups boot with Transparent Huge Pages enabled and vm.overcommit_memory=0.Provisions dedicated tainted Valkey node pools with custom launch templates or privileged init/DaemonSet sysctls.
Node drain & rolling upgrade safetySends SIGTERM directly to the Valkey container during kubectl drain, severing active connections before replicas promote.Configures PodDisruptionBudgets, Karpenter do-not-disrupt rules, and preStop lifecycle hooks that execute graceful failover first.
Valkey 8.0 CPU & io-threads schedulingApplies fractional CPU limits (for example 2000m) that trigger Linux CFS quota throttling across multi-threaded io-threads.Calibrates kubelet static CPU Manager policies or unbounded CPU bursts with dedicated CPU requests for flat sub-millisecond p99.
Backup verification & disaster recoveryMounts a PVC onto the pod; if a corrupted AOF or accidental FLUSHALL replicates, the PVC persists the broken state.Configures automated S3/GCS snapshot shipping with point-in-time validation and scheduled restore drills into isolated namespaces.

Published initial-response targets by severity

Standard business hours: 03:30–12:30 UTC

Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

SeverityInitial responseDefinitionChannel & coverage
P1 · Critical15 minutesProduction database down, primary unreachable, data corruption risk, or active failover event.24x7 on-call (under your service agreement) · Direct PagerDuty, Opsgenie, or phone page plus incident bridge
P2 · High30 minutesSevere latency spike, replication lag climbing rapidly, connection exhaustion, or degraded HA node.24x7 on-call (under your service agreement) · On-call alert plus shared Slack or Teams channel
P3 · Medium60 minutesNon-critical slow query regression, staging issue, backup warning, or replication check alert.24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket
P4 · Low90 minutesConfiguration question, index advisory, planned schema review, or general operational request.24x7 on-call (under your service agreement) · Shared Slack or Teams channel or support ticket

Our engineering team is in India; business-hours coverage is Mon–Fri 09:00–18:00 IST (UTC+5:30), and 24x7 on-call is available under your service agreement.

Initial-response targets, not resolution guarantees. The target for your engagement is set in your service agreement.

Interactive Kubernetes topology simulator

How Valkey StatefulSets behave during node drains & spikes

Compare a zone-pinned Pinned QoS cluster against an uncalibrated Helm deployment under memory pressure and a guarded kubectl drain with preStop failover.

Valkey on Kubernetes StatefulSet & node drain simulator

Select a state to inspect pod QoS, AZ anti-affinity, and PodDisruptionBudget behavior.

Headless Service DNS, Kubelet & Client Pools

Headless Service and topology-aware client pools route writes to shard primaries and reads to AZ-local replicas with Valkey 8.0 io-threads active.

3 AZs · Pinned QoS · PDB maxUnavailable=1
  • valkey-cluster-0 (us-east-1a)

    Shard 1 Primary · Pinned 32Gi (maxmemory 22Gi)

    ONLINE · Slots 0-5460 · p99 0.4ms

  • valkey-cluster-1 (us-east-1b)

    Shard 2 Primary + Shard 1 Replica (Anti-affinity)

    ONLINE · Slots 5461-10922 · Synced

  • valkey-cluster-2 (us-east-1c)

    Shard 3 Primary + Shard 2 Replica (Anti-affinity)

    ONLINE · Slots 10923-16383 · Synced

Each StatefulSet pod runs on a dedicated node pool with THP disabled, Pinned QoS cgroup limits, 30% CoW fork headroom, and strict cross-AZ anti-affinity between each primary and its replica.

Representative production deliverable

How a Valkey on Kubernetes architecture audit is delivered

Every finding includes the Kubernetes and Prometheus evidence, the hardened StatefulSet / PDB manifest diff, and the rolling rollout verification steps.

Sample finding · Exit Code 137 OOMKills & Karpenter dual shard evictionAmazon EKS 1.31 · Valkey 8.0 StatefulSet

Finding

Burstable pod limits and missing preStop hooks trigger CLUSTERDOWN during EKS node rotation

The StatefulSet configured maxmemory 30gb inside a 32Gi container limit, causing OOMKilled (Exit 137) whenever BGSAVE forked. Furthermore, Karpenter evicted pods without running CLUSTER FAILOVER first.

Pod OOMKills (30d)14 to 0
Node drain failover38s stall to <1s

1. Hardened Valkey 8.0 StatefulSet: Pinned QoS, Karpenter lock & graceful preStop failover

valkey-statefulset.yaml · production k8s spec

apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: valkey-cluster
  namespace: data-prod
spec:
  serviceName: valkey-headless
  replicas: 6
  podManagementPolicy: Parallel
  template:
    metadata:
      annotations:
        karpenter.sh/do-not-disrupt: "true"
    spec:
      topologySpreadConstraints:
        - maxSkew: 1
          topologyKey: topology.kubernetes.io/zone
          whenUnsatisfiable: DoNotSchedule
          labelSelector:
            matchLabels:
              app.kubernetes.io/name: valkey-cluster
      containers:
        - name: valkey
          image: valkey/valkey:8.0-alpine
          args:
            - "valkey-server"
            - "/etc/valkey/valkey.conf"
            - "--maxmemory"
            - "22gb"
            - "--maxmemory-policy"
            - "allkeys-lfu"
            - "--io-threads"
            - "4"
            - "--io-threads-do-reads"
            - "yes"
            - "--cluster-preferred-endpoint-type"
            - "hostname"
          resources:
            requests:
              cpu: "4"
              memory: "32Gi"
            limits:
              memory: "32Gi"
          lifecycle:
            preStop:
              exec:
                command: ["/bin/sh", "-c", "/scripts/graceful-cluster-failover.sh"]

2. PodDisruptionBudget & cgroup memory verification

valkey-pdb.yaml & kubectl verification

apiVersion: policy/v1
kind: PodDisruptionBudget
metadata:
  name: valkey-cluster-pdb
  namespace: data-prod
spec:
  maxUnavailable: 1
  selector:
    matchLabels:
      app.kubernetes.io/name: valkey-cluster
---
# Verify Pinned QoS class and cluster hostname endpoints
# kubectl get pod valkey-cluster-0 -n data-prod -o jsonpath='{.status.qosClass}'
# kubectl exec -it valkey-cluster-0 -n data-prod -- valkey-cli cluster slots

Ways to work together

How to engage JusDB for Valkey on Kubernetes

Start with a free read-only audit of your Kubernetes manifests and live pods, scope a turnkey Operator or Helm deployment, or put your K8s Valkey estate under ongoing SRE coverage.

Scoped K8s engineering projectThis page

Architect, harden, or migrate Valkey on Kubernetes.

A fixed-scope engagement delivering GitOps-ready manifests, node-pool sysctl automation, Prometheus alerts, and rehearsed node-drain chaos testing.

Common K8s scopes agreed in writing first

  • Operator & Helm architecture
  • Pinned QoS & cgroup sizing
  • Multi-AZ & Karpenter hardening
  • Redis to Valkey K8s migration
  • Valkey 8.0 io-threads on K8s
Free K8s Valkey audit

One Valkey StatefulSet or Operator CRD, audited read-only.

We review your Helm values, QoS resource limits, worker node sysctls, and PVC storage classes, then deliver a prioritized risk and sizing report within one week.

What we check on your Kubernetes cluster

  • Pinned QoS vs maxmemory & Exit 137 OOM risk
  • Cross-AZ anti-affinity, PDBs & Karpenter annotations
  • CFS CPU throttling, THP & headless DNS resolution
Ongoing K8s DBRE & support

Named engineers covering your Kubernetes Valkey estate.

Proactive Prometheus monitoring, Operator upgrades, PVC expansion, backup restore drills, and incident response under a 24x7 support agreement.

  1. Page on-callavailable under a 24x7 support agreement
  2. 15 minP1 initial-response target
  3. Written RCAafter every P1

Kubernetes distributions and cloud platforms we support

Evaluation Vector
JusDB DBRE
In-House DBALegacy AgencyDeveloper Generalist
Valkey Operator & Helm Deployment ArchitectureArchitects enterprise Valkey deployments using specialized Valkey Operators and custom Helm charts with declarative CRDs, hard anti-affinity constraints, and granular RBAC security contexts across multi-tenant clusters.Deploys untracked raw YAML manifests directly with kubectl, accumulating configuration drift and lacking automated operator reconciliation during node failure events.Installs generic community Redis Helm charts with stock defaults, omitting Valkey-specific engine optimizations, NUMA bindings, and Kubernetes security contexts.Deploys standalone Pods or stateless Deployments without StatefulSets or Operator controllers, risking total data loss and identity desynchronization during pod recycling.
Multi-Threaded I/O Engine CPU Core AllocationCalibrates Valkey multi-threaded I/O (io-threads) and assigns Guaranteed QoS CPU cores pinned to physical NUMA nodes, eliminating CFS quota throttling and maintaining sub-millisecond p99 latency during network packet bursts.Configures fractional CPU limits under Burstable QoS, triggering aggressive Linux CFS quota throttling and multi-millisecond tail latency spikes during packet bursts.Treats Valkey as strictly single-threaded; leaves multi-threaded I/O disabled, stranding over 85% of host multi-core processing power on modern cloud Kubernetes nodes.Omits CPU resource requests and limits entirely, allowing adjacent noisy-neighbor pods to starve Valkey of CPU cycles and induce cascading connection timeouts.
StatefulSet Local NVMe Persistent Volumes vs DisklessProvisions dedicated local NVMe PersistentVolumeClaims (PVCs) with tuned AOF fsync scheduling and active jemalloc memory defragmentation, for durable persistence alongside sub-millisecond read latencies.Attaches slow shared network-attached block storage (e.g. standard EBS), triggering I/O bottlenecks and latency stalls during background AOF rewrites and snapshot forks.Runs diskless configurations without persistent storage, causing complete cache wipeouts and devastating downstream relational database stampedes upon pod restarts.Mounts ephemeral container storage without PersistentVolumeClaims; all cached data, replication backlogs, and snapshots vanish whenever a container is rescheduled.
PodDisruptionBudgets & Multi-AZ Sentinel QuorumEnforces strict PodDisruptionBudgets (maxUnavailable=1), multi-AZ zone topology spread constraints, and 3-node Sentinel quorums to keep failover working during automated cluster node drains.Configures 2-node Sentinels within a single AZ, creating split-brain conditions and inability to achieve quorum whenever that availability zone suffers network degradation.Deploys Sentinel without PodDisruptionBudgets; automated node pool upgrades drain all Sentinel pods simultaneously, breaking automated HA failover capabilities.Omits Sentinel or cluster controllers altogether; primary pod crashes require manual human intervention and credential reconfiguration to promote replicas.
Rolling Stateful UpgradesAutomates rolling stateful upgrades utilizing pre-stop graceful failover hooks, replica synchronization validation, and active connection draining so engine updates avoid dropped queries.Executes manual pod deletions during business hours, causing cascading failover storms, client timeout bursts, and buffer bloat across downstream microservices.Schedules disruptive multi-hour maintenance windows requiring total application downtime to apply basic engine patches and container OS security updates.Applies StatefulSet container image tag changes directly with default RollingUpdate, abruptly killing the active primary pod before replicas have caught up with the replication stream.
Kubernetes Cluster Discovery & Client Redirection ReliabilityEngineers headless services with tuned CoreDNS caching, dual-stack endpoint discovery, and cluster-aware client connection pooling to eliminate stale DNS routing during pod failovers.Routes client traffic through standard ClusterIP services, masking individual pod states and causing persistent connection stalls when traffic routes to demoted primary pods.Hardcodes individual pod IP addresses inside application configuration maps, breaking connectivity whenever Kubernetes reschedules pods to different worker nodes.Fails to configure client-side socket reconnect timeouts or retry budgets, resulting in cascading application thread pool exhaustion during pod migrations.

For procurement and platform security teams

Mutual NDA first, RBAC least privilege, and GitOps workflow

We integrate directly with your Terraform, OpenTofu, ArgoCD, or Flux repositories. We never require cluster-admin in production; diagnostics run under scoped read-only Kubernetes RBAC and Valkey ACLs.Raguraman, Engineering Manager · Allen D, Lead Database SRE
  • Mutual NDA
  • Written statement of work
  • Scoped K8s Role / RBAC
  • GitOps PR delivery
  • NDA before access

    Signed before reviewing any Helm values, manifests, or cluster telemetry.

  • Written statement of work

    Target Kubernetes clusters, deliverables, chaos drill criteria, and fees agreed in writing first.

  • Namespace-scoped RBAC

    Read-only Role bindings for pod, StatefulSet, PVC, and Prometheus inspection without secret exfiltration.

  • Manifests & runbooks you keep

    Every Helm values file, Operator CRD, preStop failover script, and Grafana dashboard stays in your Git repo. Meet the JusDB team.

JusDB's security practices are aligned with ISO 27001 and SOC 2 Type II, and JusDB is pursuing both certifications (see Terms, section 12). Read the stated status.

Technical FAQ

Valkey on Kubernetes common questions

Answers on Operators vs Helm charts, Exit Code 137 OOMKills, Pod IP churn in Valkey Cluster, CFS CPU throttling, and Karpenter node drains.

Still have a question?

Ask it on a scoping call. No production access needed.

Book a 30-min scoping call (opens Google Calendar in a new tab)

Should we run Valkey on Kubernetes using an Operator or a Helm StatefulSet?

For standalone or 3-node Sentinel topologies, a well-tuned Bitnami or community Valkey Helm chart with StatefulSets, headless Services, and PodDisruptionBudgets is simple, predictable, and easy to manage via GitOps (ArgoCD/Flux). For multi-shard 16,384-slot Valkey Clusters that require automated slot rebalancing, shard scaling, and Pod IP healing across node replacements, we deploy and harden Kubernetes Operators such as the Hyperspike Valkey Operator or OT-Container-Kit Operator.

How do you prevent Kubernetes OOMKilled (Exit Code 137) crashes on Valkey pods?

The Linux kernel cgroup OOM killer terminates a Valkey container the instant its total RSS (dataset + jemalloc fragmentation + client output buffers + AOF rewrite buffer + BGSAVE copy-on-write pages) crosses resources.limits.memory. We prevent Exit 137 by setting Pinned QoS (requests.memory == limits.memory), configuring maxmemory in valkey.conf to 65-70% of the container limit, enabling lazyfree-lazy-*, and disabling Transparent Huge Pages on the host node pool.

How do you handle Pod IP changes in Valkey Cluster when Kubernetes reschedules a pod?

Historically, Redis/Valkey Cluster persisted ephemeral Pod IPs in nodes.conf, causing cluster split-brain when a rescheduled pod returned with a new IP. In Valkey 8.0 and 7.2, we configure cluster-preferred-endpoint-type hostname and cluster-announce-hostname pointing to each pod's stable StatefulSet headless DNS record (for example valkey-cluster-0.valkey-headless.prod.svc.cluster.local), or use Operator reconciliation hooks to update peer tables automatically.

Why shouldn't we set tight Kubernetes CPU limits on Valkey 8.0 pods?

When you configure a tight resources.limits.cpu value on a Valkey 8.0 pod - especially with io-threads 4 enabled - the Linux Completely Fair Scheduler (CFS) enforces CPU bandwidth in 100ms periods. A brief traffic burst consumes the quota across multiple threads in the first 20ms, causing the kernel to pause the entire Valkey process for the remaining 80ms. We either run Valkey on dedicated cache node pools without hard CPU limits or use the kubelet static CPU Manager policy for exclusive core pinning.

How do you protect Valkey StatefulSets from Karpenter or Cluster Autoscaler evictions?

We apply karpenter.sh/do-not-disrupt: 'true' (or cluster-autoscaler.kubernetes.io/safe-to-evict: 'false') annotations to Valkey pods, isolate them onto dedicated node pools via nodeSelector and taints/tolerations, enforce PodDisruptionBudgets (maxUnavailable: 1), and configure preStop hooks that execute a graceful Sentinel or Cluster failover before the container stops.

Which Kubernetes StorageClass is best for Valkey RDB and AOF persistence?

For cloud durability across pod restarts, we use low-latency block CSI drivers - AWS EBS gp3 (with provisioned IOPS) or io2, Google Cloud pd-ssd or Hyperdisk Balanced, and Azure Premium SSD v2 - mounted with noatime. For ultra-low-latency multi-terabyte caches where cross-AZ replication provides durability, we also architect local NVMe SSD node pools backed by automated S3/GCS snapshot shipping.

Can we migrate from Bitnami Redis Helm charts to Valkey on Kubernetes without downtime?

Yes. Because Valkey 7.2 and 8.0 are wire-compatible and replication-compatible with Redis 6.2 and 7.2, we join Valkey StatefulSet pods as replicas of your existing Redis pods (or use image rolling replacement with preStop failover hooks), verify zero replication offset lag, and cut traffic over via Kubernetes Service selectors. See our Redis vs Valkey comparison for full protocol details.

What are your response targets for Valkey on Kubernetes production incidents?

Initial-response targets are 2 to 4 hours during covered business hours, Mon–Fri 09:00–18:00 IST (UTC+5:30). Where your service agreement includes 24x7 on-call, the initial-response target for P1 incidents is 15 minutes. Targets are not resolution guarantees.

Next step

Talk to an engineer about your Valkey on Kubernetes estate

Tell us whether you run EKS, GKE, AKS, or OpenShift, and whether you use Helm or an Operator. The first 30-minute call covers your databases, current ownership, and required coverage. No production access is needed. Or request a free audit of one database instance, subject to availability: mutual NDA before read-only access, a prioritized report within one week after access is ready, and no obligation.

NDA before access · read-only by default · written scope first

Related Valkey Services

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