Managed Redis in 2026: ElastiCache, Memorystore, Redis Cloud, Upstash and Valkey

Redis is the default choice for caching, rate limiting, sessions and short-lived counters in a backend, and few teams want to run it on their own VMs. The managed options split along two lines: services inside your cloud account and VPC, such as ElastiCache and Memorystore, and Redis-as-a-service providers that run it for you and expose it over the internet or private links.

The 2024 license change also added a choice of engine. Valkey, the Linux Foundation fork, is what AWS and Google increasingly put first in their managed offerings. This guide compares the main managed services on the points that decide a backend team's choice and shows how to use one from code without wiring it up by hand.

Managed Redis services at a glance

Amazon ElastiCache

ElastiCache runs Valkey, Redis OSS or Memcached inside your VPC, either as node-based clusters where you choose instance types, shards and replicas, or as ElastiCache Serverless, which scales capacity automatically. Clusters support Multi-AZ replication with automatic failover, cluster mode for sharding, encryption in transit and at rest, and access control lists. Being in the VPC means low latency from ECS or EKS and no public endpoint, and also means local development needs its own Redis.

Best fit: Backends running on AWS that want a cache in the same VPC as their services.

Amazon MemoryDB

MemoryDB is Redis-compatible like ElastiCache, and adds a distributed, Multi-AZ transaction log so writes are durable once acknowledged. That makes it usable as a primary database for data that lives only in Redis structures, at higher write latency than ElastiCache.

Best fit: Teams that keep primary data in Redis structures and cannot afford to lose acknowledged writes.

Google Memorystore

Memorystore offers Memorystore for Redis, Memorystore for Redis Cluster and Memorystore for Valkey, all reached over private IP from Cloud Run, GKE or Compute Engine. The standard tier replicates to another zone with automatic failover, and Cloud Run reaches it through Direct VPC egress or a Serverless VPC Access connector.

Best fit: Backends on Cloud Run or GKE that want a cache inside their GCP network.

Redis Cloud

Redis Cloud is the managed service from Redis Inc., running on AWS, GCP or Azure. It offers the Redis modules and features from the company, such as search, JSON and time series, plus active-active replication across regions. Connections go over the internet with TLS or through VPC peering and private links.

Best fit: Teams that need Redis Inc.'s modules or active-active geo-replication.

Upstash

Upstash provides Redis-compatible databases with a REST API next to the standard protocol, which works from serverless and edge runtimes that cannot hold TCP connections open. Billing is based on usage, which fits spiky, low-volume workloads, and data is persisted to disk.

Best fit: Serverless and edge functions that need a key-value store over HTTP.

Aiven for Valkey

Aiven runs Valkey as a managed service in the cloud and region you pick, alongside its managed Postgres, Kafka and other data services, with one console and billing across them.

Best fit: Teams that already run other data services on Aiven and want their cache in the same place.

Redis, Valkey and licensing

Redis moved from the BSD license to dual RSALv2 and SSPLv1 licensing in March 2024, which led to the Valkey fork under the Linux Foundation, backed by AWS, Google and others, as announced by the Linux Foundation. Redis later added AGPLv3 as a license option with Redis 8. For a managed service the license matters less than for self-hosting, and the practical differences are which engine versions a provider offers and which features beyond the shared protocol you rely on.

Using a managed cache from code with Encore

Each of the services above still has to be created, placed in the right network, given credentials and replicated for local development.

Encore is infrastructure from code for TypeScript and Go, with a platform that provisions and deploys into your own AWS or GCP account, and a cache declared in code becomes ElastiCache on AWS, starting on cache.m6g.large with Multi-AZ replication, or Memorystore for Redis in a high-availability setup on GCP, as documented in the AWS infrastructure docs and GCP infrastructure docs.

Set up the app

A per-user rate limiter with typed keys and a 10-second window:

// limits/encore.service.ts
import { Service } from "encore.dev/service";
export default new Service("limits");

// limits/limits.ts
import { api, APIError } from "encore.dev/api";
import { CacheCluster, IntKeyspace, expireIn } from "encore.dev/storage/cache";

// ElastiCache on AWS, Memorystore on GCP, a local Redis under encore run.
const cluster = new CacheCluster("rate-limit", { evictionPolicy: "noeviction" });

const requestsPerUser = new IntKeyspace<{ userId: string }>(cluster, {
  keyPattern: "requests/:userId",
  defaultExpiry: expireIn(10 * 1000),
});

export const ping = api(
  { expose: true, method: "GET", path: "/ping/:userId" },
  async ({ userId }: { userId: string }): Promise<{ count: number }> => {
    let count: number;
    try {
      count = await requestsPerUser.increment({ userId }, 1);
    } catch {
      throw APIError.unavailable("rate limiter unavailable");
    }
    if (count > 10) {
      throw APIError.resourceExhausted("rate limit exceeded");
    }
    return { count };
  },
);

encore run starts a local Redis, so the limiter can be developed and tested locally against the same keyspace API it uses in production. Keyspaces type both keys and values, which prevents two parts of the code from writing different types under the same key pattern, as covered in the TypeScript caching docs and the Go caching docs. Encore manages the cache credentials, so no Redis URL or password is committed or shared.

An AI coding agent adding a cache writes a keyspace declaration and tests it locally, and the ElastiCache or Memorystore cluster behind it arrives with the next deploy.

Best fit: TypeScript and Go teams on AWS or GCP who want a managed cache in their own account, declared in the code that uses it.

Related guides

• Add caching to a TypeScript API
• Add Redis to a Go API
• Add a Redis cache on AWS with an AI agent
• Add Redis to FastAPI