Google CloudMemorystore for RedisDatabase

`google_redis_instance` cost estimation

A managed Redis instance. Priced per GB-hour by service tier (Basic or Standard) and capacity.

A google_redis_instance is a managed Redis cache on GCP Memorystore. Pricing is simpler than AWS ElastiCache or Azure Cache for Redis: per-GB-hour by tier.

Two service tiers:

Basic (tier = "BASIC"): single-node, no SLA, no replication. Right for dev/test. About $0.049/GB-hour.

Standard (tier = "STANDARD_HA"): two-node primary/replica with automatic failover and 99.9% SLA. About $0.054/GB-hour. Roughly 10% more than Basic for HA.

Memorystore is sized by memory_size_gb (1 GB through 300 GB). The per-GB rate is constant; total cost scales linearly with size.

Network tier doesn't apply (Memorystore is internal to GCP). Outbound traffic from clients goes through normal GCP egress rules.

Read replicas (read_replicas_mode = "READ_REPLICAS_ENABLED"): adds 1-5 read replicas in addition to the primary/replica pair. Each adds the same per-GB-hour cost as the primary.

For workloads that need more than 300 GB or Redis Cluster mode, Memorystore for Redis Cluster (google_redis_cluster, a separate resource) is the right choice. It uses a different shard-based pricing model.

c3x reads tier and memory_size_gb from the resource. Read replica counts come from read_replicas_mode and read_replicas_count.

Terraform example

A minimal but realistic configuration that C3X can estimate.

resource "google_redis_instance" "session_cache" {
  name           = "session-cache"
  tier           = "STANDARD_HA"
  memory_size_gb = 5
  region         = "us-central1"

  redis_version     = "REDIS_7_2"
  display_name      = "Session cache"
  reserved_ip_range = "10.0.0.0/29"

  redis_configs = {
    maxmemory-policy = "allkeys-lru"
  }
}

Pricing dimensions

What you actually pay for when you provision google_redis_instance.

Dimension	Unit	What's being charged
Basic tier	per GB-hour	Single-node Redis instance. No SLA, no replication. Right for dev/test. $0.049/GB-hour in us-central1
Standard HA tier	per GB-hour	Primary/replica with 99.9% SLA. Slightly more expensive than Basic. $0.054/GB-hour in us-central1
Read replicas	per replica per GB-hour	Each additional read replica is billed at the same per-GB-hour rate as the primary.
Outbound network egress	per GB	Bytes from clients leaving the GCP region. Free intra-region.

Optimization tips

Common ways to reduce google_redis_instance cost without changing the workload.

Use Basic tier for non-production

About 10%

Basic is 10% cheaper than Standard HA. For dev/staging where there's no SLA requirement, Basic is sufficient.

Right-size memory by actual usage

Linear with size reduction

Memorystore exposes memory metrics in Cloud Monitoring. If you're consistently using less than 50% of provisioned memory, drop the size. Memory is the only thing you're paying for.

Buy Committed Use Discounts for steady-state

17-30%

1-year CUDs cut Memorystore prices by ~17%; 3-year by ~30%. Right for production caches that won't shrink.

Use read replicas only when read-after-write isn't required

Avoid unnecessary replica cost

Each read replica doubles the cost of its own size. Only add replicas if you actually have high read traffic that the primary can't serve. Many workloads don't need them.

Consider Memorystore for Redis Cluster for larger workloads

At very large scale

Cluster mode (google_redis_cluster) is cheaper per GB above ~100 GB and supports horizontal scaling. For caches over 300 GB, it's the only option.

FAQ

Basic or Standard HA?

Standard HA for any production workload (the 10% premium is small and you get failover). Basic for dev/test/ephemeral where downtime is acceptable.

How does c3x compute Memorystore cost?

c3x multiplies memory_size_gb by the per-GB-hour rate by 730 hours/month. If read_replicas_mode is enabled, c3x adds the read replica cost.

What about Memorystore for Redis Cluster?

Different resource type (google_redis_cluster) with shard-based pricing. Right for caches over 100 GB that benefit from horizontal scaling. Separate page in the c3x catalog when implemented.

Are connections to Memorystore free?

Yes, within the same region. Memorystore is VPC-internal; intra-region traffic is free. Cross-region access requires VPC peering and incurs cross-region egress.