Deploying Redis on Google Cloud

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.

This page covers deploying and consuming Redis on Google Cloud as of September 2026, distinct from the local docker run redis:8 container the rest of this section otherwise develops against. Google Cloud offers Redis through two independent paths: Redis Ltd.'s own managed service (Redis Cloud, sold both directly and through the GCP Marketplace) and Google’s own first-party managed services (Memorystore for Redis, Memorystore for Redis Cluster, and Memorystore for Valkey), each with a different feature ceiling and operational model. For the Azure equivalent see Deploying Redis on Azure, and for the broader Azure platform view see Redis and Partner Databases on Azure. For the Google Cloud platform view of Memorystore and the other partner databases, see Memorystore and Partner Databases.

Redis Cloud on Google Cloud

Redis Cloud runs the same Redis Software stack covered in Redis Software, Redis Cloud, Kubernetes & Valkey operated by Redis Ltd. rather than by Google, and that page’s Essentials/Pro tier split, Active-Active, and auto-tiering coverage applies unchanged on Google Cloud as a hosting provider; this section covers only what is GCP-specific: how a subscription is billed and connected.

  • GCP Marketplace listing — Redis Cloud is listed on the Google Cloud Marketplace, so a subscription can be provisioned and billed as a line item on the same Google Cloud invoice as the rest of an organization’s GCP spend, instead of a separate Redis Ltd. billing relationship. Sign-up starts from the Marketplace listing and hands off to the Redis Cloud console for subscription and database configuration. See Sign up for Redis Cloud with Google Cloud Marketplace.

  • Private Service Connect (PSC) — a Redis Cloud Pro subscription hosted on Google Cloud can expose its databases through a PSC private endpoint inside the customer’s own VPC, so traffic never crosses the public internet and no inbound firewall rule against Redis Cloud’s infrastructure is needed. PSC is configured from the Redis Cloud console and is available alongside, or instead of, VPC peering. See Enable Google Cloud Private Service Connect.

  • VPC peering — the older private-connectivity option, peering the customer’s VPC directly with Redis Cloud’s underlying network; PSC is the newer, narrower-blast-radius alternative that exposes only the specific database endpoint rather than routable access across both peered networks. See Redis Cloud on Google Cloud.

Memorystore for Redis

Memorystore for Redis is Google’s original first-party managed Redis offering: a single-shard (non-cluster) instance built on open source Redis, tracking Redis up to version 7.2 — it predates Redis 8 and does not run the Query Engine, VECTOR fields, JSON, or vector sets covered elsewhere in this section. It remains supported for existing workloads that only need core Redis data structures and caching, but Google now steers new deployments toward Memorystore for Redis Cluster or Memorystore for Valkey instead (both below).

  • Basic tier — a single node with no replication: a maintenance event, zone outage, or node failure causes a cold restart with a full cache flush, so Basic is appropriate only for a pure cache that can be safely repopulated from a source of truth, not for data an application cannot afford to lose. See Redis tier capabilities.

  • Standard tier — adds a replica in a second zone with automatic failover, giving the instance high availability across a zone outage without the application managing failover itself. Standard also supports read replicas, additional replica nodes that serve read-only traffic to scale read throughput beyond a single node’s capacity, separate from the failover replica. Switching between Basic and Standard after creation isn’t supported; moving an existing instance between tiers means exporting and re-importing its data into a new instance. See Redis tier capabilities.

Memorystore for Redis Cluster

Memorystore for Redis Cluster is Google’s clustered, horizontally scalable Memorystore offering, built on Redis Cluster sharding and tracking newer Redis releases (cluster version 8.0 and later) than the single-shard Memorystore for Redis above.

  • Vector search — Memorystore for Redis Cluster exposes FT.CREATE/FT.SEARCH and the Query Engine’s VECTOR field type covered in Vector Search: Query Engine & Vector Sets, available on every cluster version and tier and in every supported region, though only on clusters created after the feature’s September 2024 launch date — an older cluster needs a new one created to pick it up. Indexing carries the same constraints Redis itself imposes plus a few Memorystore-specific ceilings: up to 10 attributes per index, vector dimensions up to 32,768, and HNSW’s `M/EF_CONSTRUCTION/EF_RUNTIME parameters capped below the values Redis Open Source itself allows. A vector field’s data is held twice — once in the ordinary Redis keyspace and once in the search index — so its memory cost is roughly double a same-sized non-indexed value, and vector search operations don’t participate in Redis transactions the way ordinary commands do. See Vector search features and limitations and About vector search.

  • JSON — clusters on version 8.0 and later get the JSON data type and its commands automatically, without loading a separate module, API-compatible with the RedisJSON v2 module this section otherwise documents. A json.max-document-size config limit guards against unbounded JSON key growth. See About JSON.

  • Persistence — RDB and AOF — a cluster can be configured with RDB snapshotting, AOF (append-only file) logging, or both, the same two persistence mechanisms Redis Open Source offers, so cluster data survives a node restart rather than existing only in memory. See Persistence overview.

  • Cross-region replication — a cluster can replicate to one or more secondary clusters in other regions, giving a read-scaling or disaster-recovery target outside the primary cluster’s region rather than confining replication to zones within one region. See About cross-region replication.

  • IAM authentication — a client can authenticate to the cluster using its Google Cloud IAM identity instead of (or alongside) a static AUTH password, so access can be granted and revoked through IAM roles the same way access to other Google Cloud resources is managed. See About IAM authentication.

  • In-transit encryption — TLS between clients and the cluster can be enabled at creation time, with a choice of Google-managed per-instance or shared certificate authorities, or a customer-managed CA when an organization needs its own trust chain. See About in-transit encryption.

Memorystore for Valkey

Memorystore for Valkey is Google’s managed offering for Valkey, the BSD-licensed Redis fork covered in Redis Software, Redis Cloud, Kubernetes & Valkey. As of this writing Google positions it as the recommended choice for new Memorystore workloads going forward, ahead of both Memorystore for Redis and Memorystore for Redis Cluster, citing a horizontally scalable, many-smaller-nodes architecture that reaches higher throughput at lower latency than Memorystore for Redis Cluster on comparable hardware. Because it runs Valkey rather than Redis, it inherits the licensing and command-surface split Redis Software, Redis Cloud, Kubernetes & Valkey already covers: core Redis data-structure commands work the same, but Redis 8’s Query Engine, VECTOR fields, JSON, and vector sets have no Valkey equivalent, so a workload that depends on any capability this section documents beyond core data structures cannot move to Memorystore for Valkey. See Memorystore for Valkey 9.0 is now GA.

Redis 8 features and Memorystore coverage

Not every Redis 8 feature this section documents is available on every Memorystore offering, and the gap is the main input into which offering fits a given workload:

Feature Memorystore for Redis Memorystore for Redis Cluster Memorystore for Valkey

Query Engine full-text search (FT.SEARCH over TEXT/TAG/NUMERIC)

Not available

Available

Not available

VECTOR fields / vector search (FT.SEARCH KNN, VECTOR_RANGE)

Not available

Available (clusters created after September 2024)

Not available

FT.HYBRID

Not available

Not documented as supported

Not available

JSON data type

Not available

Available (cluster version 8.0+)

Not available

Vector sets (VADD/VSIM)

Not available

Not available

Not available

Probabilistic types (Bloom/Cuckoo/Top-K/Count-min)

Not available

Not available

Not available

Time series (TS.*)

Not available

Not available

Not available

In practice this means a workload relying on the Query Engine’s text or vector search, or on JSON, needs Memorystore for Redis Cluster specifically (or Redis Cloud, which runs unmodified Redis Software); a workload relying on vector sets, probabilistic types, or time series needs Redis Cloud or a self-managed Redis 8 deployment, since none of Google’s Memorystore offerings expose those commands as of this writing.

Choosing an offering

Redis Cloud on GCP Memorystore for Redis Memorystore for Redis Cluster Memorystore for Valkey

Query Engine / modules

Full (unmodified Redis Software)

None

Query Engine text + vector search, JSON

None (Valkey has no module surface)

High availability

Yes (Pro; Essentials is single-zone)

Standard tier only

Yes, cross-zone by default

Yes, cross-zone by default

Operated by

Redis Ltd.

Google Cloud

Google Cloud

Google Cloud

Typical use case

Workloads needing Active-Active, auto tiering, or the full Redis 8 module set, billed through GCP or run directly

Legacy single-shard caches already on Memorystore for Redis; not recommended for new builds

New builds needing Query Engine search/vector/JSON inside a Google-operated service

New builds needing only core Redis data structures at the lowest latency/highest throughput Memorystore offers

Spring Boot on Cloud Run against a private Memorystore instance

A Memorystore instance (any of the three offerings above) is reachable only from inside its VPC by default; a Cloud Run service reaches it either through Direct VPC egress — routing the service’s outbound traffic straight into the VPC without an intermediary — or the older Serverless VPC Access connector, a small managed proxy resource Cloud Run traffic is routed through. Direct VPC egress is the option Google now recommends for new services, since it removes the connector’s extra hop and its separate scaling/cost profile. Once traffic reaches the VPC, a Spring Boot application configures Lettuce or Jedis against the instance’s private IP, an IAM auth token in place of a static password when IAM authentication (Memorystore for Redis Cluster) is enabled, and TLS when in-transit encryption is turned on:

spring:
  data:
    redis:
      host: 10.0.0.5
      port: 6379
      password: ${MEMORYSTORE_IAM_TOKEN}
      ssl:
        enabled: true
        bundle: memorystore-ca
  ssl:
    bundle:
      pem:
        memorystore-ca:
          truststore:
            certificate: file:/etc/secrets/memorystore-ca.pem

MEMORYSTORE_IAM_TOKEN is a short-lived IAM auth token the application fetches through the Memorystore client library rather than a value stored as a literal secret, and memorystore-ca.pem is the certificate authority (Google-managed or customer-managed) the instance’s in-transit encryption was configured with. This derives from About IAM authentication and Direct VPC egress.

A Terraform snippet provisioning the Memorystore for Redis Cluster instance that configuration targets:

resource "google_memorystore_instance" "orders_cache" {
  instance_id            = "orders-cache"
  location               = "us-central1"
  shard_count            = 3
  replica_count          = 1
  node_type              = "SHARED_CORE_NANO"
  transit_encryption_mode = "SERVER_AUTHENTICATION"
  authorization_mode      = "IAM_AUTH"

  persistence_config {
    mode = "RDB"
    rdb_config {
      rdb_snapshot_period    = "ONE_HOUR"
      rdb_snapshot_start_time = "2026-09-25T00:00:00Z"
    }
  }
}

This derives from the google_memorystore_instance Terraform resource.

flowchart TD A[Need Redis on Google Cloud] --> B{Need Query Engine text/vector\nsearch, JSON, or full Redis 8\nmodule set?} B -- "Vector sets, probabilistic types,\ntime series, or Active-Active" --> C[Redis Cloud on GCP] B -- "Text/vector search or JSON only" --> D[Memorystore for Redis Cluster] B -- No --> E{Need high availability?} E -- No, legacy single-shard cache --> F[Memorystore for Redis\nBasic] E -- Yes --> G{New workload, no module\ndependency?} G -- Yes --> H[Memorystore for Valkey] G -- "Existing Memorystore for Redis\ndeployment" --> I[Memorystore for Redis\nStandard]

Related pages

References