@sst-community/sst 4.19.0 → 5.0.0-alpha.1

package/platform/types/components/aws/redis.d.ts

@@ -0,0 +1,545 @@
+import { ComponentResourceOptions, Output } from "@pulumi/pulumi";
+import { Component, Transform } from "../component.js";
+import { Link } from "../link.js";
+import { Input } from "../input.js";
+import { elasticache } from "@pulumi/aws";
+import { Vpc } from "./vpc.js";
+import { Redis as RedisV1 } from "./redis-v1";
+export interface RedisArgs {
+    /**
+     * The Redis engine to use. The following engines are supported:
+     *
+     * - `"redis"`: The open-source version of Redis.
+     * - `"valkey"`: [Valkey](https://valkey.io/) is a Redis-compatible in-memory key-value store.
+     *
+     * :::danger
+     * Changing the engine will cause the database to be destroyed and recreated.
+     * :::
+     *
+     * @default `"redis"`
+     */
+    engine?: Input<"redis" | "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](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/supported-engine-versions.html).
+     *
+     * :::caution
+     * Changing the version will cause the instance to restart on the next `sst deploy`,
+     * causing downtime. Learn more about [upgrading databases](/docs/upgrade-aws-databases/).
+     * :::
+     *
+     * @default `"7.1"` for Redis, `"7.2"` for Valkey
+     * @example
+     * ```js
+     * {
+     *   version: "6.2"
+     * }
+     * ```
+     */
+    version?: Input<string>;
+    /**
+     * The type of instance to use for the nodes of the Redis instance. Check out the [supported instance types](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/CacheNodes.SupportedTypes.html).
+     *
+     * :::caution
+     * Changing the instance type will cause the instance to restart on the next `sst deploy`,
+     * causing downtime. Learn more about [upgrading databases](/docs/upgrade-aws-databases/).
+     * :::
+     *
+     * @default `"t4g.micro"`
+     * @example
+     * ```js
+     * {
+     *   instance: "m7g.xlarge"
+     * }
+     * ```
+     */
+    instance?: Input<string>;
+    /**
+     * @deprecated The `cluster.nodes` prop is now the recommended way to configure the
+     * number of nodes in the cluster.
+     */
+    nodes?: Input<number>;
+    /**
+     * Configure cluster mode for Redis.
+     *
+     * @default `{ nodes: 1 }`
+     * @example
+     * Disable cluster mode.
+     * ```js
+     * {
+     *   cluster: false
+     * }
+     * ```
+     */
+    cluster?: Input<boolean | {
+        /**
+         * The number of nodes to use for the Redis cluster.
+         *
+         * @default `1`
+         * @example
+         * ```js
+         * {
+         *   nodes: 4
+         * }
+         * ```
+         */
+        nodes: Input<number>;
+    }>;
+    /**
+     * Key-value pairs that define custom parameters for the Redis's parameter group.
+     * These values override the defaults set by AWS.
+     *
+     * @example
+     * ```js
+     * {
+     *   parameters: {
+     *     "maxmemory-policy": "noeviction"
+     *   }
+     * }
+     * ```
+     */
+    parameters?: Input<Record<string, Input<string>>>;
+    /**
+     * Use [Amazon ElastiCache Serverless](https://docs.aws.amazon.com/AmazonElastiCache/latest/dg/WhatIs.serverless.html)
+     * instead of a provisioned cluster. It scales with your usage and you pay for the data
+     * stored and the compute you use.
+     *
+     * A serverless cache needs `version` 7 or later, which the defaults are. A lower `version`
+     * fails with an error. Only the major part of `version` is used, so `"7.2"` is sent as `"7"`
+     * and ElastiCache picks the minor version.
+     *
+     * When this is set, `instance`, `cluster`, `nodes` and `parameters` are ignored, and
+     * `transform.subnetGroup`, `transform.parameterGroup` and `transform.cluster` don't run.
+     * Use `transform.serverlessCache` instead. The password is set through an ElastiCache user
+     * and user group that SST creates for the cache.
+     *
+     * :::danger
+     * Turning this on or off for an existing Redis replaces it with a different kind of cache,
+     * and its data is lost.
+     * :::
+     *
+     * A serverless cache always uses TLS. By default SST also gives it a generated password for
+     * the `default` user, like a provisioned cluster, so the linked resource has the same `host`,
+     * `port`, `username` and `password`, and the code that connects to it doesn't change. Turn it
+     * off with `password: false`.
+     *
+     * :::note
+     * `Redis.get` only works with provisioned clusters.
+     * :::
+     *
+     * @default `false`
+     * @example
+     * Use the default limits.
+     * ```js
+     * {
+     *   serverless: true
+     * }
+     * ```
+     *
+     * Set your own limits. These cap how far the cache scales, and so what it can cost.
+     * ```js
+     * {
+     *   serverless: {
+     *     storage: { maximum: "100 GB" },
+     *     ecpuPerSecond: { maximum: 50000 }
+     *   }
+     * }
+     * ```
+     */
+    serverless?: boolean | {
+        /**
+         * Protect the cache with a password. SST generates one for the `default` user and links
+         * it as `password`, like a provisioned cluster. Without a password, anything that can
+         * reach the cache inside the VPC can read and write it.
+         *
+         * Set this to `false` for a cache with no password. Then the link has `host`, `port` and
+         * `username`, and no `password`.
+         *
+         * Linked resources get the password, and `sst shell` has it in `Resource.MyRedis.password`.
+         *
+         * With a password, the deploy role needs these ElastiCache actions, on top of the ones for
+         * the cache: `elasticache:CreateUser`, `elasticache:DescribeUsers`, `elasticache:DeleteUser`,
+         * `elasticache:CreateUserGroup`, `elasticache:DescribeUserGroups` and
+         * `elasticache:DeleteUserGroup`. Changing a setting later may also call the matching
+         * `Modify` actions.
+         *
+         * :::danger
+         * Turning this on or off for an existing cache changes how clients connect, so apps
+         * that were linked before have to be deployed again.
+         * :::
+         *
+         * @default `true`
+         */
+        password?: boolean;
+        /**
+         * The amount of data the cache can store, in whole GB. A fraction is rounded up. A
+         * `minimum` and a `maximum` have to be at least `1 GB`, and the `minimum` can't be above
+         * the `maximum`.
+         *
+         * @default `{ maximum: "10 GB" }`
+         * @example
+         * ```js
+         * {
+         *   storage: { minimum: "1 GB", maximum: "100 GB" }
+         * }
+         * ```
+         */
+        storage?: Input<{
+            /**
+             * The smallest amount of storage the cache keeps available.
+             */
+            minimum?: Input<`${number} GB`>;
+            /**
+             * The most data the cache can store.
+             */
+            maximum?: Input<`${number} GB`>;
+        }>;
+        /**
+         * The ElastiCache Processing Units (ECPU) the cache can use per second. A `minimum` and
+         * a `maximum` have to be at least `1`, and the `minimum` can't be above the `maximum`.
+         *
+         * @default `{ maximum: 5000 }`
+         * @example
+         * ```js
+         * {
+         *   ecpuPerSecond: { minimum: 1000, maximum: 50000 }
+         * }
+         * ```
+         */
+        ecpuPerSecond?: Input<{
+            /**
+             * The smallest number of ECPUs per second the cache keeps available.
+             */
+            minimum?: Input<number>;
+            /**
+             * The most ECPUs per second the cache can use.
+             */
+            maximum?: Input<number>;
+        }>;
+    };
+    /**
+     * The VPC to use for the Redis instance.
+     *
+     * @example
+     * Create a VPC component.
+     *
+     * ```js
+     * const myVpc = new sst.aws.Vpc("MyVpc");
+     * ```
+     *
+     * And pass it in.
+     *
+     * ```js
+     * {
+     *   vpc: myVpc
+     * }
+     * ```
+     *
+     * Or pass in a custom VPC configuration.
+     *
+     * ```js
+     * {
+     *   vpc: {
+     *     subnets: ["subnet-0db7376a7ad4db5fd ", "subnet-06fc7ee8319b2c0ce"],
+     *     securityGroups: ["sg-0399348378a4c256c"]
+     *   }
+     * }
+     * ```
+     */
+    vpc: Vpc | Input<{
+        /**
+         * A list of subnet IDs in the VPC to deploy the Redis instance in.
+         */
+        subnets: Input<Input<string>[]>;
+        /**
+         * A list of VPC security group IDs.
+         */
+        securityGroups: Input<Input<string>[]>;
+    }>;
+    /**
+     * Configure how this component works in `sst dev`.
+     *
+     * By default, your Redis instance is deployed in `sst dev`. But if you want to instead
+     * connect to a locally running Redis server, you can configure the `dev` prop.
+     *
+     * :::note
+     * By default, this creates a new Redis ElastiCache instance even in `sst dev`.
+     * :::
+     *
+     * This will skip deploying a Redis ElastiCache instance and link to the locally running
+     * Redis server instead.
+     *
+     * @example
+     *
+     * Setting the `dev` prop also means that any linked resources will connect to the right
+     * Redis instance both in `sst dev` and `sst deploy`.
+     *
+     * ```ts
+     * {
+     *   dev: {
+     *     host: "localhost",
+     *     port: 6379
+     *   }
+     * }
+     * ```
+     */
+    dev?: {
+        /**
+         * The host of the local Redis server to connect to when running in dev.
+         * @default `"localhost"`
+         */
+        host?: Input<string>;
+        /**
+         * The port of the local Redis server when running in dev.
+         * @default `6379`
+         */
+        port?: Input<number>;
+        /**
+         * The username of the local Redis server to connect to when running in dev.
+         * @default `"default"`
+         */
+        username?: Input<string>;
+        /**
+         * The password of the local Redis server to connect to when running in dev.
+         * @default No password
+         */
+        password?: Input<string>;
+    };
+    /**
+     * [Transform](/docs/components#transform) how this component creates its underlying
+     * resources.
+     */
+    transform?: {
+        /**
+         * Transform the Redis subnet group.
+         */
+        subnetGroup?: Transform<elasticache.SubnetGroupArgs>;
+        /**
+         * Transform the Redis parameter group.
+         */
+        parameterGroup?: Transform<elasticache.ParameterGroupArgs>;
+        /**
+         * Transform the Redis cluster.
+         */
+        cluster?: Transform<elasticache.ReplicationGroupArgs>;
+        /**
+         * Transform the Redis serverless cache.
+         */
+        serverlessCache?: Transform<elasticache.ServerlessCacheArgs>;
+    };
+}
+/**
+ * The `Redis` component lets you add a Redis cluster to your app using
+ * [Amazon ElastiCache](https://docs.aws.amazon.com/AmazonElastiCache/latest/red-ug/WhatIs.html).
+ *
+ * @example
+ *
+ * #### Create the cluster
+ *
+ * ```js title="sst.config.ts"
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const redis = new sst.aws.Redis("MyRedis", { vpc });
+ * ```
+ *
+ * #### Create a serverless Redis
+ *
+ * You can also create a serverless Redis instance that automatically scales based on usage.
+ * Check out the [serverless example](/docs/examples/#aws-redis-serverless). It connects with the same
+ * `username` and `password` as a provisioned Redis.
+ *
+ * ```js title="sst.config.ts"
+ * const vpc = new sst.aws.Vpc("MyVpc");
+ * const redis = new sst.aws.Redis("MyRedis", {
+ *   vpc,
+ *   serverless: true
+ * });
+ * ```
+ *
+ * Configure serverless limits.
+ *
+ * ```js title="sst.config.ts"
+ * const redis = new sst.aws.Redis("MyRedis", {
+ *   vpc,
+ *   serverless: {
+ *     storage: { maximum: "100 GB" },
+ *     ecpuPerSecond: { maximum: 50000 }
+ *   }
+ * });
+ * ```
+ *
+ * #### Link to a resource
+ *
+ * You can link your cluster to other resources, like a function or your Next.js app.
+ *
+ * ```ts title="sst.config.ts"
+ * new sst.aws.Nextjs("MyWeb", {
+ *   link: [redis],
+ *   vpc
+ * });
+ * ```
+ *
+ * Once linked, you can connect to it from your function code.
+ *
+ * ```ts title="app/page.tsx" {1,6,7,12,13}
+ * 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.
+ *
+ * ```bash
+ * 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.
+ *
+ * ```ts title="sst.config.ts" {3-6}
+ * 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](/docs/examples/#aws-redis-local).
+ *
+ * ---
+ *
+ * ### 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.
+ *
+ * With `serverless`, you pay for the data stored and the ECPUs used instead. A serverless cache
+ * is billed for at least 1 GB of storage, even when idle, and setting a `minimum` raises that floor.
+ * The `maximum` limits cap what it can cost. Check out the
+ * [ElastiCache Serverless pricing](https://aws.amazon.com/elasticache/pricing/).
+ *
+ * The above are rough estimates for _us-east-1_, check out the
+ * [ElastiCache pricing](https://aws.amazon.com/elasticache/pricing/) for more details.
+ */
+export declare class Redis extends Component implements Link.Linkable {
+    private cluster?;
+    private serverlessCache?;
+    private _authToken?;
+    private dev?;
+    static v1: typeof RedisV1;
+    constructor(name: string, args: RedisArgs, opts?: ComponentResourceOptions);
+    /**
+     * The ID of the Redis cluster, or of the serverless cache when `serverless` is set.
+     * `Redis.get` only works with the ID of a cluster.
+     */
+    get clusterId(): Output<string>;
+    /**
+     * The username to connect to the Redis cluster.
+     */
+    get username(): Output<string>;
+    /**
+     * The password to connect to the Redis cluster. This is `undefined` for a serverless cache
+     * with `password: false`.
+     */
+    get password(): Output<string> | undefined;
+    /**
+     * The host to connect to the Redis cluster.
+     */
+    get host(): Output<string>;
+    /**
+     * The port to connect to the Redis cluster.
+     */
+    get port(): import("@pulumi/pulumi").OutputInstance<number>;
+    /**
+     * The underlying [resources](/docs/components/#nodes) this component creates.
+     */
+    get nodes(): {
+        /**
+         * The ElastiCache Redis cluster. This throws when `serverless` is set, use
+         * `serverlessCache` instead.
+         */
+        readonly cluster: Output<import("@pulumi/aws/elasticache/replicationGroup.js").ReplicationGroup>;
+        /**
+         * The ElastiCache Redis serverless cache. This throws when `serverless` is not set, use
+         * `cluster` instead.
+         */
+        readonly serverlessCache: import("@pulumi/aws/elasticache/serverlessCache.js").ServerlessCache;
+    };
+    /** @internal */
+    getSSTLink(): {
+        properties: {
+            password?: Output<string> | undefined;
+            host: Output<string>;
+            port: import("@pulumi/pulumi").OutputInstance<number>;
+            username: Output<string>;
+        };
+    };
+    /**
+     * 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.
+     *
+     * :::tip
+     * You can use the `static get` method to share Redis clusters across stages.
+     * :::
+     *
+     * :::caution
+     * This only works with a provisioned cluster. The `clusterId` of a cache created with
+     * `serverless` can't be used here and fails with a "Failed to lookup secret" error.
+     * :::
+     *
+     * @param name The name of the component.
+     * @param clusterId The id of the existing Redis cluster.
+     * @param opts Resource options.
+     *
+     * @example
+     * 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`.
+     *
+     * ```ts title="sst.config.ts"
+     * 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.
+     *
+     * ```ts title="sst.config.ts"
+     * return {
+     *   cluster: redis.clusterId
+     * };
+     * ```
+     */
+    static get(name: string, clusterId: Input<string>, opts?: ComponentResourceOptions): Redis;
+}
+//# sourceMappingURL=redis.d.ts.map

package/platform/types/components/aws/redis.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"redis.d.ts","sourceRoot":"","sources":["../../../../src/components/aws/redis.ts"],"names":[],"mappings":"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"}