feat: v2 redis components (#67)

* Create elasticache redis component

* Create elasticache redis tests

* Create upstash redis v2 component

* Create upstash redis tests

* Add elasticache redis arg documentation

* Update typing and docs

* Add default elasticache configuration tests

* Implement elasticache redis ping integration test

Author: bornast

package-lock.json

@@ -40,7 +40,7 @@
     "@pulumi/pulumi": "^3.146.0",
     "@pulumi/random": "^4.17.0",
     "@pulumiverse/grafana": "^0.16.3",
-    "@upstash/pulumi": "^0.3.14",
+    "@upstash/pulumi": "^0.5.0",
     "yaml": "^2.7.1"
   },
   "devDependencies": {
@@ -51,13 +51,16 @@
     "@aws-sdk/client-ecs": "^3.766.0",
     "@aws-sdk/client-efs": "^3.758.0",
     "@aws-sdk/client-elastic-load-balancing-v2": "^3.764.0",
+    "@aws-sdk/client-elasticache": "^3.901.0",
     "@aws-sdk/client-route-53": "^3.782.0",
+    "@aws-sdk/client-secrets-manager": "^3.906.0",
     "@aws-sdk/client-servicediscovery": "^3.758.0",
     "@studion/prettier-config": "^0.1.0",
     "@types/node": "^22",
     "exponential-backoff": "^3.1.2",
     "http-status": "^2.1.0",
     "husky": "^9.1.7",
+    "ioredis": "^5.8.1",
     "lint-staged": "^16.1.2",
     "nanospinner": "^1.2.2",
     "pathe": "^2.0.3",

package.json

@@ -28,7 +28,7 @@ export class Redis extends pulumi.ComponentResource {
   username = 'default';
 
   constructor(name: string, args: RedisArgs, opts: RedisOptions) {
-    super('studion:Redis', name, {}, opts);
+    super('studion:LegacyRedis', name, {}, opts);
 
     const project = pulumi.getProject();
     const stack = pulumi.getStack();

src/components/redis.ts

@@ -0,0 +1,116 @@
+import * as aws from '@pulumi/aws';
+import * as pulumi from '@pulumi/pulumi';
+import * as awsx from '@pulumi/awsx';
+import { commonTags } from '../../../constants';
+
+type RedisArgs = {
+  vpc: pulumi.Input<awsx.ec2.Vpc>;
+  /**
+   * Version number of the cache engine to be used
+   * @default '7.1'
+   */
+  engineVersion?: string;
+  /**
+   * Instance type for cache nodes
+   * @default 'cache.t4g.micro'
+   */
+  nodeType?: string;
+  /**
+   * The name of the parameter group to associate with this cache cluster.
+   * @default 'default.redis7'
+   */
+  parameterGroupName?: pulumi.Input<string>;
+  tags?: pulumi.Input<{
+    [key: string]: pulumi.Input<string>;
+  }>;
+};
+
+export const defaults = {
+  engineVersion: '7.1',
+  nodeType: 'cache.t4g.micro',
+  parameterGroupName: 'default.redis7',
+};
+
+export class ElastiCacheRedis extends pulumi.ComponentResource {
+  name: string;
+  vpc: pulumi.Output<awsx.ec2.Vpc>;
+  cluster: aws.elasticache.Cluster;
+  securityGroup: aws.ec2.SecurityGroup;
+  subnetGroup: aws.elasticache.SubnetGroup;
+
+  constructor(
+    name: string,
+    args: RedisArgs,
+    opts: pulumi.ComponentResourceOptions = {},
+  ) {
+    super('studion:Redis:ElastiCache', name, {}, opts);
+    const argsWithDefaults = Object.assign({}, defaults, args);
+
+    this.name = name;
+    this.vpc = pulumi.output(argsWithDefaults.vpc);
+
+    this.securityGroup = this.createSecurityGroup();
+    this.subnetGroup = this.createSubnetGroup();
+    this.cluster = this.createRedisCluster(
+      argsWithDefaults.engineVersion,
+      argsWithDefaults.nodeType,
+      argsWithDefaults.parameterGroupName,
+      argsWithDefaults.tags,
+    );
+
+    this.registerOutputs();
+  }
+
+  private createRedisCluster(
+    engineVersion: RedisArgs['engineVersion'],
+    nodeType: RedisArgs['nodeType'],
+    parameterGroupName: RedisArgs['parameterGroupName'],
+    tags: RedisArgs['tags'],
+  ) {
+    return new aws.elasticache.Cluster(
+      `${this.name}-cluster`,
+      {
+        engine: 'redis',
+        engineVersion: engineVersion,
+        nodeType: nodeType,
+        numCacheNodes: 1,
+        securityGroupIds: [this.securityGroup.id],
+        subnetGroupName: this.subnetGroup.name,
+        parameterGroupName: parameterGroupName,
+        port: 6379,
+        tags: { ...commonTags, ...tags },
+      },
+      { parent: this },
+    );
+  }
+
+  private createSubnetGroup() {
+    return new aws.elasticache.SubnetGroup(
+      `${this.name}-subnet-group`,
+      {
+        subnetIds: this.vpc.isolatedSubnetIds,
+        tags: commonTags,
+      },
+      { parent: this },
+    );
+  }
+
+  private createSecurityGroup() {
+    return new aws.ec2.SecurityGroup(
+      `${this.name}-security-group`,
+      {
+        vpcId: this.vpc.vpcId,
+        ingress: [
+          {
+            protocol: 'tcp',
+            fromPort: 6379,
+            toPort: 6379,
+            cidrBlocks: [this.vpc.vpc.cidrBlock],
+          },
+        ],
+        tags: commonTags,
+      },
+      { parent: this },
+    );
+  }
+}

src/v2/components/redis/elasticache-redis.ts

@@ -0,0 +1,65 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as upstash from '@upstash/pulumi';
+import { Password } from '../../../components/password';
+
+export type RedisArgs = {
+  dbName: pulumi.Input<string>;
+  /**
+   * Primary region for the database
+   * @default 'us-east-1'
+   */
+  primaryRegion?: pulumi.Input<
+    | 'us-east-1'
+    | 'us-west-1'
+    | 'us-west-2'
+    | 'eu-central-1'
+    | 'eu-west-1'
+    | 'sa-east-1'
+    | 'ap-southeast-1'
+    | 'ap-southeast-2'
+  >;
+};
+
+const defaults = {
+  region: 'global',
+  primaryRegion: 'us-east-1',
+};
+
+export interface RedisOptions extends pulumi.ComponentResourceOptions {
+  provider: upstash.Provider;
+}
+
+export class UpstashRedis extends pulumi.ComponentResource {
+  instance: upstash.RedisDatabase;
+  password: Password;
+  username = 'default';
+
+  constructor(name: string, args: RedisArgs, opts: RedisOptions) {
+    super('studion:Redis:Upstash', name, {}, opts);
+
+    const argsWithDefaults = Object.assign({}, defaults, args);
+
+    const dbName =
+      argsWithDefaults.dbName ?? `${pulumi.getProject()}-${pulumi.getStack()}`;
+
+    this.instance = new upstash.RedisDatabase(
+      name,
+      {
+        databaseName: dbName,
+        region: argsWithDefaults.region,
+        primaryRegion: argsWithDefaults.primaryRegion,
+        eviction: true,
+        tls: true,
+      },
+      { provider: opts.provider, parent: this },
+    );
+
+    this.password = new Password(
+      `${name}-database-password`,
+      { value: this.instance.password },
+      { parent: this },
+    );
+
+    this.registerOutputs();
+  }
+}

src/v2/components/redis/upstash-redis.ts

@@ -2,6 +2,8 @@ export { EcsService } from './components/ecs-service';
 export { WebServer } from './components/web-server';
 export { WebServerBuilder } from './components/web-server/builder';
 export { WebServerLoadBalancer } from './components/web-server/load-balancer';
+export { ElastiCacheRedis } from './components/redis/elasticache-redis';
+export { UpstashRedis } from './components/redis/upstash-redis';
 
 import { OtelCollectorBuilder } from './otel/builder';
 import { OtelCollector } from './otel';

src/v2/index.ts

@@ -27,7 +27,11 @@ const programArgs: InlineProgramArgs = {
 };
 
 describe('EcsService component deployment', () => {
-  const region = process.env.AWS_REGION || 'us-east-2';
+  const region = process.env.AWS_REGION;
+  if (!region) {
+    throw new Error('AWS_REGION environment variable is required');
+  }
+
   const ctx: EcsTestContext = {
     outputs: {},
     config: {

tests/ecs-service/index.test.ts

@@ -260,7 +260,10 @@ export function testEcsServiceWithStorage(ctx: EcsTestContext) {
   it('should successfully write to and read from EFS volume', async () => {
     const ecsServiceWithStorage = ctx.outputs.ecsServiceWithStorage.value;
     const clusterName = ctx.outputs.cluster.value.name;
-    const region = process.env.AWS_REGION || 'us-east-2';
+    const region = process.env.AWS_REGION;
+    if (!region) {
+      throw new Error('AWS_REGION environment variable is required');
+    }
     const logsClient = new CloudWatchLogsClient({ region });
 
     const listCommand = new ListTasksCommand({