A tale of two tools - Pulumi and AWS CDK

FROM httpd

import os
from aws_cdk import ( App, CfnOutput, Environment, Stack )
from aws_cdk.aws_ec2 import ( Vpc )
from aws_cdk.aws_ecr_assets import DockerImageAsset
from aws_cdk.aws_ecs import (
    Cluster,
    ContainerImage,
    DeploymentCircuitBreaker,
    FargateTaskDefinition,
    LogDriver,
    PortMapping,
    Protocol
)
from aws_cdk.aws_ecs_patterns import ApplicationLoadBalancedFargateService
from aws_cdk.aws_logs import RetentionDays

# Set up a CDK app and a stack for our resources
app = App()
stack = Stack(app,
              'my-container-infrastructure',
              env=Environment(account=os.getenv('CDK_DEFAULT_ACCOUNT'),
                              region=os.getenv('CDK_DEFAULT_REGION')))

# A VPC to use
vpc = Vpc(stack, 'vpc', vpc_name='my-vpc', nat_gateways=1, max_azs=2)

# AN ECS cluster
cluster = Cluster(stack, 'my-ecs-cluster', vpc=vpc)

WEBSERVER_PORT=80
taskdef = FargateTaskDefinition(stack,
                                'my-task-def',
                                cpu=512,
                                memory_limit_mib=1024)

image_asset = DockerImageAsset(stack, 'image-asset', directory='./my-image')
image = ContainerImage.from_docker_image_asset(image_asset)
containerdef = taskdef.add_container('my-container', image=image)
containerdef.add_port_mappings(PortMapping(container_port=WEBSERVER_PORT,
                                           protocol=Protocol.TCP))

lbservice = ApplicationLoadBalancedFargateService(
    stack,
    'loadbalanced-service',
    cluster=cluster,
    task_definition=taskdef,
    desired_count=2,
    service_name='my-service',
    circuit_breaker=DeploymentCircuitBreaker(rollback=True),
    public_load_balancer=True,
    listener_port=WEBSERVER_PORT)

CfnOutput(stack,
          'url',
          value=f'http://{lbservice.load_balancer.load_balancer_dns_name}')

app.synth()

from pulumi import Config, Output, export
import pulumi_aws as aws
import pulumi_awsx as awsx

port = 80
cpu = 512
memory = 1024

vpc = awsx.ec2.Vpc(
    'my-vpc',
    number_of_availability_zones=2,
    nat_gateways=awsx.ec2.NatGatewayConfigurationArgs(
        strategy=awsx.ec2.NatGatewayStrategy.SINGLE))

# An ECS cluster
cluster = aws.ecs.Cluster('my-ecs-cluster')

# An ECR repository for the app image
repo = awsx.ecr.Repository('my-repo')

# Build and publish the image to ECR
image = awsx.ecr.Image(
    'image',
    repository_url=repo.url,
    path='./my-image')

lbsg = aws.ec2.SecurityGroup(
    'my-lb-sg',
    vpc_id=vpc.vpc_id,
    ingress=[
        aws.ec2.SecurityGroupIngressArgs(
            from_port=port,
            to_port=port,
            protocol='tcp',
            cidr_blocks=['0.0.0.0/0'])
    ],
    egress=[
        aws.ec2.SecurityGroupEgressArgs(
            from_port=0,
            to_port=0,
            protocol='-1',
            cidr_blocks=['0.0.0.0/0'])
    ]
)

# An ALB for load balancing traffic from internet
loadbalancer = awsx.lb.ApplicationLoadBalancer(
    'my-lb',
    subnet_ids=vpc.public_subnet_ids,
    security_groups=[lbsg.id]
)

# Container definition for the ECS task
containerdef = awsx.ecs.TaskDefinitionContainerDefinitionArgs(
    image=image.image_uri,
    cpu=cpu,
    memory=memory,
    essential=True,
    port_mappings=[awsx.ecs.TaskDefinitionPortMappingArgs(
        container_port=port,
        target_group=loadbalancer.default_target_group
    )]
)

containersg = aws.ec2.SecurityGroup(
    'my-container-sg',
    vpc_id=vpc.vpc_id,
    ingress=[
        aws.ec2.SecurityGroupIngressArgs(
            from_port=port,
            to_port=port,
            protocol='tcp',
            security_groups=[lbsg.id])
    ],
    egress=[
        aws.ec2.SecurityGroupEgressArgs(
            from_port=0,
            to_port=0,
            protocol='-1',
            cidr_blocks=['0.0.0.0/0'])
    ])

# Deploy an ECS Service on Fargate to host the application container
service = awsx.ecs.FargateService(
    'my-service',
    desired_count=2,
    cluster=cluster.arn,
    task_definition_args=awsx.ecs.FargateServiceTaskDefinitionArgs(
        container=containerdef),
    network_configuration=aws.ecs.ServiceNetworkConfigurationArgs(
        subnets=vpc.private_subnet_ids,
        security_groups=[containersg.id]
    ),
    deployment_circuit_breaker=aws.ecs.ServiceDeploymentCircuitBreakerArgs(
        enable=True,
        rollback=True))


# The endpoint URL
export("url", Output.concat("http://", loadbalancer.load_balancer.dns_name))

import { App, CfnOutput, Stack } from 'aws-cdk-lib';
import { Vpc } from 'aws-cdk-lib/aws-ec2';
import { DockerImageAsset } from 'aws-cdk-lib/aws-ecr-assets';
import { Cluster, ContainerImage, FargateTaskDefinition, Protocol } from 'aws-cdk-lib/aws-ecs';
import { ApplicationLoadBalancedFargateService } from 'aws-cdk-lib/aws-ecs-patterns';

const app = new App();

const stack = new Stack(app, 'my-container-infrastructure', {
    env: {
        account: process.env.CDK_DEFAULT_ACCOUNT,
        region: process.env.CDK_DEFAULT_REGION,
    }
});

const vpc = new Vpc(stack, 'vpc', {
    vpcName: 'my-vpc',
    natGateways: 1,
    maxAzs: 2,
});

const cluster = new Cluster(stack, 'my-ecs-cluster', { vpc });

const webserverPort = 80;
const taskdef = new FargateTaskDefinition(stack, 'my-task-def', {
    cpu: 512,
    memoryLimitMiB: 1024,
});

const imageAsset = new DockerImageAsset(stack, 'image-asset', { directory: './my-image'});
const image = ContainerImage.fromDockerImageAsset(imageAsset);
const containerdef = taskdef.addContainer('my-container', { image });
containerdef.addPortMappings({
    containerPort: webserverPort,
    protocol: Protocol.TCP,
});

const lbservice = new ApplicationLoadBalancedFargateService(stack, 'loadbalanced-service', {
    cluster,
    taskDefinition: taskdef,
    desiredCount: 2,
    serviceName: 'my-service',
    circuitBreaker: { rollback: true },
    publicLoadBalancer: true,
    listenerPort: webserverPort,
});

new CfnOutput(stack, 'url', { value: `http://${lbservice.loadBalancer.loadBalancerDnsName}`});

import * as pulumi from "@pulumi/pulumi";
import * as aws from "@pulumi/aws";
import * as awsx from "@pulumi/awsx";

const config = new pulumi.Config();
const port = 80;
const cpu = 512;
const memory = 1024;

const vpc = new awsx.ec2.Vpc('my-vpc', {
    numberOfAvailabilityZones: 2,
    natGateways: { strategy: awsx.ec2.NatGatewayStrategy.Single },
});

// An ECS cluster to deploy into
const cluster = new aws.ecs.Cluster('my-ecs-cluster');

// An ECR repository for the app image
const repo = new awsx.ecr.Repository('my-repo');

// Build and publish the image to ECR
const image = new awsx.ecr.Image('image', {
    repositoryUrl: repo.url,
    path: './my-image',
});

const lbsg = new aws.ec2.SecurityGroup('my-lb-sg', {
    vpcId: vpc.vpcId,
    ingress: [{
        fromPort: port,
        toPort: port,
        protocol: 'tcp',
        cidrBlocks: ['0.0.0.0/0'],
    }],
    egress: [{
        fromPort: 0,
        toPort: 0,
        protocol: '-1',
        cidrBlocks: ['0.0.0.0/0'],
    }],
});

// An ALB to serve the container endpoint to the internet
const loadbalancer = new awsx.lb.ApplicationLoadBalancer('my-lb', {
    subnetIds: vpc.publicSubnetIds,
    securityGroups: [lbsg.id],
});

const containersg = new aws.ec2.SecurityGroup('my-container-sg', {
    vpcId: vpc.vpcId,
    ingress: [{
        fromPort: port,
        toPort: port,
        protocol: 'tcp',
        securityGroups: [lbsg.id],
    }],
    egress: [{
        fromPort: 0,
        toPort: 0,
        protocol: '-1',
        cidrBlocks: ['0.0.0.0/0'],
    }],
});

// Deploy an ECS Service on Fargate to host the application container
const service = new awsx.ecs.FargateService('my-service', {
    desiredCount: 2,
    cluster: cluster.arn,
    taskDefinitionArgs: {
        container: {
            image: image.imageUri,
            cpu: cpu,
            memory: memory,
            essential: true,
            portMappings: [{
                containerPort: port,
                targetGroup: loadbalancer.defaultTargetGroup,
            }],
        }
    },
    networkConfiguration: {
        subnets: vpc.privateSubnetIds,
        securityGroups: [containersg.id],
    },
    deploymentCircuitBreaker: {
        enable: true,
        rollback: true,
    },
});

// The URL at which the container's HTTP endpoint will be available
export const url = pulumi.interpolate`http://${loadbalancer.loadBalancer.dnsName}`;

import * as pulumi from "@pulumi/pulumi";
import * as pulumicdk from '@pulumi/cdk';
import { Vpc } from 'aws-cdk-lib/aws-ec2';
import { DockerImageAsset} from 'aws-cdk-lib/aws-ecr-assets';
import { Cluster, ContainerImage, FargateTaskDefinition, Protocol } from 'aws-cdk-lib/aws-ecs';
import { ApplicationLoadBalancedFargateService } from 'aws-cdk-lib/aws-ecs-patterns'

class MyContainerInfrastructureStack extends pulumicdk.Stack {
    url: pulumi.Output<string>;

    constructor(id: string, options?: pulumicdk.StackOptions) {
        super(id, { ...options });

        const vpc = new Vpc(this, 'vpc', {
            vpcName: 'my-vpc',
            natGateways: 1,
            maxAzs: 2,
        });

        const cluster = new Cluster(this, 'my-ecs-cluster', { vpc });

        const webserverPort = 80;
        const taskdef = new FargateTaskDefinition(this, 'my-task-def', {
            cpu: 512,
            memoryLimitMiB: 1024,
        });

        const imageAsset = new DockerImageAsset(this, 'image-asset', { directory: './my-image'});
        const image = ContainerImage.fromDockerImageAsset(imageAsset);
        const containerdef = taskdef.addContainer('my-container', { image });
        containerdef.addPortMappings({
            containerPort: webserverPort,
            protocol: Protocol.TCP,
        });

        const lbservice = new ApplicationLoadBalancedFargateService(this, 'lb-service', {
            cluster,
            taskDefinition: taskdef,
            desiredCount: 2,
            serviceName: 'my-service',
            circuitBreaker: { rollback: true },
            publicLoadBalancer: true,
            listenerPort: webserverPort,
        });

        this.url = this.asOutput(`http://${lbservice.loadBalancer.loadBalancerDnsName}`);

        this.synth();
    }
}

const stack = new MyContainerInfrastructureStack('my-container-infrastructure');
export const url = stack.url;