@studion/infra-code-blocks 0.0.2 → 0.0.3

package/dist/components/redis.d.ts

@@ -1,14 +1,19 @@
 import * as pulumi from '@pulumi/pulumi';
 import * as upstash from '@upstash/pulumi';
 export type RedisArgs = {
+    /**
+     * Redis database name.
+     */
     dbName: pulumi.Input<string>;
+    /**
+     * Region of the database. Possible values are: "global", "eu-west-1", "us-east-1", "us-west-1", "ap-northeast-1" , "eu-central1".
+     */
     region?: pulumi.Input<string>;
 };
 export interface RedisOptions extends pulumi.ComponentResourceOptions {
     provider: upstash.Provider;
 }
-export type RedisInstance = upstash.RedisDatabase;
 export declare class Redis extends pulumi.ComponentResource {
-    instance: RedisInstance;
+    instance: upstash.RedisDatabase;
     constructor(name: string, args: RedisArgs, opts: RedisOptions);
 }

package/dist/components/redis.js

@@ -3,12 +3,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.Redis = void 0;
 const pulumi = require("@pulumi/pulumi");
 const upstash = require("@upstash/pulumi");
+const defaults = {
+    region: 'us-east-1',
+};
 class Redis extends pulumi.ComponentResource {
     constructor(name, args, opts) {
-        super('studion:redis:Instance', name, {}, opts);
+        super('studion:Redis', name, {}, opts);
+        const argsWithDefaults = Object.assign({}, defaults, args);
         this.instance = new upstash.RedisDatabase(name, {
-            databaseName: args.dbName,
-            region: args.region || 'us-east-1',
+            databaseName: argsWithDefaults.dbName,
+            region: argsWithDefaults.region,
             eviction: true,
             tls: true,
         }, { provider: opts.provider, parent: this });

package/dist/components/static-site.d.ts

@@ -0,0 +1,20 @@
+import * as aws from '@pulumi/aws';
+import * as pulumi from '@pulumi/pulumi';
+import { AcmCertificate } from './acm-certificate';
+export type StaticSiteArgs = {
+    /**
+     * The domain which will be used to access the static site.
+     * The domain or subdomain must belong to the provided hostedZone.
+     */
+    domain: pulumi.Input<string>;
+    /**
+     * The ID of the hosted zone.
+     */
+    hostedZoneId: pulumi.Input<string>;
+};
+export declare class StaticSite extends pulumi.ComponentResource {
+    certificate: AcmCertificate;
+    bucket: aws.s3.Bucket;
+    cloudfront: aws.cloudfront.Distribution;
+    constructor(name: string, args: StaticSiteArgs, opts?: pulumi.ComponentResourceOptions);
+}

package/dist/components/static-site.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticSite = void 0;
+const aws = require("@pulumi/aws");
+const pulumi = require("@pulumi/pulumi");
+const acm_certificate_1 = require("./acm-certificate");
+class StaticSite extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:StaticSite', name, {}, opts);
+        const certificate = new acm_certificate_1.AcmCertificate(`${args.domain}-acm-certificate`, {
+            domain: args.domain,
+            hostedZoneId: args.hostedZoneId,
+        }, { parent: this });
+        const bucket = new aws.s3.Bucket(`${name}-bucket`, {
+            bucket: name,
+            website: {
+                indexDocument: 'index.html',
+                errorDocument: 'index.html',
+            },
+        }, { parent: this });
+        const bucketPublicAccessBlock = new aws.s3.BucketPublicAccessBlock(`${name}-bucket-access-block`, {
+            bucket: bucket.id,
+            blockPublicAcls: false,
+            blockPublicPolicy: false,
+            ignorePublicAcls: false,
+            restrictPublicBuckets: false,
+        }, { parent: this });
+        const siteBucketPolicy = new aws.s3.BucketPolicy(`${name}-bucket-policy`, {
+            bucket: bucket.bucket,
+            policy: bucket.bucket.apply(publicReadPolicy),
+        }, { parent: this, dependsOn: [bucketPublicAccessBlock] });
+        function publicReadPolicy(bucketName) {
+            return {
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Effect: 'Allow',
+                        Principal: '*',
+                        Action: ['s3:GetObject'],
+                        Resource: [`arn:aws:s3:::${bucketName}/*`],
+                    },
+                ],
+            };
+        }
+        const cloudfront = new aws.cloudfront.Distribution(`${name}-cloudfront`, {
+            enabled: true,
+            defaultRootObject: 'index.html',
+            aliases: [args.domain],
+            isIpv6Enabled: true,
+            waitForDeployment: true,
+            httpVersion: 'http2and3',
+            viewerCertificate: {
+                acmCertificateArn: certificate.certificate.arn,
+                sslSupportMethod: 'sni-only',
+                minimumProtocolVersion: 'TLSv1.2_2021',
+            },
+            origins: [
+                {
+                    originId: bucket.arn,
+                    domainName: bucket.websiteEndpoint,
+                    connectionAttempts: 3,
+                    connectionTimeout: 10,
+                    customOriginConfig: {
+                        originProtocolPolicy: 'http-only',
+                        httpPort: 80,
+                        httpsPort: 443,
+                        originSslProtocols: ['TLSv1.2'],
+                    },
+                },
+            ],
+            defaultCacheBehavior: {
+                targetOriginId: bucket.arn,
+                viewerProtocolPolicy: 'redirect-to-https',
+                allowedMethods: ['GET', 'HEAD', 'OPTIONS'],
+                cachedMethods: ['GET', 'HEAD', 'OPTIONS'],
+                compress: true,
+                defaultTtl: 86400,
+                minTtl: 1,
+                maxTtl: 31536000,
+                forwardedValues: {
+                    cookies: { forward: 'none' },
+                    queryString: false,
+                },
+            },
+            priceClass: 'PriceClass_100',
+            restrictions: {
+                geoRestriction: { restrictionType: 'none' },
+            },
+        }, { parent: this });
+        const cdnAliasRecord = new aws.route53.Record(`${name}-cdn-route53-record`, {
+            type: 'A',
+            name: args.domain,
+            zoneId: args.hostedZoneId,
+            aliases: [
+                {
+                    name: cloudfront.domainName,
+                    zoneId: cloudfront.hostedZoneId,
+                    evaluateTargetHealth: true,
+                },
+            ],
+        }, { parent: this });
+        this.certificate = certificate;
+        this.bucket = bucket;
+        this.cloudfront = cloudfront;
+        this.registerOutputs();
+    }
+}
+exports.StaticSite = StaticSite;

package/dist/components/web-server.d.ts

@@ -0,0 +1,86 @@
+import * as pulumi from '@pulumi/pulumi';
+import * as aws from '@pulumi/aws';
+import * as awsx from '@pulumi/awsx';
+import { Size } from './types';
+import { AcmCertificate } from './acm-certificate';
+export type RoleInlinePolicy = {
+    /**
+     * Name of the role policy.
+     */
+    name?: pulumi.Input<string>;
+    /**
+     * Policy document as a JSON formatted string.
+     */
+    policy?: pulumi.Input<string>;
+};
+export type WebServerArgs = {
+    /**
+     * The ECR image used to start a container.
+     */
+    image: pulumi.Input<string>;
+    /**
+     * Exposed service port.
+     */
+    port: pulumi.Input<number>;
+    /**
+     * The domain which will be used to access the service.
+     * The domain or subdomain must belong to the provided hostedZone.
+     */
+    domain: pulumi.Input<string>;
+    /**
+     * The aws.ecs.Cluster resource.
+     */
+    cluster: aws.ecs.Cluster;
+    /**
+     * The ID of the hosted zone.
+     */
+    hostedZoneId: pulumi.Input<string>;
+    /**
+     * The awsx.ec2.Vpc resource.
+     */
+    vpc: awsx.ec2.Vpc;
+    /**
+     * Number of instances of the task definition to place and keep running. Defaults to 1.
+     */
+    desiredCount?: pulumi.Input<number>;
+    /**
+     * Min capacity of the scalable target. Defaults to 1.
+     */
+    minCount?: pulumi.Input<number>;
+    /**
+     * Max capacity of the scalable target. Defaults to 10.
+     */
+    maxCount?: pulumi.Input<number>;
+    /**
+     * CPU and memory size used for running the container. Defaults to "small".
+     * Available predefined options are:
+     * - small (0.25 vCPU, 0.5 GB memory)
+     * - medium (0.5 vCPU, 1 GB memory)
+     * - large (1 vCPU memory, 2 GB memory)
+     * - xlarge (2 vCPU, 4 GB memory)
+     */
+    size?: pulumi.Input<Size>;
+    /**
+     * The environment variables to pass to a container. Defaults to [].
+     */
+    environment?: aws.ecs.KeyValuePair[];
+    /**
+     * Path for the health check request. Defaults to "/healtcheck".
+     */
+    healtCheckPath?: pulumi.Input<string>;
+    taskExecutionRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
+    taskRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
+};
+export declare class WebServer extends pulumi.ComponentResource {
+    certificate: AcmCertificate;
+    logGroup: aws.cloudwatch.LogGroup;
+    lbSecurityGroup: aws.ec2.SecurityGroup;
+    lb: aws.lb.LoadBalancer;
+    lbTargetGroup: aws.lb.TargetGroup;
+    lbHttpListener: aws.lb.Listener;
+    lbTlsListener: aws.lb.Listener;
+    serviceSecurityGroup: aws.ec2.SecurityGroup;
+    taskDefinition: aws.ecs.TaskDefinition;
+    service: aws.ecs.Service;
+    constructor(name: string, args: WebServerArgs, opts?: pulumi.ComponentResourceOptions);
+}

package/dist/components/web-server.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebServer = void 0;
+const pulumi = require("@pulumi/pulumi");
+const aws = require("@pulumi/aws");
+const constants_1 = require("../constants");
+const acm_certificate_1 = require("./acm-certificate");
+const config = new pulumi.Config('aws');
+const awsRegion = config.require('region');
+const assumeRolePolicy = {
+    Version: '2012-10-17',
+    Statement: [
+        {
+            Action: 'sts:AssumeRole',
+            Principal: {
+                Service: 'ecs-tasks.amazonaws.com',
+            },
+            Effect: 'Allow',
+            Sid: '',
+        },
+    ],
+};
+const defaults = {
+    desiredCount: 1,
+    minCount: 1,
+    maxCount: 10,
+    size: 'small',
+    environment: [],
+    healtCheckPath: '/healtcheck',
+    taskExecutionRoleInlinePolicies: [],
+    taskRoleInlinePolicies: [],
+};
+class WebServer extends pulumi.ComponentResource {
+    constructor(name, args, opts = {}) {
+        super('studion:WebServer', name, {}, opts);
+        const argsWithDefaults = Object.assign({}, defaults, args);
+        this.certificate = new acm_certificate_1.AcmCertificate(`${argsWithDefaults.domain}-acm-certificate`, {
+            domain: argsWithDefaults.domain,
+            hostedZoneId: argsWithDefaults.hostedZoneId,
+        }, { parent: this });
+        this.logGroup = new aws.cloudwatch.LogGroup(`${name}-log-group`, {
+            retentionInDays: 14,
+            name: `/ecs/${name}`,
+        }, { parent: this });
+        this.lbSecurityGroup = new aws.ec2.SecurityGroup(`${name}-lb-security-group`, {
+            vpcId: argsWithDefaults.vpc.vpcId,
+            ingress: [
+                {
+                    protocol: 'tcp',
+                    fromPort: 80,
+                    toPort: 80,
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+                {
+                    protocol: 'tcp',
+                    fromPort: 443,
+                    toPort: 443,
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+            ],
+            egress: [
+                {
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+            ],
+        }, { parent: this });
+        this.lb = new aws.lb.LoadBalancer(`${name}-lb`, {
+            name: `${name}-lb`,
+            loadBalancerType: 'application',
+            subnets: argsWithDefaults.vpc.publicSubnetIds,
+            securityGroups: [this.lbSecurityGroup.id],
+            internal: false,
+            ipAddressType: 'ipv4',
+        }, { parent: this });
+        this.lbTargetGroup = new aws.lb.TargetGroup(`${name}-lb-tg`, {
+            name: `${name}-lb-tg`,
+            port: argsWithDefaults.port,
+            protocol: 'HTTP',
+            targetType: 'ip',
+            vpcId: argsWithDefaults.vpc.vpcId,
+            healthCheck: {
+                healthyThreshold: 3,
+                unhealthyThreshold: 2,
+                interval: 60,
+                timeout: 5,
+                path: argsWithDefaults.healtCheckPath,
+            },
+        }, { parent: this, dependsOn: [this.lb] });
+        this.lbHttpListener = new aws.lb.Listener(`${name}-lb-listener-80`, {
+            loadBalancerArn: this.lb.arn,
+            port: 80,
+            defaultActions: [
+                {
+                    type: 'redirect',
+                    redirect: {
+                        port: '443',
+                        protocol: 'HTTPS',
+                        statusCode: 'HTTP_301',
+                    },
+                },
+            ],
+        }, { parent: this });
+        this.lbTlsListener = new aws.lb.Listener(`${name}-lb-listener-443`, {
+            loadBalancerArn: this.lb.arn,
+            port: 443,
+            protocol: 'HTTPS',
+            sslPolicy: 'ELBSecurityPolicy-2016-08',
+            certificateArn: this.certificate.certificate.arn,
+            defaultActions: [
+                {
+                    type: 'forward',
+                    targetGroupArn: this.lbTargetGroup.arn,
+                },
+            ],
+        }, { parent: this });
+        const albAliasRecord = new aws.route53.Record(`${name}-route53-record`, {
+            type: 'A',
+            name: argsWithDefaults.domain,
+            zoneId: argsWithDefaults.hostedZoneId,
+            aliases: [
+                {
+                    name: this.lb.dnsName,
+                    zoneId: this.lb.zoneId,
+                    evaluateTargetHealth: true,
+                },
+            ],
+        }, { parent: this });
+        const taskExecutionRole = new aws.iam.Role(`${name}-ecs-task-exec-role`, {
+            name: `${name}-ecs-task-exec-role`,
+            assumeRolePolicy,
+            managedPolicyArns: [
+                'arn:aws:iam::aws:policy/CloudWatchFullAccess',
+                'arn:aws:iam::aws:policy/AmazonEC2ContainerRegistryFullAccess',
+            ],
+            inlinePolicies: argsWithDefaults.taskExecutionRoleInlinePolicies,
+        }, { parent: this });
+        const execCmdInlinePolicy = {
+            name: 'ecs-exec',
+            policy: JSON.stringify({
+                Version: '2012-10-17',
+                Statement: [
+                    {
+                        Sid: 'AllowContainerToCreateECSExecSSMChannel',
+                        Effect: 'Allow',
+                        Action: [
+                            'ssmmessages:CreateControlChannel',
+                            'ssmmessages:CreateDataChannel',
+                            'ssmmessages:OpenControlChannel',
+                            'ssmmessages:OpenDataChannel',
+                        ],
+                        Resource: '*',
+                    },
+                ],
+            }),
+        };
+        const taskRole = new aws.iam.Role(`${name}-ecs-task-role`, {
+            name: `${name}-ecs-task-role`,
+            assumeRolePolicy,
+            inlinePolicies: [
+                execCmdInlinePolicy,
+                ...argsWithDefaults.taskRoleInlinePolicies,
+            ],
+        }, { parent: this });
+        const parsedSize = pulumi.all([argsWithDefaults.size]).apply(([size]) => {
+            const mapCapabilities = ({ cpu, memory }) => ({
+                cpu: String(cpu),
+                memory: String(memory),
+            });
+            if (typeof size === 'string') {
+                return mapCapabilities(constants_1.PredefinedSize[size]);
+            }
+            if (typeof size === 'object') {
+                return mapCapabilities(size);
+            }
+            throw Error('Incorrect EcsService size argument');
+        });
+        this.taskDefinition = new aws.ecs.TaskDefinition(`${name}-task-definition`, {
+            family: `${name}-task-definition`,
+            networkMode: 'awsvpc',
+            executionRoleArn: taskExecutionRole.arn,
+            taskRoleArn: taskRole.arn,
+            cpu: parsedSize.cpu,
+            memory: parsedSize.memory,
+            requiresCompatibilities: ['FARGATE'],
+            containerDefinitions: pulumi
+                .all([
+                name,
+                argsWithDefaults.image,
+                argsWithDefaults.port,
+                argsWithDefaults.environment,
+                this.logGroup.name,
+                awsRegion,
+            ])
+                .apply(([containerName, image, port, environment, logGroup, region]) => {
+                return JSON.stringify([
+                    {
+                        readonlyRootFilesystem: true,
+                        name: containerName,
+                        image,
+                        essential: true,
+                        portMappings: [
+                            {
+                                containerPort: port,
+                                protocol: 'tcp',
+                            },
+                        ],
+                        logConfiguration: {
+                            logDriver: 'awslogs',
+                            options: {
+                                'awslogs-group': logGroup,
+                                'awslogs-region': region,
+                                'awslogs-stream-prefix': 'ecs',
+                            },
+                        },
+                        environment,
+                    },
+                ]);
+            }),
+        }, { parent: this });
+        this.serviceSecurityGroup = new aws.ec2.SecurityGroup(`${name}-security-group`, {
+            vpcId: argsWithDefaults.vpc.vpcId,
+            ingress: [
+                {
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    securityGroups: [this.lbSecurityGroup.id],
+                },
+            ],
+            egress: [
+                {
+                    fromPort: 0,
+                    toPort: 0,
+                    protocol: '-1',
+                    cidrBlocks: ['0.0.0.0/0'],
+                },
+            ],
+        }, { parent: this });
+        this.service = new aws.ecs.Service(`${name}-service`, {
+            name,
+            cluster: argsWithDefaults.cluster.id,
+            launchType: 'FARGATE',
+            desiredCount: argsWithDefaults.desiredCount,
+            taskDefinition: this.taskDefinition.arn,
+            enableExecuteCommand: true,
+            loadBalancers: [
+                {
+                    containerName: name,
+                    containerPort: argsWithDefaults.port,
+                    targetGroupArn: this.lbTargetGroup.arn,
+                },
+            ],
+            networkConfiguration: {
+                assignPublicIp: true,
+                subnets: argsWithDefaults.vpc.publicSubnetIds,
+                securityGroups: [this.serviceSecurityGroup.id],
+            },
+        }, {
+            parent: this,
+            dependsOn: [
+                this.lb,
+                this.lbTargetGroup,
+                this.lbHttpListener,
+                this.lbTlsListener,
+            ],
+        });
+        const autoscalingTarget = new aws.appautoscaling.Target(`${name}-autoscale-target`, {
+            minCapacity: argsWithDefaults.minCount,
+            maxCapacity: argsWithDefaults.maxCount,
+            resourceId: pulumi.interpolate `service/${argsWithDefaults.cluster.name}/${this.service.name}`,
+            serviceNamespace: 'ecs',
+            scalableDimension: 'ecs:service:DesiredCount',
+        }, { parent: this });
+        const memoryAutoscalingPolicy = new aws.appautoscaling.Policy(`${name}-memory-autoscale-policy`, {
+            policyType: 'TargetTrackingScaling',
+            resourceId: autoscalingTarget.resourceId,
+            scalableDimension: autoscalingTarget.scalableDimension,
+            serviceNamespace: autoscalingTarget.serviceNamespace,
+            targetTrackingScalingPolicyConfiguration: {
+                predefinedMetricSpecification: {
+                    predefinedMetricType: 'ECSServiceAverageMemoryUtilization',
+                },
+                targetValue: 80,
+            },
+        }, { parent: this });
+        const cpuAutoscalingPolicy = new aws.appautoscaling.Policy(`${name}-cpu-autoscale-policy`, {
+            policyType: 'TargetTrackingScaling',
+            resourceId: autoscalingTarget.resourceId,
+            scalableDimension: autoscalingTarget.scalableDimension,
+            serviceNamespace: autoscalingTarget.serviceNamespace,
+            targetTrackingScalingPolicyConfiguration: {
+                predefinedMetricSpecification: {
+                    predefinedMetricType: 'ECSServiceAverageCPUUtilization',
+                },
+                targetValue: 60,
+            },
+        }, { parent: this });
+        this.registerOutputs();
+    }
+}
+exports.WebServer = WebServer;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-export * from './components/ecs';
-export * from './components/rds';
+export * from './components/web-server';
+export * from './components/static-site';
+export * from './components/database';
 export * from './components/redis';
 export * from './components/project';
+export * from './components/ec2-ssm-connect';

package/dist/index.js

@@ -14,7 +14,9 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./components/ecs"), exports);
-__exportStar(require("./components/rds"), exports);
+__exportStar(require("./components/web-server"), exports);
+__exportStar(require("./components/static-site"), exports);
+__exportStar(require("./components/database"), exports);
 __exportStar(require("./components/redis"), exports);
 __exportStar(require("./components/project"), exports);
+__exportStar(require("./components/ec2-ssm-connect"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@studion/infra-code-blocks",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Studion common infra components",
   "keywords": [
     "infrastructure",
@@ -24,10 +24,10 @@
     "dist"
   ],
   "scripts": {
-    "build": "npm run clean && tsc",
     "clean": "rm -rf dist",
+    "build": "npm run clean && tsc",
     "format": "prettier -w .",
-    "release": "release-it",
+    "release": "npm run build && release-it",
     "test": ""
   },
   "prettier": "@studion/prettier-config",

package/dist/components/ecs.d.ts

@@ -1,33 +0,0 @@
-import * as pulumi from '@pulumi/pulumi';
-import * as aws from '@pulumi/aws';
-import { Size } from './types';
-export type RoleInlinePolicy = {
-    /**
-     * Name of the role policy.
-     */
-    name?: pulumi.Input<string>;
-    /**
-     * Policy document as a JSON formatted string.
-     */
-    policy?: pulumi.Input<string>;
-};
-export type EcsServiceArgs = {
-    image: pulumi.Input<string>;
-    port: pulumi.Input<number>;
-    cluster: aws.ecs.Cluster;
-    subnets: pulumi.Input<pulumi.Input<string>[]>;
-    securityGroupIds: pulumi.Input<pulumi.Input<string>[]>;
-    lb: aws.lb.LoadBalancer;
-    lbTargetGroup: aws.lb.TargetGroup;
-    lbListener: aws.lb.Listener;
-    desiredCount?: pulumi.Input<number>;
-    minCount?: pulumi.Input<number>;
-    maxCount?: pulumi.Input<number>;
-    size?: pulumi.Input<Size>;
-    environment?: aws.ecs.KeyValuePair[];
-    taskExecutionRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
-    taskRoleInlinePolicies?: pulumi.Input<pulumi.Input<RoleInlinePolicy>[]>;
-};
-export declare class EcsService extends pulumi.ComponentResource {
-    constructor(name: string, args: EcsServiceArgs, opts?: pulumi.ComponentResourceOptions);
-}