Why use Docker compose

What is Docker compose?

If you read this article, I think you maybe already understand what is Docker.

Docker is a tool which helps to create, deploy, and run applications by using containers. Docker provides developers and operators with a friendly interface to build, ship, and run containers on any environment.

With the docker-cli, we can run and execute the Docker container via Dockerfile. But with Dockerfile, we can work only with a container, but in the project, we normally work with multiple containers. In that case, we need to use Docker compose.

Docker Compose define the services that make up your app in docker-compose.yml so they can be run together in an isolated environment. It get an app running in one command by just running docker-compose up.

Docker compose uses the Dockerfile if one add the build command to your project’s docker-compose.yml. Your Docker workflow should be to build a suitable Dockerfile for each image you wish to create, then use compose to assemble the images using the build command.

We will create a demo: simple app nodejs using Redis. You will see the problem with only Dockerfile and why use Docker compose.

Project demo


Make sure you have docker & docker-compose installed in your machine:

Create Docker Images without Docker compose

  • Create project folder

    $ mkdir node-redis-demo
    $ cd node-redis-demo
  • Create package.json file

    In this file, we will declare the dependencies we use for our application. This step is similar as you create the Nodejs application (without npm install or yarn add dependencies).

    We consider our computer don’t have npm or yarn installed. We just use Docker to create the develop environment.

    $ touch package.json # or yarn init -y

    Paste the following code:

      "name": "node-redis-app",
      "version": "1.0.0",
      "main": "index.js",
      "license": "MIT",
      "scripts": {
        "start": "node index.js",
      "dependencies": {
        "redis": "*", //We don't care about the version of dependencies
        "express": "*", //Docker will fetch the latest version of them
  • Create index.js file to config express and run server

    const express = require('express');
    const redis = require('redis');
    const app = express();
    const client = redis.createClient();
    client.on('error', function (error) {
    client.set('visits', 0);
    app.get('/', (req, res) => {
      client.get('visits', (err, visits) => {
        res.send('Number of visits is ' + visits);
        client.set('visits', parseInt(visits) + 1);
    const port = 8080;
    app.listen(port, () => {
      console.log('App Redis is running on port 8080');
  • Create Dockerfile

    # Dockerfile
    FROM node:12.18-alpine #Version nodejs we want to use
    WORKDIR /app #Define the work directory of project in Docker container
    COPY package*.json ./ #Make sure always copy package.json and package-lock.json to build folder
    # Copy package.json to avoid reinstall all the dependencies for each build
    RUN yarn install #Run install and update dependencies from package.json
    COPY . . #Copy all other files to the build folder
    EXPOSE 8080 #Optional: Port running on Docker container
    CMD ["node", "index.js"] #Command line to run project

    You can also check an article on my blog for more information of Dockerfile: Create simple project Nodejs with Docker

  • Create .dockerignore

  • Build Docker Image OK, everything is done. Now, we will build this image:

    $ docker build -t node-redis-app .

    Don’t forget the point . in the end.

    You can check all images available in your computer:

    $ docker images
  • Run Docker container from Docker image We have already an Docker image node-redis-app. The thing to do now is run container from this image to start project.

    $ docker run -p 8080:8080 -it node-redis-app

    -p 8080:8080 flag: declare port using (port on Docker container and port on your machine) -it flag: allow access inside the terminal of Docker container node-redis-app: name image of your app

  • Problem When you run with the command above, you will see an error failed connection with Redis-server:

    $ docker run -p 8080:8080 -it node-redis-app
    App Redis is running on port 8080
    Error: Redis connection to failed - connect ECONNREFUSED
        at TCPConnectWrap.afterConnect [as oncomplete] (net.js:1141:16) {
      errno: 'ECONNREFUSED',
      code: 'ECONNREFUSED',
      syscall: 'connect',
      address: '',
      port: 6379

    What is the problem ? The problem is: You want to run 2 containers in same times. ==> redis-server && nodejs But when you run your Dockerfile, you run only Nodejs app container, not to redis container. You can also create other redis-server container from redis image

    There are no any link between 2 this containers. Your Nodejs application can’t connect to redis-server(from redis Docker image).

    How to resolve this error? The answer is Docker compose. In this case, we need to use Docker compose to run and connect multiple Docker container.

Create Docker image using Docker compose

  • To make sure the project above running, we need simply create a docker-compose.yml file. It is a config file for docker-compose. It allows us to define the services (container) using in our app.

    $ touch docker-compose.yml
  • Add the following code:

    version: '3.8' #version of docker-compose
    services: # declare containers used
      redis-server: #image of redis
        image: 'redis'
      node-app: #images of your node app (using Dockerfile, package.json ...)
        restart: always #If this container stops for any reason, always attempt to restart it
        build: .
          - '8080:8080'

    Check docker compose for more details about configuration.

  • Update redis services to index.js file

    // index.js
    const express = require('express');
    const redis = require('redis');
    const app = express();
    const process = require('process');
    const client = redis.createClient({
      host: 'redis-server',
      port: '6379',
    client.on('error', function (error) {
    client.set('visits', 0);
    app.get('/', (req, res) => {
      client.get('visits', (err, visits) => {
        res.send('Number of visits is ' + visits);
        client.set('visits', parseInt(visits) + 1);
    const port = 8080;
    app.listen(port, () => {
      console.log('App Redis is running on port 8080');
  • Build and run your app with docker-compose

    In the root project:

    • Build images:
      $ docker-compose build
      When you use docker-compose to build the image, the image name is always going to be _, where in this example is node-redis-app_node-app.
    • Run containers with docker-compose
    $ docker-compose up # all services declared in docker-compose.yml will be started
    $ docker-compose up -d #detach mode
    • Stop containers with docker-compose
    $ docker-compose down # Stop all containers declared in docker-compose.yml file

That’s it. Test the code on your machine and check it in then localhost8080 to see the result.


Docker compose:

  • Separate CLI that gets installed along with Docker
  • Used to startup multiple Docker containers at the same time
  • Automate some of the long-winded arguments we were passing to docker run
  • Docker compose will start and connect all the containers Docker that you declare in the docker-compose.yml file. We will use it usually when we work with Docker.