Redis

Reference doc for the `sst.aws.Redis` component.

The Redis component lets you add a Redis cluster to your app using Amazon ElastiCache.

Create the cluster

const vpc = new sst.aws.Vpc("MyVpc");
const redis = new sst.aws.Redis("MyRedis", { vpc });

Link to a resource

You can link your cluster to other resources, like a function or your Next.js app.

new sst.aws.Nextjs("MyWeb", {
  link: [redis],
  vpc
});

Once linked, you can connect to it from your function code.

import { Resource } from "sst";
import { Cluster } from "ioredis";

const client = new Cluster(
  [{
    host: Resource.MyRedis.host,
    port: Resource.MyRedis.port
  }],
  {
    redisOptions: {
      tls: { checkServerIdentity: () => undefined },
      username: Resource.MyRedis.username,
      password: Resource.MyRedis.password
    }
  }
);

Running locally

By default, your Redis cluster is deployed in sst dev. But let’s say you are running Redis locally.

docker run \
  --rm \
  -p 6379:6379 \
  -v $(pwd)/.sst/storage/redis:/data \
  redis:latest

You can connect to it in sst dev by configuring the dev prop.

const redis = new sst.aws.Redis("MyRedis", {
  vpc,
  dev: {
    host: "localhost",
    port: 6379
  }
});

This will skip deploying a Redis ElastiCache cluster and link to the locally running Redis server instead. Check out the full example.

Cost

By default this component uses On-demand nodes with a single cache.t4g.micro instance.

The default redis engine costs $0.016 per hour. That works out to $0.016 x 24 x 30 or $12 per month.

If the valkey engine is used, the cost is $0.0128 per hour. That works out to $0.0128 x 24 x 30 or $9 per month.

Adjust this for the instance type and number of nodes you are using.

The above are rough estimates for us-east-1, check out the ElastiCache pricing for more details.

Constructor

new Redis(name, args, opts?)

Parameters

name string
args RedisArgs
opts? ComponentResourceOptions

RedisArgs

dev?

Type Object

host?
password?
port?
username?

Configure how this component works in sst dev.

By default, your Redis cluster is deployed in sst dev. But if you want to instead connect to a locally running Redis server, you can configure the dev prop.

This will skip deploying a Redis ElastiCache cluster and link to the locally running Redis server instead.

Setting the dev prop also means that any linked resources will connect to the right Redis instance both in sst dev and sst deploy.

{
  dev: {
    host: "localhost",
    port: 6379
  }
}

dev.host?

Type Input<string>

Default “localhost”

The host of the local Redis server to connect to when running in dev.

dev.password?

Type Input<string>

Default No password

The password of the local Redis server to connect to when running in dev.

dev.port?

Type Input<number>

Default 6379

The port of the local Redis server when running in dev.

dev.username?

Type Input<string>

Default “default”

The username of the local Redis server to connect to when running in dev.

engine?

Type Input<“redis” | “valkey”>

Default “redis”

The Redis engine to use. The following engines are supported:

"redis": The open-source version of Redis.
"valkey": Valkey is a Redis-compatible in-memory key-value store.

instance?

Type Input<string>

Default “t4g.micro”

The type of instance to use for the nodes of the Redis cluster. Check out the supported instance types.

{
  instance: "m7g.xlarge"
}

nodes?

Type Input<number>

Default 1

The number of nodes to use for the Redis cluster.

{
  nodes: 4
}

transform?

Type Object

cluster?
subnetGroup?

Transform how this component creates its underlying resources.

transform.cluster?

Type ReplicationGroupArgs | (args: ReplicationGroupArgs, opts: ComponentResourceOptions, name: string) => void

Transform the Redis cluster.

transform.subnetGroup?

Type SubnetGroupArgs | (args: SubnetGroupArgs, opts: ComponentResourceOptions, name: string) => void

Transform the Redis subnet group.

version?

Type Input<string>

Default "7.1" for Redis, "7.2" for Valkey

The version of Redis.

The default is "7.1" for the "redis" engine and "7.2" for the "valkey" engine.

Check out the supported versions.

{
  version: "6.2"
}

vpc

Type Vpc | Input<Object>

securityGroups
subnets

The VPC to use for the Redis cluster.

Create a VPC component.

const myVpc = new sst.aws.Vpc("MyVpc");

And pass it in.

{
  vpc: myVpc
}

Or pass in a custom VPC configuration.

{
  vpc: {
    subnets: ["subnet-0db7376a7ad4db5fd ", "subnet-06fc7ee8319b2c0ce"],
    securityGroups: ["sg-0399348378a4c256c"]
  }
}

vpc.securityGroups

Type Input<Input<string>[]>

A list of VPC security group IDs.

vpc.subnets

Type Input<Input<string>[]>

A list of subnet IDs in the VPC to deploy the Redis cluster in.

Properties

clusterID

Type Output<string>

The ID of the Redis cluster.

host

Type Output<string>

The host to connect to the Redis cluster.

nodes

Type Object

cluster

The underlying resources this component creates.

nodes.cluster

Type ReplicationGroup

The ElastiCache Redis cluster.

password

Type undefined | Output<string>

The password to connect to the Redis cluster.

port

Type Output<number>

The port to connect to the Redis cluster.

username

Type Output<string>

The username to connect to the Redis cluster.

SDK

Use the SDK in your runtime to interact with your infrastructure.

Methods

static get

Redis.get(name, clusterID, opts?)

Parameters

name string
The name of the component.
clusterID Input<string>
The id of the existing Redis cluster.
opts? ComponentResourceOptions

Returns Redis

Reference an existing Redis cluster with the given cluster name. This is useful when you create a Redis cluster in one stage and want to share it in another. It avoids having to create a new Redis cluster in the other stage.

Imagine you create a cluster in the dev stage. And in your personal stage frank, instead of creating a new cluster, you want to share the same cluster from dev.

const redis = $app.stage === "frank"
  ? sst.aws.Redis.get("MyRedis", "app-dev-myredis")
  : new sst.aws.Redis("MyRedis");

Here app-dev-myredis is the ID of the cluster created in the dev stage. You can find this by outputting the cluster ID in the dev stage.

return {
  cluster: redis.clusterID
};