---
title: "Dockerized ASP.NET app on AWS ECS Fargate"
description: "An ASP.NET application running in AWS ECS Fargate, using C# infrastructure as code"
url: "https://www.pulumi.com/dev/examples/aws-cs-fargate/"
image: "https://www.pulumi.com/assets/og/dev/examples/aws-cs-fargate.png"
---

# Dockerized ASP.NET app on AWS ECS Fargate

An ASP.NET application running in AWS ECS Fargate, using C# infrastructure as code

- Source on GitHub: https://github.com/pulumi/examples/tree/master/aws-cs-fargate
- Deploy with Pulumi: https://app.pulumi.com/new?template=https%3A%2F%2Fgithub.com%2Fpulumi%2Fexamples%2Ftree%2Fmaster%2Faws-cs-fargate

## Get started with this example

This example lives in the [pulumi/examples](https://github.com/pulumi/examples/tree/master/aws-cs-fargate) repo. Pull down just this directory to follow along:

```bash
git clone --filter=blob:none --sparse https://github.com/pulumi/examples pulumi-examples
git -C pulumi-examples sparse-checkout set aws-cs-fargate
cd pulumi-examples/aws-cs-fargate
```

This example defines a [basic ASP.NET application](https://github.com/pulumi/examples/tree/master/aws-cs-fargate/App) and
[all of the infrastructure required to run it in AWS](https://github.com/pulumi/examples/tree/master/aws-cs-fargate/Infra) 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)](https://aws.amazon.com/ecr/) repository
* Scale out 3 load-balanced replicas using [Amazon Elastic Container Service (ECS)](https://aws.amazon.com/ecs/) "Fargate"
* Accept Internet traffic on port 80 using [Amazon Elastic Application Load Balancer (ELB)](https://aws.amazon.com/elasticloadbalancing/)

This example is inspired by [Docker's](https://docs.docker.com/get-started/) and
[ASP.NET's](https://docs.microsoft.com/en-us/aspnet/core/getting-started/?view=aspnetcore-3.1) 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`](https://github.com/pulumi/examples/tree/master/aws-cs-fargate/Infra/Program.cs) defines the project's infrastructure.

## Prerequisites

1. [Install Pulumi](https://www.pulumi.com/docs/get-started/install/)
2. [Configure AWS credentials](https://www.pulumi.com/docs/intro/cloud-providers/aws/setup/)
3. [Install .NET](https://www.pulumi.com/docs/intro/languages/dotnet/)
4. [Install Docker](https://docs.docker.com/get-docker/)

## Deploying the example

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

    ```bash
    pulumi stack init dev
    ```

1.  Set the AWS region to deploy into:

    ```bash
    pulumi config set aws:region us-east-1
    ```

1.  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!

    ```bash
    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:

    ```bash
    curl $(pulumi stack output url)
    ```

    ```
    Hello World!
    ```

1.  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!"`:

    ```bash
    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!
    ```

## Cleaning up

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

```bash
pulumi destroy
pulumi stack rm
```
