Amazon EC2 Container Service (ECS)

bogotobogo.com site search:

What is EC2 Container Service (ECS)

Amazon EC2 Container Service (Amazon ECS) is a highly scalable, fast, container management service that makes it easy to run, stop, and manage Docker containers on a cluster of Amazon EC2 instances.

Amazon ECS uses Docker images in task definitions to launch containers on EC2 instances in our clusters.

Docker is a technology that allows us to build, run, test, and deploy distributed applications that are based on Linux containers.

ECS is basically a set of APIs that turn EC2 instances into compute cluster for container management:

EC2 instances must call RegisterContainerInstance API to signal that they are ready to run containers.
Need to call RegisterTaskDefinition API to define the tasks (setting an image, command and memory for docker run etc.)
We use RunTask API to start a new task.
Lastly, we make a CreateService API call to run a long-running container.

We can start using Amazon EC2 Container Service (Amazon ECS) by creating a task definition, scheduling tasks, and configuring a cluster in the Amazon ECS console. Note that we do not need any orchestration tools such as Mesos, Kubernetes or Docker Swarm.

ECS first run wizard configuration

Open the Amazon ECS console first run wizard at https://console.aws.amazon.com/ecs/home#/firstRun.

Step 2: Build, tag, and push Docker image

Now that our repository exists, we can push a Docker image by following these steps:

Retrieve the docker login command that we can use to authenticate our Docker client to our registry:

$ aws ecr get-login --region us-east-1

Run the docker login command that was returned in the previous step.

Or we can combine the two commands:

$ eval $(aws ecr get-login --region us-east-1)
Login Succeeded

Flask Dockerfile:

FROM tiangolo/uwsgi-nginx-flask:flask

# copy over our requirements.txt file
COPY requirements.txt /tmp/

# upgrade pip and install required python packages
RUN pip install -U pip
RUN pip install -r /tmp/requirements.txt

# copy over our app code
COPY ./app /app

# set an environmental variable, MESSAGE,
# which the app will use and display
ENV MESSAGE "hello from Docker"

app/main.py:

from pyfiglet import Figlet
import os
from flask import Flask

app = Flask(__name__)

font = Figlet(font="starwars")

@app.route("/")
def main():
    # get the message from the environmental variable $MESSAGE
    # or fall back to the string "no message specified"
    message = os.getenv("MESSAGE", "Flask on AWS ECS")

    # render plain text nicely in HTML
    html_text = font.renderText(message)\
            .replace(" "," ")\
            .replace(">",">")\
            .replace("<","<")\
            .replace("\n","<br>")

    # use a monospace font so everything lines up as expected
    return "<html><body style='font-family: mono;'>" + html_text + "</body></html>"

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=5000)

requirements.txt:

Flask==0.11.1
pyfiglet==0.7.5

Now we're ready for our Flask app. On our local machine, let's build our Docker image using the following command:

$ docker build -t my_flask_app .
Sending build context to Docker daemon 25.43 MB
Step 1/6 : FROM tiangolo/uwsgi-nginx-flask:flask
Step 2/6 : COPY requirements.txt /tmp/
Step 3/6 : RUN pip install -U pip
Step 4/6 : RUN pip install -r /tmp/requirements.txt
Step 5/6 : COPY ./app /app
Step 6/6 : ENV MESSAGE "hello from Docker"
Successfully built 1ff7f5314a23

$ docker images
REPOSITORY      TAG                 IMAGE ID            
my_flask_app    latest              1ff7f5314a23

After the build completes, tag our image so we can push the image to this repository:

$ docker tag my_flask_app:latest 526262051452.dkr.ecr.us-east-1.amazonaws.com/my-ec2-container-registry:latest

Run the following command to push this image to our newly created AWS repository:

$ docker push 526262051452.dkr.ecr.us-east-1.amazonaws.com/my-ec2-container-registry:latest
The push refers to a repository [526262051452.dkr.ecr.us-east-1.amazonaws.com/my-ec2-container-registry]
...
latest: digest: sha256:5de6f7cb5ed272746dad4fc6e7168e6855ad8f40b13c56c4c811d1ff18d9da2b size: 5344

We can check if the image has been pushed into ECR:

Create a task definition

A task definition is like a blue print for an application.

Every time we launch a task in Amazon ECS, we specify a task definition so the service knows which Docker image to use for containers, how many containers to use in the task, and the resource allocation for each container.

Task definitions created in the first run wizard are limited to a single container for simplicity's sake:

Actually, to complete the definition, we need to click "Add Container" and fill out the following as shown below:

Configure service

A service launches and maintains a specified number of copies of the task definition in our cluster.

The Amazon ECS sample application is a web-based "Hello World" style application that is meant to run indefinitely, so by running it as a service, it will restart if the task becomes unhealthy or unexpectedly stops.

Configure cluster

In this section of the wizard, we name our cluster, and then configure the container instances that our tasks can be placed on, the address range that we can reach our instances and load balancer from, and the IAM roles to use with our container instances that let Amazon ECS take care of this configuration for us.

Run

Now, our docker is running on this agent node:

Cleaning Up our Amazon ECS Resources

Scale Down Services
If our cluster contains any services, we should first scale down the desired count of tasks in these services to 0 so that Amazon ECS does not try to start new tasks on our container instances while we are cleaning up.
Updating a Service and enter 0 in the Number of tasks field.
Delete Services
Before we can delete a cluster, we must delete the services inside that cluster. After our service has scaled down to 0 tasks, we can delete it. For each service inside our cluster, follow the procedures in Deleting a Service to delete it.
Deregister Container Instances
Before we can delete a cluster, we must deregister the container instances inside that cluster. For each container instance inside our cluster, follow the procedures in Deregister a Container Instance to deregister it.
Delete a Cluster After we have removed the active resources from our Amazon ECS cluster, we can delete it.
Delete the AWS CloudFormation Stack