Docker on AWS

Deploying Docker containers on AWS allows you to leverage AWS's robust infrastructure to manage and scale your applications. This guide covers key concepts, steps to deploy Docker containers on AWS, examples, and best practices for deploying Dockerized Express.js applications on AWS.

Key Concepts of Docker on AWS

• Amazon ECS: Amazon Elastic Container Service (ECS) is a fully managed container orchestration service.
• Amazon ECR: Amazon Elastic Container Registry (ECR) is a fully managed Docker container registry.
• Amazon EC2: Amazon Elastic Compute Cloud (EC2) provides scalable compute capacity in the cloud.
• Fargate: AWS Fargate is a serverless compute engine for containers.
• IAM: AWS Identity and Access Management (IAM) enables you to manage access to AWS services and resources securely.

Setting Up the Project

Initialize a new Express.js project and create a Dockerfile:

// Initialize a new project
// npm init -y

// Install Express
// npm install express

// Create the project structure
// mkdir src
// touch src/index.js Dockerfile .dockerignore .gitignore

// .gitignore
node_modules
.env

// .dockerignore
node_modules
npm-debug.log

Creating an Express Application

Create a simple Express application:

Example: index.js

// src/index.js
const express = require('express');
const app = express();
const port = 3000;

app.get('/', (req, res) => {
    res.send('Hello, Docker on AWS!');
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}/`);
});

Creating a Dockerfile

Create a Dockerfile to containerize your Express application:

Example: Dockerfile

// Dockerfile
FROM node:14

# Create app directory
WORKDIR /usr/src/app

# Install app dependencies
COPY package*.json ./
RUN npm install

# Bundle app source
COPY . .

# Expose port 3000 to the outside world
EXPOSE 3000

# Run app when the container launches
CMD ["node", "src/index.js"]

Building and Running the Docker Container

Build and run the Docker container for your Express application:

// Build the Docker image
docker build -t my-express-app .

// Run the Docker container
docker run -d -p 3000:3000 --name my-express-app my-express-app

// Open http://localhost:3000 in your browser to see the application running

Setting Up AWS

Set up AWS CLI, create an ECR repository, and push your Docker image to ECR:

Install AWS CLI

// On a Linux or macOS system
// Install AWS CLI using a package manager or download from the official website
brew install awscli

// Configure AWS CLI
aws configure

Create an ECR Repository

// Create an ECR repository
aws ecr create-repository --repository-name my-express-app

Push Docker Image to ECR

// Authenticate Docker to ECR
aws ecr get-login-password --region us-west-2 | docker login --username AWS --password-stdin .dkr.ecr.us-west-2.amazonaws.com

// Tag the Docker image
docker tag my-express-app:latest .dkr.ecr.us-west-2.amazonaws.com/my-express-app:latest

// Push the Docker image to ECR
docker push .dkr.ecr.us-west-2.amazonaws.com/my-express-app:latest

Deploying to Amazon ECS

Create an ECS cluster, define a task definition, and run a service:

Create an ECS Cluster

// Create an ECS cluster
aws ecs create-cluster --cluster-name my-cluster

Define a Task Definition

// task-definition.json
{
  "family": "my-express-app",
  "networkMode": "awsvpc",
  "containerDefinitions": [
    {
      "name": "my-express-app",
      "image": ".dkr.ecr.us-west-2.amazonaws.com/my-express-app:latest",
      "essential": true,
      "portMappings": [
        {
          "containerPort": 3000,
          "hostPort": 3000
        }
      ]
    }
  ],
  "requiresCompatibilities": ["FARGATE"],
  "cpu": "256",
  "memory": "512"
}

// Register the task definition
aws ecs register-task-definition --cli-input-json file://task-definition.json

Run a Service

// Create a VPC, subnets, and security group if not already created
aws ec2 create-vpc --cidr-block 10.0.0.0/16
aws ec2 create-subnet --vpc-id  --cidr-block 10.0.1.0/24
aws ec2 create-security-group --group-name my-security-group --description "My security group" --vpc-id 
aws ec2 authorize-security-group-ingress --group-id  --protocol tcp --port 3000 --cidr 0.0.0.0/0

// Create a Fargate service
aws ecs create-service \
    --cluster my-cluster \
    --service-name my-express-app-service \
    --task-definition my-express-app \
    --desired-count 1 \
    --launch-type FARGATE \
    --network-configuration "awsvpcConfiguration={subnets=[],securityGroups=[],assignPublicIp=ENABLED}"

Best Practices for Docker on AWS

• Use IAM Roles: Assign IAM roles to ECS tasks to grant permissions to AWS resources securely.
• Use Load Balancers: Use AWS Application Load Balancers to distribute traffic to your ECS services.
• Enable Auto Scaling: Configure ECS service auto scaling to adjust the desired count of tasks based on load.
• Monitor and Log: Use AWS CloudWatch for monitoring and logging your ECS services.
• Secure Your Environment: Use security groups and network ACLs to control access to your ECS tasks.

Testing Docker on AWS

Test your Dockerized application deployed on AWS to ensure it works correctly:

Example: Testing with Mocha and Chai

// Install Mocha and Chai
// npm install --save-dev mocha chai

// test/app.test.js
const chai = require('chai');
const expect = chai.expect;
const axios = require('axios');

describe('Express App', () => {
    it('should return Hello, Docker on AWS!', async () => {
        const response = await axios.get('http://:3000');
        expect(response.data).to.equal('Hello, Docker on AWS!');
    });
});

// Add test script to package.json
// "scripts": {
//   "test": "mocha"
// }

// Run tests
// npm test

Key Points

Conclusion

Deploying Docker containers on AWS allows you to leverage AWS's robust infrastructure to manage and scale your applications. By understanding and implementing the key concepts, steps, examples, and best practices covered in this guide, you can effectively deploy Dockerized Express.js applications on AWS. Happy coding!