low-cost-ecs 0.0.6

package/lib/low-cost-ecs.js

@@ -0,0 +1,273 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LowCostECS = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const lib = require("aws-cdk-lib");
+const ec2 = require("aws-cdk-lib/aws-ec2");
+const ecs = require("aws-cdk-lib/aws-ecs");
+const aws_efs_1 = require("aws-cdk-lib/aws-efs");
+const aws_events_1 = require("aws-cdk-lib/aws-events");
+const aws_events_targets_1 = require("aws-cdk-lib/aws-events-targets");
+const aws_iam_1 = require("aws-cdk-lib/aws-iam");
+const aws_logs_1 = require("aws-cdk-lib/aws-logs");
+const route53 = require("aws-cdk-lib/aws-route53");
+const aws_sns_1 = require("aws-cdk-lib/aws-sns");
+const sfn = require("aws-cdk-lib/aws-stepfunctions");
+const sfn_tasks = require("aws-cdk-lib/aws-stepfunctions-tasks");
+;
+class LowCostECS extends lib.Stack {
+    constructor(scope, id, props) {
+        super(scope, id, props);
+        const vpc = props.vpc ??
+            new ec2.Vpc(this, 'Vpc', {
+                natGateways: 0,
+                subnetConfiguration: [
+                    {
+                        name: 'PublicSubnet',
+                        subnetType: ec2.SubnetType.PUBLIC,
+                    },
+                ],
+            });
+        const cluster = new ecs.Cluster(this, 'Cluster', {
+            vpc,
+            containerInsights: props.containerInsights,
+        });
+        const hostAutoScalingGroup = cluster.addCapacity('HostInstanceCapacity', {
+            machineImage: ecs.EcsOptimizedImage.amazonLinux2(ecs.AmiHardwareType.STANDARD, {
+                cachedInContext: true,
+            }),
+            instanceType: new ec2.InstanceType(props.hostInstanceType ?? 't2.micro'),
+            spotPrice: props.hostInstanceSpotPrice,
+            vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },
+            associatePublicIpAddress: true,
+            minCapacity: 1,
+            maxCapacity: 1,
+        });
+        if (props.securityGroup) {
+            hostAutoScalingGroup.addSecurityGroup(props.securityGroup);
+        }
+        else {
+            hostAutoScalingGroup.connections.allowFromAnyIpv4(ec2.Port.tcp(80));
+            hostAutoScalingGroup.connections.allowFromAnyIpv4(ec2.Port.tcp(443));
+            hostAutoScalingGroup.connections.allowFrom(ec2.Peer.anyIpv6(), ec2.Port.tcp(80));
+            hostAutoScalingGroup.connections.allowFrom(ec2.Peer.anyIpv6(), ec2.Port.tcp(443));
+        }
+        /**
+         * Add managed policy to allow ssh through ssm manager
+         */
+        hostAutoScalingGroup.role.addManagedPolicy(aws_iam_1.ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'));
+        /**
+         * Add policy to associate elastic ip on startup
+         */
+        hostAutoScalingGroup.role.addToPrincipalPolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: ['ec2:DescribeAddresses', 'ec2:AssociateAddress'],
+            resources: ['*'],
+        }));
+        const hostInstanceIp = new ec2.CfnEIP(this, 'HostInstanceIp');
+        const tagUniqueId = lib.Names.uniqueId(hostInstanceIp);
+        hostInstanceIp.tags.setTag('Name', tagUniqueId);
+        const awsCliTag = props.awsCliDockerTag ?? 'latest';
+        hostAutoScalingGroup.addUserData('INSTANCE_ID=$(curl --silent http://169.254.169.254/latest/meta-data/instance-id)', `ALLOCATION_ID=$(docker run --net=host amazon/aws-cli:${awsCliTag} ec2 describe-addresses --region ${hostAutoScalingGroup.env.region} --filter Name=tag:Name,Values=${tagUniqueId} --query 'Addresses[].AllocationId' --output text | head)`, `docker run --net=host amazon/aws-cli:${awsCliTag} ec2 associate-address --region ${hostAutoScalingGroup.env.region} --instance-id "$INSTANCE_ID" --allocation-id "$ALLOCATION_ID" --allow-reassociation`);
+        const certFileSystem = new aws_efs_1.FileSystem(this, 'FileSystem', {
+            vpc,
+            encrypted: true,
+            securityGroup: new ec2.SecurityGroup(this, 'FileSystemSecurityGroup', {
+                vpc,
+                allowAllOutbound: false,
+            }),
+            removalPolicy: props.removalPolicy ?? lib.RemovalPolicy.DESTROY,
+        });
+        certFileSystem.connections.allowDefaultPortTo(hostAutoScalingGroup);
+        certFileSystem.connections.allowDefaultPortFrom(hostAutoScalingGroup);
+        /**
+         * ARecord to Elastic ip
+         */
+        const hostedZone = route53.HostedZone.fromLookup(this, 'HostedZone', {
+            domainName: props.hostedZoneDomain,
+        });
+        const records = props.recordDomainNames ?? [hostedZone.zoneName];
+        records.forEach((record) => new route53.ARecord(this, `ARecord${record}`, {
+            zone: hostedZone,
+            recordName: record,
+            target: route53.RecordTarget.fromIpAddresses(hostInstanceIp.ref),
+        }));
+        /**
+         * Certbot Task Definition
+         * Mounts generated certificate to EFS
+         */
+        const logGroup = props.logGroup ??
+            new aws_logs_1.LogGroup(this, 'LogGroup', {
+                retention: aws_logs_1.RetentionDays.TWO_YEARS,
+                removalPolicy: props.removalPolicy ?? lib.RemovalPolicy.DESTROY,
+            });
+        const certbotTaskDefinition = new ecs.Ec2TaskDefinition(this, 'CertbotTaskDefinition');
+        certbotTaskDefinition.addToTaskRolePolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: ['route53:ListHostedZones', 'route53:GetChange'],
+            resources: ['*'],
+        }));
+        certbotTaskDefinition.addToTaskRolePolicy(new aws_iam_1.PolicyStatement({
+            effect: aws_iam_1.Effect.ALLOW,
+            actions: ['route53:ChangeResourceRecordSets'],
+            resources: [hostedZone.hostedZoneArn],
+        }));
+        const certbotTag = props.certbotDockerTag ?? 'v1.29.0';
+        const certbotContainer = certbotTaskDefinition.addContainer('CertbotContainer', {
+            image: ecs.ContainerImage.fromRegistry(`certbot/dns-route53:${certbotTag}`),
+            containerName: 'certbot',
+            memoryReservationMiB: 64,
+            command: [
+                'certonly',
+                '--verbose',
+                '--preferred-challenges=dns-01',
+                '--dns-route53',
+                '--dns-route53-propagation-seconds=300',
+                '--non-interactive',
+                '--agree-tos',
+                '--expand',
+                '-m',
+                props.email,
+                '--cert-name',
+                records[0],
+                ...records.flatMap((domain) => ['-d', domain]),
+            ],
+            logging: ecs.LogDriver.awsLogs({
+                logGroup,
+                streamPrefix: certbotTag,
+            }),
+        });
+        certFileSystem.grant(certbotTaskDefinition.taskRole, 'elasticfilesystem:ClientWrite');
+        certbotTaskDefinition.addVolume({
+            name: 'certVolume',
+            efsVolumeConfiguration: {
+                fileSystemId: certFileSystem.fileSystemId,
+            },
+        });
+        certbotContainer.addMountPoints({
+            sourceVolume: 'certVolume',
+            containerPath: '/etc/letsencrypt',
+            readOnly: false,
+        });
+        /**
+         * Schedule Certbot certificate create/renew on Step Functions
+         * Sends email notification on certbot failure
+         */
+        const topic = new aws_sns_1.Topic(this, 'Topic');
+        new aws_sns_1.Subscription(this, 'EmailSubscription', {
+            topic: topic,
+            protocol: aws_sns_1.SubscriptionProtocol.EMAIL,
+            endpoint: props.email,
+        });
+        const certbotRunTask = new sfn_tasks.EcsRunTask(this, 'CreateCertificate', {
+            cluster: cluster,
+            taskDefinition: certbotTaskDefinition,
+            launchTarget: new sfn_tasks.EcsEc2LaunchTarget(),
+            integrationPattern: sfn.IntegrationPattern.RUN_JOB,
+        });
+        certbotRunTask.addCatch(new sfn_tasks.SnsPublish(this, 'SendEmailOnFailure', {
+            topic: topic,
+            message: sfn.TaskInput.fromJsonPathAt('$'),
+        }).next(new sfn.Fail(this, 'Fail')));
+        certbotRunTask.addRetry({
+            interval: lib.Duration.seconds(20),
+        });
+        const certbotStateMachine = new sfn.StateMachine(this, 'StateMachine', {
+            definition: certbotRunTask,
+        });
+        new aws_events_1.Rule(this, 'CertbotScheduleRule', {
+            schedule: aws_events_1.Schedule.rate(lib.Duration.days(props.certbotScheduleInterval ?? 60)),
+            targets: [new aws_events_targets_1.SfnStateMachine(certbotStateMachine)],
+        });
+        /**
+         * Server ECS task
+         */
+        const serverTaskDefinition = props.serverTaskDefinition ?? this.sampleSeverTask(records, logGroup);
+        certFileSystem.grant(serverTaskDefinition.taskRole, 'elasticfilesystem:ClientMount');
+        serverTaskDefinition.addVolume({
+            name: 'certVolume',
+            efsVolumeConfiguration: {
+                fileSystemId: certFileSystem.fileSystemId,
+            },
+        });
+        serverTaskDefinition.defaultContainer?.addMountPoints({
+            sourceVolume: 'certVolume',
+            containerPath: '/etc/letsencrypt',
+            readOnly: true,
+        });
+        /**
+         * AWS cli container to execute certbot sfn before the default container startup.
+         */
+        serverTaskDefinition.defaultContainer?.addContainerDependencies({
+            container: serverTaskDefinition.addContainer('AWSCliContainer', {
+                image: ecs.ContainerImage.fromRegistry(`amazon/aws-cli:${awsCliTag}`),
+                containerName: 'aws-cli',
+                memoryReservationMiB: 64,
+                entryPoint: ['/bin/bash', '-c'],
+                command: [
+                    `set -eux
+          aws configure set region ${certbotStateMachine.env.region} && \\
+          aws configure set output text && \\
+          EXECUTION_ARN=$(aws stepfunctions start-execution --state-machine-arn ${certbotStateMachine.stateMachineArn} --query executionArn) && \\
+          until [ $(aws stepfunctions describe-execution --execution-arn "$EXECUTION_ARN" --query status) != RUNNING ];
+          do
+            echo "Waiting for $EXECUTION_ARN"
+            sleep 10
+          done`,
+                ],
+                essential: false,
+                logging: ecs.LogDriver.awsLogs({
+                    logGroup: logGroup,
+                    streamPrefix: awsCliTag,
+                }),
+            }),
+            condition: ecs.ContainerDependencyCondition.COMPLETE,
+        });
+        certbotStateMachine.grantExecution(serverTaskDefinition.taskRole, 'states:DescribeExecution');
+        certbotStateMachine.grantStartExecution(serverTaskDefinition.taskRole);
+        new ecs.Ec2Service(this, 'Service', {
+            cluster: cluster,
+            taskDefinition: serverTaskDefinition,
+            desiredCount: 1,
+            minHealthyPercent: 0,
+            maxHealthyPercent: 100,
+            circuitBreaker: {
+                rollback: true,
+            },
+            enableExecuteCommand: true,
+        });
+    }
+    sampleSeverTask(records, logGroup) {
+        const nginxTaskDefinition = new ecs.Ec2TaskDefinition(this, 'NginxTaskDefinition');
+        const nginxContainer = nginxTaskDefinition.addContainer('NginxContainer', {
+            image: ecs.ContainerImage.fromAsset(path.join(__dirname, '../containers/nginx-proxy')),
+            containerName: 'nginx',
+            memoryReservationMiB: 64,
+            essential: true,
+            environment: {
+                SERVER_NAME: records.join(' '),
+                CERT_NAME: records[0],
+            },
+            logging: ecs.LogDrivers.awsLogs({
+                logGroup: logGroup,
+                streamPrefix: 'nginx-proxy',
+            }),
+        });
+        nginxContainer.addPortMappings({
+            hostPort: 80,
+            containerPort: 80,
+            protocol: ecs.Protocol.TCP,
+        }, {
+            hostPort: 443,
+            containerPort: 443,
+            protocol: ecs.Protocol.TCP,
+        });
+        return nginxTaskDefinition;
+    }
+}
+exports.LowCostECS = LowCostECS;
+_a = JSII_RTTI_SYMBOL_1;
+LowCostECS[_a] = { fqn: "low-cost-ecs.LowCostECS", version: "0.0.6" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"low-cost-ecs.js","sourceRoot":"","sources":["../src/low-cost-ecs.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as lib from 'aws-cdk-lib';\nimport * as ec2 from 'aws-cdk-lib/aws-ec2';\nimport * as ecs from 'aws-cdk-lib/aws-ecs';\nimport { FileSystem } from 'aws-cdk-lib/aws-efs';\nimport { Rule, Schedule } from 'aws-cdk-lib/aws-events';\nimport { SfnStateMachine } from 'aws-cdk-lib/aws-events-targets';\nimport { Effect, ManagedPolicy, PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { ILogGroup, LogGroup, RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport * as route53 from 'aws-cdk-lib/aws-route53';\nimport { Subscription, SubscriptionProtocol, Topic } from 'aws-cdk-lib/aws-sns';\nimport * as sfn from 'aws-cdk-lib/aws-stepfunctions';\nimport * as sfn_tasks from 'aws-cdk-lib/aws-stepfunctions-tasks';\nimport { Construct } from 'constructs';\n\nexport interface LowCostECSProps extends lib.StackProps {\n  /**\n   * Domain name of the hosted zone.\n   */\n  readonly hostedZoneDomain: string;\n\n  /**\n   * Email for expiration emails to register to your let's encrypt account.\n   *\n   * @link https://letsencrypt.org/docs/expiration-emails/\n   *\n   * Also registered as a subscriber of the sns topic, notified on certbot task failure.\n   * Subscription confirmation email would be sent on stack creation.\n   *\n   * @link https://docs.aws.amazon.com/sns/latest/dg/sns-email-notifications.html\n   */\n  readonly email: string;\n\n  /**\n   * Domain names for A records to elastic ip of ECS host instance.\n   *\n   * @default - [ props.hostedZone.zoneName ]\n   */\n  readonly recordDomainNames?: string[];\n\n  /**\n   * Vpc of the ECS host instance and cluster.\n   *\n   * @default - Creates vpc with only public subnets and no NAT gateways.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group of the ECS host instance\n   *\n   * @default - Creates security group with allowAllOutbound and ingress rule (ipv4, ipv6) => (tcp 80, 443).\n   */\n  readonly securityGroup?: ec2.SecurityGroup;\n\n  /**\n   * Instance type of the ECS host instance.\n   *\n   * @default - t2.micro\n   */\n  readonly hostInstanceType?: string;\n\n  /**\n   * The maximum hourly price (in USD) to be paid for any Spot Instance launched to fulfill the request.\n   * Host instance asg would use spot instances if hostInstanceSpotPrice is set.\n   *\n   * @link https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ecs.AddCapacityOptions.html#spotprice\n   * @default - undefined\n   */\n  readonly hostInstanceSpotPrice?: string;\n\n  /**\n   * Log group of the certbot task and the aws-cli task.\n   *\n   * @default - Creates default cdk log group\n   */\n  readonly logGroup?: ILogGroup;\n\n  /**\n   * Docker image tag of certbot/dns-route53 to create certificates.\n   *\n   * @link https://hub.docker.com/r/certbot/dns-route53/tags\n   * @default - v1.29.0\n   */\n  readonly certbotDockerTag?: string;\n\n  /**\n   * Certbot task schedule interval in days to renew the certificate.\n   *\n   * @default - 60\n   */\n  readonly certbotScheduleInterval?: number;\n\n  /**\n   * Docker image tag of amazon/aws-cli.\n   * This image is used to associate elastic ip on host instance startup, and run certbot cfn on ecs container startup.\n   *\n   * @default - latest\n   */\n  readonly awsCliDockerTag?: string;\n\n  /**\n   * Enable container insights or not\n   *\n   * @default - undefined (container insights disabled)\n   */\n  readonly containerInsights?: boolean;\n\n  /**\n   * Removal policy for the file system and log group (if using default).\n   *\n   * @default - RemovalPolicy.DESTROY\n   */\n  readonly removalPolicy?: lib.RemovalPolicy;\n\n  /**\n   * Task definition for the server ecs task.\n   *\n   * @default - Nginx server task definition defined in sampleServerTask()\n   */\n  readonly serverTaskDefinition?: ecs.Ec2TaskDefinition;\n};\n\nexport class LowCostECS extends lib.Stack {\n  constructor(scope: Construct, id: string, props: LowCostECSProps) {\n    super(scope, id, props);\n\n    const vpc =\n      props.vpc ??\n      new ec2.Vpc(this, 'Vpc', {\n        natGateways: 0,\n        subnetConfiguration: [\n          {\n            name: 'PublicSubnet',\n            subnetType: ec2.SubnetType.PUBLIC,\n          },\n        ],\n      });\n\n    const cluster = new ecs.Cluster(this, 'Cluster', {\n      vpc,\n      containerInsights: props.containerInsights,\n    });\n\n    const hostAutoScalingGroup = cluster.addCapacity('HostInstanceCapacity', {\n      machineImage: ecs.EcsOptimizedImage.amazonLinux2(\n        ecs.AmiHardwareType.STANDARD,\n        {\n          cachedInContext: true,\n        },\n      ),\n      instanceType: new ec2.InstanceType(props.hostInstanceType ?? 't2.micro'),\n      spotPrice: props.hostInstanceSpotPrice,\n      vpcSubnets: { subnetType: ec2.SubnetType.PUBLIC },\n      associatePublicIpAddress: true,\n      minCapacity: 1,\n      maxCapacity: 1,\n    });\n\n    if (props.securityGroup) {\n      hostAutoScalingGroup.addSecurityGroup(props.securityGroup);\n    } else {\n      hostAutoScalingGroup.connections.allowFromAnyIpv4(ec2.Port.tcp(80));\n      hostAutoScalingGroup.connections.allowFromAnyIpv4(ec2.Port.tcp(443));\n      hostAutoScalingGroup.connections.allowFrom(\n        ec2.Peer.anyIpv6(),\n        ec2.Port.tcp(80),\n      );\n      hostAutoScalingGroup.connections.allowFrom(\n        ec2.Peer.anyIpv6(),\n        ec2.Port.tcp(443),\n      );\n    }\n\n    /**\n     * Add managed policy to allow ssh through ssm manager\n     */\n    hostAutoScalingGroup.role.addManagedPolicy(\n      ManagedPolicy.fromAwsManagedPolicyName('AmazonSSMManagedInstanceCore'),\n    );\n    /**\n     * Add policy to associate elastic ip on startup\n     */\n    hostAutoScalingGroup.role.addToPrincipalPolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: ['ec2:DescribeAddresses', 'ec2:AssociateAddress'],\n        resources: ['*'],\n      }),\n    );\n\n    const hostInstanceIp = new ec2.CfnEIP(this, 'HostInstanceIp');\n    const tagUniqueId = lib.Names.uniqueId(hostInstanceIp);\n    hostInstanceIp.tags.setTag('Name', tagUniqueId);\n\n    const awsCliTag = props.awsCliDockerTag ?? 'latest';\n    hostAutoScalingGroup.addUserData(\n      'INSTANCE_ID=$(curl --silent http://169.254.169.254/latest/meta-data/instance-id)',\n      `ALLOCATION_ID=$(docker run --net=host amazon/aws-cli:${awsCliTag} ec2 describe-addresses --region ${hostAutoScalingGroup.env.region} --filter Name=tag:Name,Values=${tagUniqueId} --query 'Addresses[].AllocationId' --output text | head)`,\n      `docker run --net=host amazon/aws-cli:${awsCliTag} ec2 associate-address --region ${hostAutoScalingGroup.env.region} --instance-id \"$INSTANCE_ID\" --allocation-id \"$ALLOCATION_ID\" --allow-reassociation`,\n    );\n\n    const certFileSystem = new FileSystem(this, 'FileSystem', {\n      vpc,\n      encrypted: true,\n      securityGroup: new ec2.SecurityGroup(this, 'FileSystemSecurityGroup', {\n        vpc,\n        allowAllOutbound: false,\n      }),\n      removalPolicy: props.removalPolicy ?? lib.RemovalPolicy.DESTROY,\n    });\n    certFileSystem.connections.allowDefaultPortTo(hostAutoScalingGroup);\n    certFileSystem.connections.allowDefaultPortFrom(hostAutoScalingGroup);\n\n    /**\n     * ARecord to Elastic ip\n     */\n    const hostedZone = route53.HostedZone.fromLookup(this, 'HostedZone', {\n      domainName: props.hostedZoneDomain,\n    });\n    const records = props.recordDomainNames ?? [hostedZone.zoneName];\n    records.forEach(\n      (record) =>\n        new route53.ARecord(this, `ARecord${record}`, {\n          zone: hostedZone,\n          recordName: record,\n          target: route53.RecordTarget.fromIpAddresses(hostInstanceIp.ref),\n        }),\n    );\n\n    /**\n     * Certbot Task Definition\n     * Mounts generated certificate to EFS\n     */\n    const logGroup =\n      props.logGroup ??\n      new LogGroup(this, 'LogGroup', {\n        retention: RetentionDays.TWO_YEARS,\n        removalPolicy: props.removalPolicy ?? lib.RemovalPolicy.DESTROY,\n      });\n\n    const certbotTaskDefinition = new ecs.Ec2TaskDefinition(\n      this,\n      'CertbotTaskDefinition',\n    );\n    certbotTaskDefinition.addToTaskRolePolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: ['route53:ListHostedZones', 'route53:GetChange'],\n        resources: ['*'],\n      }),\n    );\n    certbotTaskDefinition.addToTaskRolePolicy(\n      new PolicyStatement({\n        effect: Effect.ALLOW,\n        actions: ['route53:ChangeResourceRecordSets'],\n        resources: [hostedZone.hostedZoneArn],\n      }),\n    );\n\n    const certbotTag = props.certbotDockerTag ?? 'v1.29.0';\n    const certbotContainer = certbotTaskDefinition.addContainer(\n      'CertbotContainer',\n      {\n        image: ecs.ContainerImage.fromRegistry(\n          `certbot/dns-route53:${certbotTag}`,\n        ),\n        containerName: 'certbot',\n        memoryReservationMiB: 64,\n        command: [\n          'certonly',\n          '--verbose',\n          '--preferred-challenges=dns-01',\n          '--dns-route53',\n          '--dns-route53-propagation-seconds=300',\n          '--non-interactive',\n          '--agree-tos',\n          '--expand',\n          '-m',\n          props.email,\n          '--cert-name',\n          records[0],\n          ...records.flatMap((domain) => ['-d', domain]),\n        ],\n        logging: ecs.LogDriver.awsLogs({\n          logGroup,\n          streamPrefix: certbotTag,\n        }),\n      },\n    );\n\n    certFileSystem.grant(\n      certbotTaskDefinition.taskRole,\n      'elasticfilesystem:ClientWrite',\n    );\n    certbotTaskDefinition.addVolume({\n      name: 'certVolume',\n      efsVolumeConfiguration: {\n        fileSystemId: certFileSystem.fileSystemId,\n      },\n    });\n    certbotContainer.addMountPoints({\n      sourceVolume: 'certVolume',\n      containerPath: '/etc/letsencrypt',\n      readOnly: false,\n    });\n\n    /**\n     * Schedule Certbot certificate create/renew on Step Functions\n     * Sends email notification on certbot failure\n     */\n    const topic = new Topic(this, 'Topic');\n    new Subscription(this, 'EmailSubscription', {\n      topic: topic,\n      protocol: SubscriptionProtocol.EMAIL,\n      endpoint: props.email,\n    });\n\n    const certbotRunTask = new sfn_tasks.EcsRunTask(this, 'CreateCertificate', {\n      cluster: cluster,\n      taskDefinition: certbotTaskDefinition,\n      launchTarget: new sfn_tasks.EcsEc2LaunchTarget(),\n      integrationPattern: sfn.IntegrationPattern.RUN_JOB,\n    });\n    certbotRunTask.addCatch(\n      new sfn_tasks.SnsPublish(this, 'SendEmailOnFailure', {\n        topic: topic,\n        message: sfn.TaskInput.fromJsonPathAt('$'),\n      }).next(new sfn.Fail(this, 'Fail')),\n    );\n    certbotRunTask.addRetry({\n      interval: lib.Duration.seconds(20),\n    });\n    const certbotStateMachine = new sfn.StateMachine(this, 'StateMachine', {\n      definition: certbotRunTask,\n    });\n\n    new Rule(this, 'CertbotScheduleRule', {\n      schedule: Schedule.rate(\n        lib.Duration.days(props.certbotScheduleInterval ?? 60),\n      ),\n      targets: [new SfnStateMachine(certbotStateMachine)],\n    });\n\n    /**\n     * Server ECS task\n     */\n    const serverTaskDefinition =\n      props.serverTaskDefinition ?? this.sampleSeverTask(records, logGroup);\n    certFileSystem.grant(\n      serverTaskDefinition.taskRole,\n      'elasticfilesystem:ClientMount',\n    );\n    serverTaskDefinition.addVolume({\n      name: 'certVolume',\n      efsVolumeConfiguration: {\n        fileSystemId: certFileSystem.fileSystemId,\n      },\n    });\n    serverTaskDefinition.defaultContainer?.addMountPoints({\n      sourceVolume: 'certVolume',\n      containerPath: '/etc/letsencrypt',\n      readOnly: true,\n    });\n\n    /**\n     * AWS cli container to execute certbot sfn before the default container startup.\n     */\n    serverTaskDefinition.defaultContainer?.addContainerDependencies({\n      container: serverTaskDefinition.addContainer('AWSCliContainer', {\n        image: ecs.ContainerImage.fromRegistry(`amazon/aws-cli:${awsCliTag}`),\n        containerName: 'aws-cli',\n        memoryReservationMiB: 64,\n        entryPoint: ['/bin/bash', '-c'],\n        command: [\n          `set -eux\n          aws configure set region ${certbotStateMachine.env.region} && \\\\\n          aws configure set output text && \\\\\n          EXECUTION_ARN=$(aws stepfunctions start-execution --state-machine-arn ${certbotStateMachine.stateMachineArn} --query executionArn) && \\\\\n          until [ $(aws stepfunctions describe-execution --execution-arn \"$EXECUTION_ARN\" --query status) != RUNNING ];\n          do\n            echo \"Waiting for $EXECUTION_ARN\"\n            sleep 10\n          done`,\n        ],\n        essential: false,\n        logging: ecs.LogDriver.awsLogs({\n          logGroup: logGroup,\n          streamPrefix: awsCliTag,\n        }),\n      }),\n      condition: ecs.ContainerDependencyCondition.COMPLETE,\n    });\n    certbotStateMachine.grantExecution(\n      serverTaskDefinition.taskRole,\n      'states:DescribeExecution',\n    );\n    certbotStateMachine.grantStartExecution(serverTaskDefinition.taskRole);\n\n    new ecs.Ec2Service(this, 'Service', {\n      cluster: cluster,\n      taskDefinition: serverTaskDefinition,\n      desiredCount: 1,\n      minHealthyPercent: 0,\n      maxHealthyPercent: 100,\n      circuitBreaker: {\n        rollback: true,\n      },\n      enableExecuteCommand: true,\n    });\n  }\n\n  private sampleSeverTask(\n    records: string[],\n    logGroup: ILogGroup,\n  ): ecs.Ec2TaskDefinition {\n    const nginxTaskDefinition = new ecs.Ec2TaskDefinition(\n      this,\n      'NginxTaskDefinition',\n    );\n    const nginxContainer = nginxTaskDefinition.addContainer('NginxContainer', {\n      image: ecs.ContainerImage.fromAsset(\n        path.join(__dirname, '../containers/nginx-proxy'),\n      ),\n      containerName: 'nginx',\n      memoryReservationMiB: 64,\n      essential: true,\n      environment: {\n        SERVER_NAME: records.join(' '),\n        CERT_NAME: records[0],\n      },\n      logging: ecs.LogDrivers.awsLogs({\n        logGroup: logGroup,\n        streamPrefix: 'nginx-proxy',\n      }),\n    });\n\n    nginxContainer.addPortMappings(\n      {\n        hostPort: 80,\n        containerPort: 80,\n        protocol: ecs.Protocol.TCP,\n      },\n      {\n        hostPort: 443,\n        containerPort: 443,\n        protocol: ecs.Protocol.TCP,\n      },\n    );\n\n    return nginxTaskDefinition;\n  }\n}\n"]}

package/package.json

@@ -0,0 +1,139 @@
+{
+  "name": "low-cost-ecs",
+  "description": "Easy and low-cost ECS on EC2 server without a load balancer",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/rajyan/low-cost-ecs.git"
+  },
+  "scripts": {
+    "build": "npx projen build",
+    "bump": "npx projen bump",
+    "clobber": "npx projen clobber",
+    "compat": "npx projen compat",
+    "compile": "npx projen compile",
+    "default": "npx projen default",
+    "docgen": "npx projen docgen",
+    "eject": "npx projen eject",
+    "eslint": "npx projen eslint",
+    "package": "npx projen package",
+    "package-all": "npx projen package-all",
+    "package:js": "npx projen package:js",
+    "package:python": "npx projen package:python",
+    "post-compile": "npx projen post-compile",
+    "post-upgrade": "npx projen post-upgrade",
+    "pre-compile": "npx projen pre-compile",
+    "release": "npx projen release",
+    "test": "npx projen test",
+    "test:update": "npx projen test:update",
+    "test:watch": "npx projen test:watch",
+    "unbump": "npx projen unbump",
+    "upgrade": "npx projen upgrade",
+    "watch": "npx projen watch",
+    "projen": "npx projen"
+  },
+  "author": {
+    "name": "Yohta Kimura",
+    "email": "kitakita7617@gmail.com",
+    "organization": false
+  },
+  "devDependencies": {
+    "@types/jest": "^27",
+    "@types/node": "^14",
+    "@typescript-eslint/eslint-plugin": "^5",
+    "@typescript-eslint/parser": "^5",
+    "aws-cdk": "^2.39.0",
+    "aws-cdk-lib": "2.37.0",
+    "constructs": "10.0.5",
+    "eslint": "8.22.0",
+    "eslint-import-resolver-node": "^0.3.6",
+    "eslint-import-resolver-typescript": "^3.5.0",
+    "eslint-plugin-import": "^2.26.0",
+    "jest": "^27",
+    "jest-junit": "^13",
+    "jsii": "^1.65.0",
+    "jsii-diff": "^1.65.0",
+    "jsii-docgen": "^7.0.73",
+    "jsii-pacmak": "^1.65.0",
+    "json-schema": "^0.4.0",
+    "npm-check-updates": "^15",
+    "projen": "^0.61.30",
+    "standard-version": "^9",
+    "ts-jest": "^27",
+    "ts-node": "^10.9.1",
+    "typescript": "~4.7.4"
+  },
+  "peerDependencies": {
+    "aws-cdk-lib": "^2.37.0",
+    "constructs": "^10.0.5"
+  },
+  "keywords": [
+    "cdk",
+    "certbot",
+    "ecs",
+    "loadbalancer",
+    "route53",
+    "stepfunctions"
+  ],
+  "main": "lib/index.js",
+  "license": "MIT",
+  "version": "0.0.6",
+  "jest": {
+    "testMatch": [
+      "<rootDir>/src/**/__tests__/**/*.ts?(x)",
+      "<rootDir>/(test|src)/**/*(*.)@(spec|test).ts?(x)"
+    ],
+    "clearMocks": true,
+    "collectCoverage": true,
+    "coverageReporters": [
+      "json",
+      "lcov",
+      "clover",
+      "cobertura",
+      "text"
+    ],
+    "coverageDirectory": "coverage",
+    "coveragePathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "testPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "watchPathIgnorePatterns": [
+      "/node_modules/"
+    ],
+    "reporters": [
+      "default",
+      [
+        "jest-junit",
+        {
+          "outputDirectory": "test-reports"
+        }
+      ]
+    ],
+    "preset": "ts-jest",
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.dev.json"
+      }
+    }
+  },
+  "types": "lib/index.d.ts",
+  "stability": "experimental",
+  "jsii": {
+    "outdir": "dist",
+    "targets": {
+      "python": {
+        "distName": "low-cost-ecs",
+        "module": "low_cost_ecs"
+      }
+    },
+    "tsc": {
+      "outDir": "lib",
+      "rootDir": "src"
+    }
+  },
+  "resolutions": {
+    "@types/prettier": "2.6.0"
+  },
+  "//": "~~ Generated by projen. To modify, edit .projenrc.js and run \"npx projen\"."
+}

package/todo.md

@@ -0,0 +1,4 @@
+# todo
+
+* update Overview
+* add properties to expose