📣 Limited offer: subscribe to cloudonaut plus, get a t-shirt for free

📣 Limited offer: free cloudonaut t-shirt

How to dockerize your Node.js Express application for AWS Fargate?

Michael Wittig – 05 Dec 2019

My first project with Node.js - an asynchronous event-driven JavaScript runtime, designed to build scalable network applications - was building an online trading platform in 2013. Since then, Node.js is one of my favorite technologies. I will show you how to dockerize your Node.js application based on Express - a fast, unopinionated, minimalist web framework - and run it on AWS Fargate in this blog bost. I like AWS Fargate because running containers in the cloud were never easier.

This blog post is an excerpt from our book Rapid Docker on AWS.

Read on to learn how to build a Docker image for a Node.js application.

Dockerize your Node.js application for AWS Fargate

Building the Docker image

The Dockerfile is based on the official Node.js Docker Image: node:10.16.2-stretch. Static files (folders img and css) are served by Express as well as the dynamic parts. The following details are required to understand the Dockerfile:

  • envsubst is used to generate the config file from environment variables
  • npm ci --only=production installs the dependencies declared in package.json (package-lock.json, to be more precise)
  • The Express application listens on port 8080
  • The Express application’s entry point is server.js and can be started with node server.js

A simple server.js file follows. Yours likely is more complicated.

server.js
const express = require('express');

const app = express();
app.use('/css', express.static('css'));
app.use('/img', express.static('img'));

app.get('/health-check', (req, res, next) => {
res.sendStatus(200);
});

app.listen(8080, '0.0.0.0');

Customization Most likely, your folder structure is different. Therefore, adapt the Copy config files and Copy Node.js files section in the following Dockerfile to your needs.

docker/Dockerfile
FROM node:10.16.2-stretch

WORKDIR /usr/src/app

ENV NODE_ENV production

# Install envsubst
RUN apt-get update && apt-get install -y gettext
COPY docker/custom-entrypoint /usr/local/bin/
RUN chmod u+x /usr/local/bin/custom-entrypoint
ENTRYPOINT ["custom-entrypoint"]
RUN mkdir /usr/src/app/config/

# Copy config files
COPY config/*.tmp /tmp/config/

# Install Node.js dependencies
COPY package*.json /usr/src/app/
RUN npm ci --only=production

# Copy Node.js files
COPY css /usr/src/app/css
COPY img /usr/src/app/img
COPY views /usr/src/app/views
COPY server.js /usr/src/app/

# Expose port 8080 and start Node.js server
EXPOSE 8080
CMD ["node", "server.js"]

The custom entrypoint is used to generate the config file from environment variables with envsubst.

docker/custom-entrypoint
#!/bin/bash
set -e

echo "generating configuration files"
FILES=/tmp/config/*
for f in $FILES
do
c=$(basename $f .tmp)
echo "... $c"
envsubst < $f > /usr/src/app/config/${c}
done

echo "starting $@"
exec "$@"

Next, you will learn how to test your containers and application locally.

Testing locally

Use Docker Compose to run your application locally. The following docker-compose.yml file configures Docker Compose and starts two containers: Node.js and a MySQL database.

Special offer: cloudonaut t-shirt

Do you love our blog posts and podcast episodes? Unlock our weekly videos and online events by subscribing to cloudonaut plus.

Special offer: Join cloudonaut plus before November 30th, and we will send you a cloudonaut t-shirt for free.

Subscribe now!
docker/docker-compose.yml
version: '3'
services:
nodejs:
build:
context: '..'
dockerfile: 'docker/Dockerfile'
ports:
- '8080:8080'
depends_on:
- mysql
environment:
DATABASE_HOST: mysql
DATABASE_NAME: app
DATABASE_USER: app
DATABASE_PASSWORD: secret
mysql:
image: 'mysql:5.6'
command: '--default-authentication-plugin=mysql_native_password'
ports:
- '3306:3306'
environment:
MYSQL_ROOT_PASSWORD: secret
MYSQL_DATABASE: app
MYSQL_USER: app
MYSQL_PASSWORD: secret

The following command starts the application:

docker-compose -f docker/docker-compose.yml up --build

Magically, Docker Compose will spin up two containers: Node.js and MySQL. Point your browser to http://localhost:8080 to check that your web application is up and running. The log files of all containers will show up in your terminal, which simplifies debugging a lot.

After you have verified that your application is working correctly, cancel the running docker-compose process by pressing CTRL + C, and tear down the containers:

docker-compose -f docker/docker-compose.yml down

Deploying on AWS

You are now ready to deploy your application on AWS.

(1) Build Docker image:

docker build -t nodejs-express:latest -f docker/Dockerfile .

(2) Create ECR repository:

aws ecr create-repository --repository-name nodejs-express \
--query 'repository.repositoryUri' --output text

(3) Login to Docker registry (ECR):

$(aws ecr get-login --no-include-email)

(4) Tag Docker image:

docker tag nodejs-express:latest \
111111111111.dkr.ecr.eu-west-1.amazonaws.com/\
nodejs-express:latest

(5) Push Docker image:

docker push \
111111111111.dkr.ecr.eu-west-1.amazonaws.com/\
nodejs-express:latest

There is only one step missing: you need to spin up the cloud infrastructure.

  1. Use our Free Templates for AWS CloudFormation.
  2. Use our cfn-modules.
  3. Use the blueprint from our book Rapid Docker on AWS.
Michael Wittig

Michael Wittig

I’m an independent consultant, technical writer, and programming founder. All these activities have to do with AWS. I’m writing this blog and all other projects together with my brother Andreas.

In 2009, we joined the same company as software developers. Three years later, we were looking for a way to deploy our software—an online banking platform—in an agile way. We got excited about the possibilities in the cloud and the DevOps movement. It’s no wonder we ended up migrating the whole infrastructure of Tullius Walden Bank to AWS. This was a first in the finance industry, at least in Germany! Since 2015, we have accelerated the cloud journeys of startups, mid-sized companies, and enterprises. We have penned books like Amazon Web Services in Action and Rapid Docker on AWS, we regularly update our blog, and we are contributing to the Open Source community. Besides running a 2-headed consultancy, we are entrepreneurs building Software-as-a-Service products.

We are available for projects.

You can contact me via Email, Twitter, and LinkedIn.

Briefcase icon
Hire me