Redis Software, Redis Cloud, Kubernetes & Valkey

This content was generated with the assistance of AI and should be verified against the official Redis documentation before being relied on in production.

This section’s bibliography lists the reference material consulted while preparing these pages.

Examples on this page target Redis Open Source 8.10 (8.10.2) as the baseline — the same version the rest of this section’s pages run against — with this page itself covering the commercial, managed, and forked ecosystem that sits around that baseline: Redis Software (the self-managed commercial distribution), Redis Cloud (the managed service), the Kubernetes operator that runs Redis Software on a cluster, Redis Data Integration, and Valkey, the community fork that some managed-cloud providers offer in Redis’s place.

Editions compared

The table below focuses on what actually differs day to day — feature surface, who operates it, and under what license — rather than every marketing distinction.

Redis Open Source Redis Software Redis Cloud Valkey

Deployment

Self-managed, any host

Self-managed (VMs, bare metal, or Kubernetes via the operator)

Fully managed by Redis, on AWS/GCP/Azure

Self-managed or offered by third-party clouds (e.g. as a managed service)

Support model

Community (GitHub issues, forums)

Commercial support contract

Commercial support included in the subscription

Community, plus commercial support from individual vendors

Multi-tenancy / clustering

Single database per process; Redis Cluster for sharding

Multi-database clusters with a proxy layer, resource pooling across tenants

Same as Redis Software, operated for you

Redis Cluster-compatible sharding; no built-in multi-tenant proxy layer

Active-Active (CRDT-based multi-region writes)

Not available

Available

Available on Pro

Not available

Auto tiering (RAM + flash)

Not available

Available

Available on Pro

Not available

Role-based access control

ACLs (ACL SETUSER, since Redis 6)

ACLs plus cluster-level RBAC for cluster management operations

ACLs plus Redis Cloud’s own team/role management

ACLs (inherited from the Redis 7.2.4 fork point)

Licensing

AGPLv3, RSALv2, or SSPLv1 (tri-licensed, choose one)

Commercial license

Commercial (subscription), no separate license choice

BSD-3-Clause

Redis Software architecture

Redis Software (older material calls this Redis Enterprise Software; this page uses Redis’s current Redis Software naming) is a clustered, self-managed distribution built to run many databases on a shared pool of nodes rather than one Redis process per host.

  • Nodes and shards — a Redis Software cluster is a set of nodes (physical or virtual machines) that pool their CPU, RAM, and storage; each database created on the cluster is split into shards distributed across those nodes, and Redis Software rebalances shard placement as nodes are added, removed, or fail. See Redis Software architecture.

  • Proxy — every database is fronted by a proxy layer that routes client connections to the shard actually holding a given key, so a client can address the database through a single endpoint without implementing cluster-aware routing itself, unlike open source Redis Cluster where clients must be cluster-aware. See Durability and high availability.

  • Multi-tenancy — because many databases share the same node pool, a cluster can host multiple applications or teams' databases side by side, each with its own memory and throughput limits, instead of one cluster per workload.

  • Active-Active (CRDTs) — an Active-Active database replicates writes between regions using conflict-free replicated data types (CRDTs), so each region accepts local writes with local latency and conflicting updates converge automatically rather than requiring a single write region. See Active-Active Redis.

  • Auto tiering — a database can be configured to keep hot data in RAM and colder data on local flash storage, extending effective capacity beyond RAM size at a latency cost for flash-resident keys. See Auto Tiering.

  • RBAC — cluster management (as opposed to per-database ACLs) is controlled by role-based access control, assigning cluster administrators, database administrators, and viewers distinct permissions over the management UI/API rather than sharing one admin credential. See Access control.

Redis Cloud

Redis Cloud is Redis’s fully managed service: Redis Software’s clustering, Active-Active, and auto-tiering capabilities operated by Redis on the customer’s behalf.

  • Essentials vs. Pro — Essentials (formerly Fixed) is the shared, fixed-price tier: pick a database size from 250 MB up to 12 GB and get a preset connection/throughput limit for that size, suited to smaller or early-stage workloads. Pro (formerly Flexible) runs on dedicated VPC infrastructure, adds multiple databases per subscription, Active-Active, auto tiering, private connectivity (VPC peering/PrivateLink), and a 99.999% uptime SLA — the tier for production workloads with their own capacity and isolation requirements. See Redis Cloud subscriptions.

  • Free tier — a permanently free 30 MB database is available without a paid subscription, intended for evaluation and small personal projects rather than production traffic. See Create a free database.

  • Cloud providers — Redis Cloud runs on AWS, Google Cloud, and Microsoft Azure; Pro subscriptions choose a provider and region at creation time, while Essentials databases are hosted on Redis’s own shared infrastructure. See Redis Cloud subscriptions.

  • Networking and SSO — Pro subscriptions support VPC peering, AWS PrivateLink, and Azure Private Link for private connectivity, plus SSO integration (SAML) for console access, so an organization can enforce its own identity provider instead of Redis Cloud-local credentials. See Redis Cloud security.

  • REST API and redisctl — every management operation (creating subscriptions, databases, ACL rules) is available through Redis Cloud’s REST API; redisctl is Redis’s official command-line client that wraps that API (and the Redis Software API) into a single binary, replacing hand-rolled curl/jq scripts. See Redis Cloud REST API and redisctl.

$ redisctl cloud database create --subscription-id 123456 \
    --name orders-cache --memory-limit-in-gb 1

  • Terraform and Pulumi — Redis publishes an official Terraform provider (RedisLabs/rediscloud) and a Pulumi provider built on it, so subscriptions, databases, and ACL rules can be defined as code and applied through the same pipelines that manage the rest of an organization’s cloud infrastructure. See Redis Cloud Terraform provider.

Redis Enterprise for Kubernetes

Redis Software can run on Kubernetes through the Redis Enterprise Kubernetes operator: a controller that watches two custom resources and reconciles the actual cluster/database state to match them, the same declarative model Kubernetes uses for its own built-in resources.

RedisEnterpriseCluster (REC) describes the cluster itself — how many nodes, how much storage and CPU/memory each node gets — and the operator provisions a StatefulSet and supporting resources to match it. RedisEnterpriseDatabase (REDB) describes one database on that cluster — memory size, shard count, replication — and the operator creates it through the cluster’s management API once the REC it references is ready. See Redis Enterprise for Kubernetes architecture.

apiVersion: app.redislabs.com/v1
kind: RedisEnterpriseCluster
metadata:
  name: rec-orders
spec:
  nodes: 3
  redisEnterpriseNodeResources:
    limits:
      cpu: "4"
      memory: 8Gi
    requests:
      cpu: "2"
      memory: 4Gi
  persistentSpec:
    enabled: true
    storageClassName: standard
    volumeSize: 20Gi
---
apiVersion: app.redislabs.com/v1alpha1
kind: RedisEnterpriseDatabase
metadata:
  name: orders-cache
spec:
  redisEnterpriseCluster:
    name: rec-orders
  memorySize: 2GB
  shardCount: 3
  replication: true

This derives from Basic deployment examples.

Redis Data Integration

Redis Data Integration (RDI) is a change-data-capture pipeline that keeps a Redis database automatically in sync with a primary transactional database — Postgres, MySQL, Oracle, or SQL Server — so an application can read from Redis at cache speed while a background pipeline applies each upstream change (insert, update, delete) to the corresponding Redis keys, without the application writing any cache-population code of its own. It targets read-heavy, cache-aside style workloads that today hand-maintain that synchronization logic. See Redis Data Integration.

Licensing history and Valkey

Redis Open Source shipped under the permissive BSD-3-Clause license through version 7.2.4. In March 2024, Redis Ltd. relicensed all versions from 7.4 onward under a dual license — the Redis Source Available License v2 (RSALv2) and the Server Side Public License v1 (SSPLv1) — neither of which is OSI-approved open source; RSALv2 in particular restricts offering Redis as a competing managed service. That change prompted the Linux Foundation, backed by AWS, Google, and Oracle among others, to fork the last BSD-licensed release — Redis 7.2.4 — into Valkey, keeping the BSD-3-Clause license the community had built on. With Redis 8.0’s general availability, Redis added a third licensing option: AGPLv3, an OSI-approved copyleft license, so Redis 8 and later ship tri-licensed under the developer’s choice of RSALv2, SSPLv1, or AGPLv3 — making Redis Open Source OSI-open-source-compliant again without withdrawing the two source-available options commercial vendors had been building against.

Valkey has continued as an independent project rather than merging back: it reached 8.0 in 2024 and, as of this writing, its current major line is Valkey 9.x (9.0 general availability in October 2025, with a 9.1 release in May 2026), adding its own features — such as multiple databases in cluster mode and atomic slot migration — that have no equivalent in Redis 8. Conversely, everything Redis has added to the RediSearch, RedisJSON, and the rest of the module set folded into Redis 8’s tri-licensed core, plus Redis Software-only capabilities like Active-Active CRDTs and auto tiering, has no counterpart in Valkey, since Valkey tracks Redis’s protocol and command set rather than its commercial feature set. In practice this means: a client library or application written against the Redis command set generally works unmodified against either engine for core data-structure commands, but search/JSON/time-series module commands and Redis Software-specific management features are Redis-only, and a codebase relying on them will not run against a Valkey-backed service. That split matters directly for the managed cloud offerings described elsewhere in this section — AWS, Google Cloud, and Microsoft Azure each offer a managed Redis-compatible cache, and some of those offerings run Valkey rather than Redis under the hood, so confirming which engine (and which version) a managed offering actually runs is a prerequisite before relying on any Redis 8-only capability.

timeline title Redis vs. Valkey: releases and licenses 2018 : Redis Open Source under BSD-3-Clause March 2024 : Redis relicenses 7.4+ under RSALv2 / SSPLv1 : Valkey forks from Redis 7.2.4 (BSD-3-Clause) 2024 : Valkey 8.0 GA May 2025 : Redis 8.0 GA -- adds AGPLv3, tri-licensed with RSALv2 / SSPLv1 October 2025 : Valkey 9.0 GA May 2026 : Valkey 9.1 GA

Related pages

  • Choosing the Right Database — how Redis (and Redis-compatible engines) compare against other database types when picking one for a workload.

References