1. Docs
2. Tutorials
3. AWS
4. Dockerized ASP.NET App on AWS ECS Fargate

Dockerized ASP.NET App on AWS ECS Fargate

View Code

This example defines a basic ASP.NET application and all of the infrastructure required to run it in AWS in C#.

This infrastructure includes everything needed to:

• Build and publish the ASP.NET application as a Docker container image
• Store images in a private Amazon Elastic Container Registry (ECR) repository
• Scale out 3 load-balanced replicas using Amazon Elastic Container Service (ECS) “Fargate”
• Accept Internet traffic on port 80 using Amazon Elastic Application Load Balancer (ELB)

This example is inspired by Docker’s and ASP.NET’s Getting Started tutorials. The result is a simple development experience and yet an end result that uses modern, production-ready AWS infrastructure. ./Infra/Program.cs defines the project’s infrastructure.

Prerequisites

• Install Pulumi
• Configure Pulumi to Use AWS (if your AWS CLI is configured, no further changes are required)
• Install .NET Core 3
• Install Docker

Running the Example

Clone this repo and cd into it.

Next, to deploy the application and its infrastructure, follow these steps:

1. Create a new stack, which is an isolated deployment target for this example:

   $ pulumi stack init dev

2. Set your desired AWS region:

   $ pulumi config set aws:region us-east-1 # any valid AWS region will work

3. Deploy everything with a single pulumi up command. This will show you a preview of changes first, which includes all of the required AWS resources (clusters, services, and the like). Don’t worry if it’s more than you expected – this is one of the benefits of Pulumi, it configures everything so that so you don’t need to!

   $ pulumi up

   After being prompted and selecting “yes”, your deployment will begin. It’ll complete in a few minutes:

   ``` Updating (dev): Type Name Status

   • pulumi:pulumi:Stack aws-cs-fargate-dev created
   • ├─ aws:ec2:SecurityGroup web-sg created
   • ├─ aws:ecs:Cluster app-cluster created
   • ├─ aws:iam:Role task-exec-role created
   • ├─ aws:elasticloadbalancingv2:TargetGroup web-tg created
   • ├─ aws:ecr:Repository app-repo created
   • ├─ docker:image:Image app-img created
   • ├─ aws:iam:RolePolicyAttachment task-exec-policy created
   • ├─ aws:ecs:TaskDefinition app-task created
   • ├─ aws:elasticloadbalancingv2:LoadBalancer web-lb created
   • └─ aws:ecs:Service app-svc created

   Outputs: url: “http://web-lb-23139b7-1806442625.us-east-1.elb.amazonaws.com"

   Resources: + 11 created

   Duration: 3m41s

   Permalink: https://app.pulumi.com/acmecorp/aws-cs-fargate/dev/updates/1 ```

Notice that the automatically assigned load-balancer URL is printed as a stack output.

1. At this point, your app is running – let’s curl it. The CLI makes it easy to grab the URL:

   $ curl $(pulumi stack output url)
   Hello World!

2. Try making some changes and rerunning pulumi up.

If you just change the application code, and deploy the results, for example, only the Docker image will be updated and rolled out. Try changing "Hello World!" inside of App/Startup.cs to "Hello Pulumi!":

   $ pulumi up
   Updating (dev):
         Type                       Name                Plan        Info
         pulumi:pulumi:Stack        aws-cs-fargate-dev
     +-  ├─ aws:ecs:TaskDefinition  app-task            replaced    [diff: ~containerDefinitions]
     ~   ├─ aws:ecs:Service         app-svc             updated     [diff: ~taskDefinition]
         └─ docker:image:Image      app-img

    Resources:
        ~ 1 updated
        +-1 replaced
        2 changes. 9 unchanged

Notice that pulumi up redeploys just the parts of the application/infrastructure that you’ve edited.

Now the endpoint will run the newly updated application code:

```bash
$ curl $(pulumi stack output Url)
Hello Pulumi!
```

1. Once you are done, you can destroy all of the resources, and the stack:

   $ pulumi destroy
   $ pulumi stack rm