In my previous post I walked through a couple of tutorials to deploy a test Docker container to AWS ECS Fargate. As a summary, here’s the various parts that you need to have in place to deploy a Docker container using Fargate:
A Docker image, deployed to a Docker repository, e.g. either Docker Hub, or AWS ECR
A VPC with either a public or private subnet (or both)
A Security Group to define what traffic is allowed in and out to your running Container
A ELB Load Balancer, assuming you’re running more than 1 instance of a container and are not accessing a single instance directly with a public IP
An ECS Cluster
An ECS Task Definition
An ECS Fargate Service Definition to create the running instance of your task
The interesting feature of AWS ECS Fargate is that it’s ‘serverless for containers’. Serverless broadly means you don’t need to be concerned with the provisioning and maintenance of the servers or compute that are running your code. With Fargate, you don’t have to provision compute for your Docker Containers, AWS manages the compute for you.
If you’re working with Docker containers, AWS have multiple runtime options, each with their own pros and cons:
running Docker on your own EC2 instances – the roll your own approach, you provision instances and manage everything yourself
AWS ECS with EC2 launch type – you still need to provision a pool of available EC2 instances on which AWS will run your containers
AWS EKS – managed Kubernetes
AWS ECS with Fargate launch type – you don’t need to provision any compute (e.g. EC2), AWS manages the compute for you
I’m taking a look at AWS ECS Fargate to see what it takes to deploy a Docker container.
An ECS cluster needs a VPC in which your container instances will run, with at least 1 public or private subnet. Steps to create a new VPC with subnets is covered here.
Following these steps from the VPC section in ECS tutorials using the AWS Console I created:
an Elastic IP to associate with my cluster for public access
a new VPC with 1 private subnet and 1 public subnet
I created these with the VPC Wizard using this option:
Apparently your public subnet doesn’t get assigned a public IP by default, so follow these steps in the guide to change this default behavior:
When you select your public subnet, this option is under Actions here:
Select this option:
My public subnet was created in AZ us-west-2a and my private subnet is also in the same AZ. The guide recommends creating 1 additional public and private subnets in a different AZ high for availability.
To create a ECS Fargate cluster you can use the AWS CLI like this:
However, I’m not sure at this point how to configure the new cluster to specify the VPC and subnets I just created, so for my first cluster I’m going to use the ECS wizard in the AWS Console first, and then come back to the CLI later.
Using the wizard I selected the Networking Only option with Fargate:
I don’t need to select the ‘Create VPC’ option because I’ve already created one:
Turns out there aren’t any options to associate the VPC at this point, the tasks are associated to your VPC and subnets when you create them next. So using the CLI step earlier would create the cluster exactly the same.
You need to define an ECS task definition that defines the task that will run on the ECS cluster. Following the tutorial here, the example JSON file provided as an example looks like this:
Since we’re deploying a Docker container, we need to specify a Docker image to pull some somewhere. This example provides the name of a Docker container to pull from Docker Hub, in this case httpd:2.4. To. deploy your own apps, you configure your own dockerfile for your app, and publish it to a Docker repo like Docker Hub, or AWS ECR.
When –cli-input-json reads your config file, it will open is whatever is your default editor in your shell. On my Mac in zsh it appears to open the file in vim with a ‘:’ prompt at the bottom of the screen, and pressing ‘q’ quits the editor and continues registering the Task Def.
You can list registered Task Definitions with:
aws ecs list-task-definitions
By default, your ECS service will only have a private IP, and would typically be exposed publicly via an ELB. You can configure the task to get allocated it’s own public IP by adding this config:
This is where we we specify the subnets that were created earlier. I’m going to publicly expose this container, so I’m associating it with the 2 public subnets I created (added to the above config snippet).
I also need a Security Group for the config, so I’ll create that too and allow incoming traffic on port 80.
It’s not obvious from the docs where this NetworkConfiguration section gets specified, but it doesn’t go in the Task Definition json, it gets passed when you create the Service using the Task Definition.
Using this command to plug in the subnet ids and Security Group id, from the ECS Console you’ll now see you have service running! If you drill down to the task you can find the assigned public IP. Hit the IP to call the service! Since we’re running an httpd container with a sample web page, we see:
A few months back I walked through the steps to build, tag and deploy Docker containers to AWS ECS. It’s been a while and I need to revisit the steps.
Although you can use the the AWS Console, using the aws cli works well complements the common steps with the docker cli.
The steps you need to connect and login the docker cli to aws are listed from the AWS ECS dashboard, from the Repositories tab. Press the ‘Push Commands’ button and it will show you the login command which looks like this:
AWS offers their own EC2 Container Service (ECS) which simplifies deploying Docker containers to EC2 instances (and clusters of instances) and management of your containers. If you want to do-it-yourself though, you can easily install docker yourself in your own instance.