<div id="readability-page-1" class="page"><div><div><a rel="noopener follow" href="/?source=post_page-----35b229e6fd83--------------------------------"><div aria-hidden="false"><p><img alt="Wynn" src="https://miro.medium.com/v2/resize:fill:88:88/1*LLvV2_vpdgpdIae8DAVKcA.png" width="44" height="44" loading="lazy" data-testid="authorPhoto"></p></div></a></div><p id="eaad"><strong>Deployment Automation (Django + Docker + ECS + Fargate)</strong></p><figure><figcaption>AWS ECS</figcaption></figure><p id="02bb"><strong>Cloud service has become an indispensable part for us, like air.</strong><br>I still vividly remember the exhilarating feeling when I first deployed my clumsy web application to an EC2 instance. However, as a novice developer back then, I encountered numerous challenges, particularly with:</p><ul><li id="a920">Nginx</li><li id="1592">Security Group</li><li id="1ba6">SSH Key</li><li id="0ec8">Running the server in the background</li></ul><p id="d21c">These components didn’t provide clues suitable to my beginner level, leading to significant trial and error.</p><h2 id="64c1">Manual Deployment Challenges</h2><p id="ac44">While initial deployment costs are justifiable, connecting to the instance via SSH key and running <code>git pull</code> for every update is tedious. Although SSH key access is straightforward, novice developers often feel an uneasy reluctance towards directly accessing instances. The reluctance leads to infrequent updates and can diminish interest in the service being developed.</p><h2 id="3e53">Introduction to Automation with GitHub Actions</h2><p id="3980">To address these issues, we’ll automate the process of dockerizing our application and deploying it to AWS using GitHub Actions. this may sound daunting, but by leveraging AWS services, we’ll just need to provide the correct configuration values. Deployment becomes repetitive and mundane once the process is established, and as developers, avoiding repetitive tasks is our destiny.</p><h2 id="c09f">Prerequisites</h2><ul><li id="d7d7">Create a Django proejct</li><li id="2cc6">Install Docker</li></ul><h2 id="63f1">Building the Docker Image</h2><p id="d5d6">Before writing the Dockerfile, list the required Python libs in <code>requirements.txt</code> . for this example, we’ll use <code>django</code> and <code>mysqlclient</code> .</p><pre><span id="f088">django==3.1<br>mysqlclient==2.0.1</span></pre><p id="325b">The `Dockerfile` executes a set of commands (DSL) to create the Docker image. Let’s create a Dockerfile in the project’s root directory.</p><pre><span id="a3ff">FROM python:3.7<br>ENV PYTHONUNBUFFERED=1<br>WORKDIR /app<br>COPY requirements.txt /app/<br>RUN pip install -r requirements.txt<br>COPY . /app/<br>EXPOSE 8080<br>CMD ["python3", "manage.py", "runserver", "0.0.0.0:8080"]</span></pre><p id="8fee">Now build the Docker image using the following command:</p><pre><span id="c133">docker build . -t ecs-tutorial</span></pre><p id="de59">If logs like the below have been printed, it means the image build was successful.</p><pre><span id="f944">&gt; docker build . -t ecs-tutorial<br>Step 1/8 : FROM python:3.7<br> ---&gt; 2699987679cd<br>Step 2/8 : ENV PYTHONUNBUFFERED=1<br> ---&gt; Using cache<br> ---&gt; b1ecf661981c<br>Step 3/8 : WORKDIR /app<br> ---&gt; Using cache<br> ---&gt; 4f89f55da03a<br>Step 4/8 : COPY requirements.txt /app/<br> ---&gt; Using cache<br> ---&gt; 363862418ed6<br>Step 5/8 : RUN pip install -r requirements.txt<br> ---&gt; Using cache<br> ---&gt; ee9a55e82551<br>Step 6/8 : COPY . /app/<br> ---&gt; Using cache<br> ---&gt; c0b955af8faf<br>Step 7/8 : EXPOSE 8080<br> ---&gt; Using cache<br> ---&gt; ebb82e5e1931<br>Step 8/8 : CMD [ "python3", "manage.py", "runserver", "0.0.0.0:8080" ]<br> ---&gt; Using cache<br> ---&gt; ba3d6c22cbb9<br>Successfully built ba3d6c22cbb9<br>Successfully tagged ecs-tutorial:latest</span></pre><p id="8c47">You can see the list of images you have created by entering the <code>docker images</code> command.</p><pre><span id="8e79">REPOSITORY      TAG     IMAGE ID            CREATED           SIZE<br>ecs-tutorial   latest  8b9365a9f930       2 seconds ago       919MB<br>...</span></pre><h2 id="a119">Running the Docker Container</h2><p id="923d">to run the image:</p><pre><span id="42c5">docker run -d -p 8080:8080 ecs-tutorial</span></pre><figure></figure><p id="5f65">Access <code>127.0.0.1:8080</code> to see the Django rocket welcoming you.</p><h2 id="fa20">Creating a Repository in AWS ECR</h2><p id="034b">ECR is a managed container image registry service by AWS. It securely stores Docker images, and integrates seemless with other AWS services.</p><figure></figure><p id="86d2">Create a repository named <code>repo-for-ecs-tutorial</code> in ECR. We will later upload our Docker image here Using GitHub Actions.</p><h2 id="6928">Creating a Task Definition</h2><p id="0e04">A task definition in ECS is similar to <code>docker-compose</code> . It specifies the Docker image, port mappings, instance type, CPU, and memory allocations. Instead of using the AWS console, we’ll create a <code>task-definition.json</code> file.</p><p id="c8ab">Create the <code>task-definition.json</code> in your project root:</p><pre><span id="7fa1">{<br>  "executionRoleArn": "arn:aws:iam::your_account_id:role/ecsTaskExecutionRole",<br>  "containerDefinitions": [<br>    {<br>      "name": "ecs-tutorial",<br>      "image": "your_account_id.dkr.ecr.region.amazonaws.com/repo-for-ecs-tutorial:latest",<br>      "memory": 512,<br>      "cpu": 256,<br>      "essential": true,<br>      "portMappings": [<br>        {<br>          "containerPort": 8080,<br>          "hostPort": 8080<br>        }<br>      ]<br>    }<br>  ],<br>  "family": "ecs-tutorial"<br>}</span></pre><p id="539a">Register the task definition using the AWS CLI:</p><pre><span id="409e">aws ecs register-task-definition --cli-input-json file://task-definition.json</span></pre><p id="ed6b">This command registers the task definition in your AWS account. You can verify the task definition in the AWS Management Console by navigating to the ECS service and selecting the “Task Definitions” tab.</p><figure></figure><h2 id="2c21">Understanding Roles and Permissions</h2><p id="3a7a">If you do not have an <code>executionRoleArn</code> created, follow these steps to create one:</p><ol><li id="78bd">Open the IAM console at <a href="https://console.aws.amazon.com/iam/" rel="noopener ugc nofollow" target="_blank">https://console.aws.amazon.com/iam/</a>.</li><li id="6e24">In the navigation pane, choose “Roles,” then “Create role.”</li><li id="8569">Select “Elastic Container Service” as the type of trusted entity.</li><li id="764e">For the use case, choose “Elastic Container Service Task” and then select “Next: Permissions.”</li><li id="4e3d">Search for <code>AmazonECSTaskExecutionRolePolicy</code>, select it, and proceed to the next step.</li><li id="7836">Name the role <code>ecsTaskExecutionRole</code> and create the role.</li></ol><p id="aaa5">Once created, the ARN for this role can be found in the IAM console under the role’s details. Use this ARN in your <code>task-definition.json</code> file.</p><p id="5488">By following these steps and using the provided example, you should have a comprehensive understanding of creating and registering a task definition for AWS ECS.</p><h2 id="20c5">Creating an ECS Cluster and Service</h2><figure></figure><p id="e348">Define an ECS cluster, which is a logical grouping of tasks of services. AWS provides a default clsuter, but we’ll create a new one named <code>cluster-for-ecs-tutorial</code> using the <code>Network only</code> template for Fargate.</p><h2 id="bcb2">Creating an Application Load Balancer</h2><p id="8861">In the EC2 console, create an ALB named <code>alb-for-ecs-tutorial</code> . Configure the security settings to open port 80 to anywhere. Create a target group with IP as the target type. Associate this ALB with service created in ECS.</p><h2 id="7128">Automating Deployment With GitHub Actions</h2><figure></figure><p id="a922">Configure GitHub Actions to deploy the Docker image to ECR and update the ECS service. Add the required secrets (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`) to GitHub. you can see the example of mine <a href="https://github.com/well-balanced/ecs-tutorial/blob/main/.github/workflows/aws.yml" rel="noopener ugc nofollow" target="_blank">here</a>.</p><p id="fe2e">Create a workflow file in your repository at <code>.github/workflows/aws.yml</code> :</p><pre><span id="dc34">name: Deploy to Amazon ECS<p>on:<br>  push:<br>    branches:<br>      - main</p><p>jobs:<br>  deploy:<br>    runs-on: ubuntu-latest<br>    steps:<br>      - name: Checkout code<br>        uses: actions/checkout@v2</p><p>      - name: Login to Amazon ECR<br>        id: login-ecr<br>        uses: aws-actions/amazon-ecr-login@v1</p><p>      - name: Build, tag, and push image to Amazon ECR<br>        env:<br>          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}<br>          ECR_REPOSITORY: repo-for-ecs-tutorial<br>          IMAGE_TAG: latest<br>        run: |<br>          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .<br>          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG</p><p>      - name: Deploy to Amazon ECS<br>        uses: aws-actions/amazon-ecs-deploy-task-definition@v1<br>        with:<br>          task-definition: task-definition.json<br>          service: ecs-tutorial-service<br>          cluster: cluster-for-ecs-tutorial<br>          wait-for-service-stability: true</p></span></pre><h2 id="a480">Conclusion</h2><p id="fc7b">By automating the deployment process, we can now focus more on developing our service. In future, we can explore advanced topics like applying SSL cerificates using AWS Certificate Manager, configuring HTTPS for ALB, and using AWS System Manager for environment variables.</p><h2 id="f025">References</h2><ul><li id="518b"><a href="https://dev.to/kokospapa8/how-to-deploy-django-app-to-ecs-fargate-part3-3i7p" rel="noopener ugc nofollow" target="_blank">How to Deploy Django App to ECS Fargate</a></li><li id="503b"><a href="https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ECS_AWSCLI_Fargate.html" rel="noopener ugc nofollow" target="_blank">Amazon ECS Developer Guide</a></li></ul><p id="7fde">this document has been created to help consolidate knowleged and make the deployment process smoother and more understandable.</p></div></div>

Stories by Woosik Kim on Medium

Deployment Automation (Django + Docker + ECS + Fargate)
Cloud service has become an indispensable part for us, like air.
I still vividly remember the exhilarating feeling when I first deployed my clumsy web application to an EC2 instance. However, as a novice developer back then, I encountered numerous challenges, particularly with:
Nginx
Security Group
SSH Key
Running the server in the background
These components didn’t provide clues suitable to my beginner level, leading to significant trial and error.
Manual Deployment Challenges
While initial deployment costs are justifiable, connecting to the instance via SSH key and running git pull for every update is tedious. Although SSH key access is straightforward, novice developers often feel an uneasy reluctance towards directly accessing instances. The reluctance leads to infrequent updates and can diminish interest in the service being developed.
Introduction to Automation with GitHub Actions
To address these issues, we’ll automate the process of dockerizing our application and deploying it to AWS using GitHub Actions. this may sound daunting, but by leveraging AWS services, we’ll just need to provide the correct configuration values. Deployment becomes repetitive and mundane once the process is established, and as developers, avoiding repetitive tasks is our destiny.
Prerequisites
Create a Django proejct
Install Docker
Building the Docker Image
Before writing the Dockerfile, list the required Python libs in requirements.txt . for this example, we’ll use django and mysqlclient .
django==3.1
mysqlclient==2.0.1
The `Dockerfile` executes a set of commands (DSL) to create the Docker image. Let’s create a Dockerfile in the project’s root directory.
FROM python:3.7
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY requirements.txt /app/
RUN pip install -r requirements.txt
COPY . /app/
EXPOSE 8080
CMD ["python3", "manage.py", "runserver", "0.0.0.0:8080"]
Now build the Docker image using the following command:
docker build . -t ecs-tutorial
If logs like the below have been printed, it means the image build was successful.
> docker build . -t ecs-tutorial
Step 1/8 : FROM python:3.7
 ---> 2699987679cd
Step 2/8 : ENV PYTHONUNBUFFERED=1
 ---> Using cache
 ---> b1ecf661981c
Step 3/8 : WORKDIR /app
 ---> Using cache
 ---> 4f89f55da03a
Step 4/8 : COPY requirements.txt /app/
 ---> Using cache
 ---> 363862418ed6
Step 5/8 : RUN pip install -r requirements.txt
 ---> Using cache
 ---> ee9a55e82551
Step 6/8 : COPY . /app/
 ---> Using cache
 ---> c0b955af8faf
Step 7/8 : EXPOSE 8080
 ---> Using cache
 ---> ebb82e5e1931
Step 8/8 : CMD [ "python3", "manage.py", "runserver", "0.0.0.0:8080" ]
 ---> Using cache
 ---> ba3d6c22cbb9
Successfully built ba3d6c22cbb9
Successfully tagged ecs-tutorial:latest
You can see the list of images you have created by entering the docker images command.
REPOSITORY      TAG     IMAGE ID            CREATED           SIZE
ecs-tutorial   latest  8b9365a9f930       2 seconds ago       919MB
...
Running the Docker Container
to run the image:
docker run -d -p 8080:8080 ecs-tutorial
Access 127.0.0.1:8080 to see the Django rocket welcoming you.
Creating a Repository in AWS ECR
ECR is a managed container image registry service by AWS. It securely stores Docker images, and integrates seemless with other AWS services.
Create a repository named repo-for-ecs-tutorial in ECR. We will later upload our Docker image here Using GitHub Actions.
Creating a Task Definition
A task definition in ECS is similar to docker-compose . It specifies the Docker image, port mappings, instance type, CPU, and memory allocations. Instead of using the AWS console, we’ll create a task-definition.json file.
Create the task-definition.json in your project root:
{
  "executionRoleArn": "arn:aws:iam::your_account_id:role/ecsTaskExecutionRole",
  "containerDefinitions": [
    {
      "name": "ecs-tutorial",
      "image": "your_account_id.dkr.ecr.region.amazonaws.com/repo-for-ecs-tutorial:latest",
      "memory": 512,
      "cpu": 256,
      "essential": true,
      "portMappings": [
        {
          "containerPort": 8080,
          "hostPort": 8080
        }
      ]
    }
  ],
  "family": "ecs-tutorial"
}
Register the task definition using the AWS CLI:
aws ecs register-task-definition --cli-input-json file://task-definition.json
This command registers the task definition in your AWS account. You can verify the task definition in the AWS Management Console by navigating to the ECS service and selecting the “Task Definitions” tab.
Understanding Roles and Permissions
If you do not have an executionRoleArn created, follow these steps to create one:
Open the IAM console at https://console.aws.amazon.com/iam/.
In the navigation pane, choose “Roles,” then “Create role.”
Select “Elastic Container Service” as the type of trusted entity.
For the use case, choose “Elastic Container Service Task” and then select “Next: Permissions.”
Search for AmazonECSTaskExecutionRolePolicy, select it, and proceed to the next step.
Name the role ecsTaskExecutionRole and create the role.
Once created, the ARN for this role can be found in the IAM console under the role’s details. Use this ARN in your task-definition.json file.
By following these steps and using the provided example, you should have a comprehensive understanding of creating and registering a task definition for AWS ECS.
Creating an ECS Cluster and Service
Define an ECS cluster, which is a logical grouping of tasks of services. AWS provides a default clsuter, but we’ll create a new one named cluster-for-ecs-tutorial using the Network only template for Fargate.
Creating an Application Load Balancer
In the EC2 console, create an ALB named alb-for-ecs-tutorial . Configure the security settings to open port 80 to anywhere. Create a target group with IP as the target type. Associate this ALB with service created in ECS.
Automating Deployment With GitHub Actions
Configure GitHub Actions to deploy the Docker image to ECR and update the ECS service. Add the required secrets (`AWS_ACCESS_KEY_ID`, `AWS_SECRET_ACCESS_KEY`) to GitHub. you can see the example of mine here.
Create a workflow file in your repository at .github/workflows/aws.yml :
name: Deploy to Amazon ECS
on:
  push:
    branches:
      - main
jobs:
  deploy:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v2
      - name: Login to Amazon ECR
        id: login-ecr
        uses: aws-actions/amazon-ecr-login@v1
      - name: Build, tag, and push image to Amazon ECR
        env:
          ECR_REGISTRY: ${{ steps.login-ecr.outputs.registry }}
          ECR_REPOSITORY: repo-for-ecs-tutorial
          IMAGE_TAG: latest
        run: |
          docker build -t $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG .
          docker push $ECR_REGISTRY/$ECR_REPOSITORY:$IMAGE_TAG
      - name: Deploy to Amazon ECS
        uses: aws-actions/amazon-ecs-deploy-task-definition@v1
        with:
          task-definition: task-definition.json
          service: ecs-tutorial-service
          cluster: cluster-for-ecs-tutorial
          wait-for-service-stability: true
Conclusion
By automating the deployment process, we can now focus more on developing our service. In future, we can explore advanced topics like applying SSL cerificates using AWS Certificate Manager, configuring HTTPS for ALB, and using AWS System Manager for environment variables.
References
How to Deploy Django App to ECS Fargate
Amazon ECS Developer Guide
this document has been created to help consolidate knowleged and make the deployment process smoother and more understandable.

Deployment Automation using GitHub Actions with ECS

댓글