@studion/infra-code-blocks 0.0.2 → 0.0.4

package/dist/components/project.js

@@ -11,30 +11,41 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Project = void 0;
+exports.Project = exports.MissingHostedZoneId = void 0;
 const pulumi = require("@pulumi/pulumi");
 const aws = require("@pulumi/aws");
 const awsx = require("@pulumi/awsx");
 const upstash = require("@upstash/pulumi");
-const rds_1 = require("./rds");
-const ecs_1 = require("./ecs");
+const database_1 = require("./database");
+const web_server_1 = require("./web-server");
 const redis_1 = require("./redis");
+const static_site_1 = require("./static-site");
+const ec2_ssm_connect_1 = require("./ec2-ssm-connect");
+class MissingHostedZoneId extends Error {
+    constructor(serviceType) {
+        super(`Project::hostedZoneId argument must be provided 
+      in order to create ${serviceType} service`);
+        this.name = this.constructor.name;
+    }
+}
+exports.MissingHostedZoneId = MissingHostedZoneId;
 class Project extends pulumi.ComponentResource {
     constructor(name, args, opts = {}) {
         super('studion:Project', name, {}, opts);
-        this.dbSubnetGroup = null;
-        this.dbSecurityGroup = null;
-        this.cluster = null;
-        this.lbSecurityGroup = null;
-        this.lb = null;
-        this.ecsServiceSecurityGroup = null;
-        this.upstashProvider = null;
         this.services = {};
-        const { services, environment } = args;
+        const { services, environment, hostedZoneId } = args;
         this.name = name;
+        this.hostedZoneId = hostedZoneId;
         this.environment = environment;
         this.vpc = this.createVpc();
         this.createServices(services);
+        if (args.enableSSMConnect) {
+            const sshConfig = new pulumi.Config('ssh');
+            this.ec2SSMConnect = new ec2_ssm_connect_1.Ec2SSMConnect(`${name}-ssm-connect`, {
+                vpc: this.vpc,
+                sshPublicKey: sshConfig.require('publicKey'),
+            });
+        }
         this.registerOutputs();
     }
     createVpc() {
@@ -46,11 +57,8 @@ class Project extends pulumi.ComponentResource {
         return vpc;
     }
     createServices(services) {
-        const hasDatabaseService = services.some(it => it.type === 'DATABASE');
         const hasRedisService = services.some(it => it.type === 'REDIS');
         const hasWebServerService = services.some(it => it.type === 'WEB_SERVER');
-        if (hasDatabaseService)
-            this.createDatabasePrerequisites();
         if (hasRedisService)
             this.createRedisPrerequisites();
         if (hasWebServerService)
@@ -60,26 +68,12 @@ class Project extends pulumi.ComponentResource {
                 this.createDatabaseService(it);
             if (it.type === 'REDIS')
                 this.createRedisService(it);
+            if (it.type === 'STATIC_SITE')
+                this.createStaticSiteService(it);
             if (it.type === 'WEB_SERVER')
                 this.createWebServerService(it);
         });
     }
-    createDatabasePrerequisites() {
-        this.dbSubnetGroup = new aws.rds.SubnetGroup('db-subnet-group', {
-            subnetIds: this.vpc.privateSubnetIds,
-        }, { parent: this });
-        this.dbSecurityGroup = new aws.ec2.SecurityGroup('db-security-group', {
-            vpcId: this.vpc.vpcId,
-            ingress: [
-                {
-                    protocol: 'tcp',
-                    fromPort: 5432,
-                    toPort: 5432,
-                    cidrBlocks: [this.vpc.vpc.cidrBlock],
-                },
-            ],
-        }, { parent: this });
-    }
     createRedisPrerequisites() {
         const upstashConfig = new pulumi.Config('upstash');
         this.upstashProvider = new upstash.Provider('upstash', {
@@ -89,103 +83,40 @@ class Project extends pulumi.ComponentResource {
     }
     createWebServerPrerequisites() {
         this.cluster = new aws.ecs.Cluster(`${this.name}-cluster`, { name: this.name }, { parent: this });
-        this.lbSecurityGroup = new aws.ec2.SecurityGroup('ecs-lb-security-group', {
-            vpcId: this.vpc.vpcId,
-            ingress: [
-                {
-                    fromPort: 80,
-                    toPort: 80,
-                    protocol: 'tcp',
-                    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('ecs-load-balancer', {
-            loadBalancerType: 'application',
-            subnets: this.vpc.publicSubnetIds,
-            securityGroups: [this.lbSecurityGroup.id],
-            internal: false,
-            ipAddressType: 'ipv4',
-        }, { parent: this });
-        this.ecsServiceSecurityGroup = new aws.ec2.SecurityGroup('ecs-service-security-group', {
-            vpcId: this.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 });
     }
     createDatabaseService(options) {
-        if (!this.dbSecurityGroup || !this.dbSubnetGroup)
-            return;
-        const { serviceName, type } = options, rdsOptions = __rest(options, ["serviceName", "type"]);
-        const instance = new rds_1.Rds(serviceName, Object.assign(Object.assign({}, rdsOptions), { subnetGroupName: this.dbSubnetGroup.name, securityGroupIds: [this.dbSecurityGroup.id] }), { parent: this });
-        this.services[serviceName] = instance;
+        const { serviceName, type } = options, databaseOptions = __rest(options, ["serviceName", "type"]);
+        const service = new database_1.Database(serviceName, Object.assign(Object.assign({}, databaseOptions), { vpc: this.vpc }), { parent: this });
+        this.services[serviceName] = service;
     }
     createRedisService(options) {
         if (!this.upstashProvider)
             return;
         const { serviceName } = options, redisOptions = __rest(options, ["serviceName"]);
-        const instance = new redis_1.Redis(serviceName, redisOptions, {
+        const service = new redis_1.Redis(serviceName, redisOptions, {
             parent: this,
             provider: this.upstashProvider,
         });
-        this.services[options.serviceName] = instance;
+        this.services[options.serviceName] = service;
+    }
+    createStaticSiteService(options) {
+        const { serviceName } = options, staticSiteOptions = __rest(options, ["serviceName"]);
+        if (!this.hostedZoneId)
+            throw new MissingHostedZoneId(options.type);
+        const service = new static_site_1.StaticSite(serviceName, Object.assign(Object.assign({}, staticSiteOptions), { hostedZoneId: this.hostedZoneId }), { parent: this });
+        this.services[serviceName] = service;
     }
     createWebServerService(options) {
-        if (!this.cluster || !this.ecsServiceSecurityGroup || !this.lb) {
+        if (!this.cluster)
             return;
-        }
-        const { serviceName, environment, healtCheckPath = '/healtcheck' } = options, ecsOptions = __rest(options, ["serviceName", "environment", "healtCheckPath"]);
-        const lbTargetGroup = new aws.lb.TargetGroup(`${serviceName}-tg`, {
-            port: ecsOptions.port,
-            protocol: 'HTTP',
-            targetType: 'ip',
-            vpcId: this.vpc.vpcId,
-            healthCheck: {
-                healthyThreshold: 3,
-                unhealthyThreshold: 2,
-                interval: 60,
-                timeout: 5,
-                path: healtCheckPath,
-            },
-        }, { parent: this, dependsOn: [this.lb] });
-        const lbListener = new aws.lb.Listener(`${serviceName}-lb-listener`, {
-            loadBalancerArn: this.lb.arn,
-            port: 80,
-            defaultActions: [
-                {
-                    type: 'forward',
-                    targetGroupArn: lbTargetGroup.arn,
-                },
-            ],
-        }, { parent: this, dependsOn: [this.lb, lbTargetGroup] });
+        if (!this.hostedZoneId)
+            throw new MissingHostedZoneId(options.type);
+        const { serviceName, environment } = options, ecsOptions = __rest(options, ["serviceName", "environment"]);
         const parsedEnv = typeof environment === 'function'
             ? environment(this.services)
             : environment;
-        const instance = new ecs_1.EcsService(serviceName, Object.assign(Object.assign({}, ecsOptions), { cluster: this.cluster, subnets: this.vpc.publicSubnetIds, securityGroupIds: [this.ecsServiceSecurityGroup.id], lb: this.lb, lbTargetGroup,
-            lbListener, environment: parsedEnv }), { parent: this });
-        this.services[options.serviceName] = instance;
+        const service = new web_server_1.WebServer(serviceName, Object.assign(Object.assign({}, ecsOptions), { cluster: this.cluster, vpc: this.vpc, hostedZoneId: this.hostedZoneId, environment: parsedEnv }), { parent: this });
+        this.services[options.serviceName] = service;
     }
 }
 exports.Project = Project;

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);
+}