cdk-fargate-application-lb

cdk-stack.ts

import ec2 = require('@aws-cdk/aws-ec2');
import ecs = require('@aws-cdk/aws-ecs');
import ecs_patterns = require('@aws-cdk/aws-ecs-patterns');
import cdk = require('@aws-cdk/core');
import route53 = require('@aws-cdk/aws-route53');
import acm = require('@aws-cdk/aws-certificatemanager');
import targets = require('@aws-cdk/aws-route53-targets/lib');
import path = require('path');
import { config } from 'dotenv';
import { ApplicationProtocol, SslPolicy } from '@aws-cdk/aws-elasticloadbalancingv2';

config();

if (!process.env.SERVICE_NAME) {
  throw new Error('process.env.SERVICE_NAME not specified. Update .env');
}
if (!process.env.DOMAIN_NAME) throw new Error('Missing DOMAIN_NAME in .env');
if (!process.env.SUBDOMAIN) throw new Error('Missing SUBDOMAIN in .env');

export class CdkStack extends cdk.Stack {
  constructor(scope: cdk.Construct, id: string, props?: cdk.StackProps) {
    super(scope, id, props);

    const app = new cdk.App();
    const stack = new cdk.Stack(app, process.env.SERVICE_NAME, {
      env: {
        account: process.env.ACCOUNT,
        region: process.env.REGION
      }
    });

    // Routes
    let zone;
    try {
      zone = route53.HostedZone.fromLookup(stack, process.env.DOMAIN_NAME + 'HostedZone', {
        domainName: '' + process.env.DOMAIN_NAME
      });
    } catch (err) {
      zone = new route53.PublicHostedZone(stack, process.env.DOMAIN_NAME + 'HostedZone', {
        zoneName: '' + process.env.DOMAIN_NAME
      });
    }

    const apiDomain = process.env.SUBDOMAIN + '.' + process.env.DOMAIN_NAME;
    new cdk.CfnOutput(stack, apiDomain + 'Site', {
      value: 'https://' + apiDomain
    });

    const backEndCertificateArn = new acm.DnsValidatedCertificate(stack, apiDomain + 'SiteCertificate', {
      domainName: apiDomain,
      hostedZone: zone
    }).certificateArn;

    new cdk.CfnOutput(stack, apiDomain + '-Certificate', {
      value: backEndCertificateArn
    });

    // Fargate App
    const vpc = new ec2.Vpc(stack, process.env.DOMAIN_NAME + 'Vpc', {
      maxAzs: 2
    });
    const cluster = new ecs.Cluster(stack, 'Cluster', { vpc });
    const lb = new ecs_patterns.ApplicationLoadBalancedFargateService(stack, '' + process.env.SERVICE_NAME, {
      assignPublicIp: true,
      cluster,
      taskImageOptions: {
        image: ecs.ContainerImage.fromAsset(path.resolve(__dirname, '../../'))
      }
    });

    lb.loadBalancer.addListener(process.env.SERVICE_NAME + 'HttpsListener', {
      certificateArns: [backEndCertificateArn],
      protocol: ApplicationProtocol.HTTPS,
      port: 443,
      sslPolicy: SslPolicy.RECOMMENDED,
      open: true,
      defaultTargetGroups: [lb.targetGroup]
    });

    // lb.loadBalancer.addListener(process.env.SERVICE_NAME + 'HttpListener', {
    //   protocol: ApplicationProtocol.HTTP,
    //   port: 80,
    //   // sslPolicy: SslPolicy.RECOMMENDED,
    //   open: true,
    //   defaultTargetGroups: [lb.targetGroup]
    // });

    // A Records
    new route53.ARecord(stack, apiDomain + 'SiteAliasRecord', {
      recordName: apiDomain,
      target: route53.AddressRecordTarget.fromAlias(new targets.LoadBalancerTarget(lb.loadBalancer)),
      zone
    });
  }
}