Dockerizing AdonisJs (v6) with MySQL

While working on a new API for my company, I decided to use
AdonisJs in combination with MySQL for the implementation. As we are running all of our projects in Docker, the obvious choice was to dockerize the application.

After performing some research I only found documentation on dockerizing AdonisJS v5 applications. But as I was using AdonisJs v6 and needed to do some slight changes, I wanted to share what I have learned with the community.

I will focus mainly on the Docker parts in this article but will share below a few steps to kick-start the implementation of an API with Adonis with an example application. You can also take a look at the code in this GitHub repository.

In this example we will create a very simple API which returns random quotes from Arnold Schwarzenegger.

Creating a Dockerfile

As it is now mainly recommended to use Docker multistage builds to keep the Docker image small and cache each step, we will also build a multi stage Dockerfile.

First stage: BASE

The first stage will be our base layer, which will be used as a base for the other steps.
As it is recommended for Node.js and Docker we are changing the user from root to node.

ARG NODE_IMAGE=node:20.12.1-bullseye-slim

FROM $NODE_IMAGE as base
RUN mkdir -p /home/node/app && chown node:node /home/node/app 
WORKDIR /home/node/app
USER node
RUN mkdir tmp

Second stage: DEPENDENCIES

In the next step we will install the dependencies that we need to later build the Node.js app.

FROM base AS dependencies
COPY --chown=node:node ./package*.json ./
RUN npm ci
COPY --chown=node:node . .

Third stage: BUILD

With the base all set and the dependencies installed, we can now build our app!

FROM dependencies AS build
RUN node ace build

Fourth stage: PRODUCTION

And the last stage is wiring everything together for production. Note that we are building this stage from the base to keep our image as small as possible and we only install --production dependencies.

FROM base as production
ENV NODE_ENV=production
ENV PORT=$PORT
ENV HOST=0.0.0.0
COPY --chown=node:node ./package*.json ./
RUN npm ci --only=production
COPY --chown=node:node --from=build /home/node/app/build .
EXPOSE $PORT

Combined

This is how the complete Dockerfile should look like:

ARG NODE_IMAGE=node:20.12.1-bullseye-slim

###### First Stage - Creating base ######
FROM $NODE_IMAGE as base
RUN mkdir -p /home/node/app && chown node:node /home/node/app 
WORKDIR /home/node/app
USER node
RUN mkdir tmp

###### Second Stage - Installing dependencies ######
FROM base AS dependencies
COPY --chown=node:node ./package*.json ./
RUN npm ci
COPY --chown=node:node . .

###### Third Stage - Building Stage ######
FROM dependencies AS build
RUN node ace build

###### Final Stage - Production ######
FROM base as production
ENV NODE_ENV=production
ENV PORT=$PORT
ENV HOST=0.0.0.0
COPY --chown=node:node ./package*.json ./
RUN npm ci --only=production
COPY --chown=node:node --from=build /home/node/app/build .
EXPOSE $PORT

Wiring up docker-compose

Now that we have the Dockerfile that will describe our Docker image ready, we will configure our docker-compose.yml to run our Docker image.
In your project root create a docker-compose.yml and add the following contents:

version: '3.8'

services:
  arnold-api:
    image: arnold_api
    container_name: arnold_api
    restart: unless-stopped
    build:
      context: .
      target: build
    ports:
      - ${PORT}:${PORT}
      - 9229:9229
    env_file:
      - .env
    volumes:
      - ./:/home/node/app
      - /home/node/app/node_modules
    command: node ace serve --watch
    depends_on:
      - arnold-mysql

  arnold-mysql:
    image: arm64v8/mysql
    container_name: arnold-mysql
    restart: always
    ports:
      - ${DB_PORT}:${DB_PORT}
    expose:
      - ${DB_PORT}
    volumes:
      - ./db:/var/lib/mysql
volumes:
  db:

If you want to follow the complete project setup, here are the steps for starting from scratch:

Step-by-Step-Setup

1. Ensure you have Node.js and npm installed on your machine. AdonisJs needs Node.js >= 20.6

node -v
# v20.12.1

1. Create a new application. As this example is used for implementation of an API with a MySQL database, we use the according flags to have the relevant starter kits available.

 npm init adonisjs@latest adonis-mysql-docker  -- --kit=api --db=mysql --git-init=true

During installation you will be asked to select your authentication guard, to keep this example simple, we will leave authentication so skip that step.

1. When the installation is done, go into the project directory and open the project with your code editor

cd adonis-mysql-docker
code .

1. Create an .env file Copy the .env.example and add all relevant environment variables. Please note: It is important to set the HOST to the same value as in the Dockerfile! Otherwise you will not be able to reach the application.

TZ=UTC
PORT=3333
HOST=0.0.0.0
LOG_LEVEL=info
APP_KEY=fFNoe5b32DGXLIf4aHqjyQ6dOpaTdD6u
NODE_ENV=production
DB_HOST=127.0.0.1
DB_PORT=3306
DB_USER=root
DB_PASSWORD=arnold
DB_DATABASE=arnold-mysql

1. Adding our route and controller

In the routes.ts adjust the example route to return random quotes:

router.get('/', async () => {
  const quotes = [
    'Turn the pain into power.',
    'Life may be full of pain but that is not an excuse to give up.',
    'There are no shortcuts - everything is reps, reps reps.',
    'Doing nothing is easy. That is why so many people do it.',
    'Work harder than you did yesterday.',
    'Be passionate. This is the only way to be among the best.',
    'If you dont find the time. If you dont do the work, you dont get the results.',
  ]

  return `Arnold Quote of the Day: ${quotes[Math.floor(Math.random() * quotes.length)]}`
})

1. Add the Dockerfile and the docker-compose.yml as described at the beginning of the post.

Now let's see if everything worked.
Start your docker container by running
docker-compose up -d
Once the container has started you should be able to reach your api:

http://127.0.0.1:3333/

:)