Andoni Rodríguez


Docker & Docker Compose

Comprehensive introduction to development with Docker and Docker Compose

Every day it is more common to find applications inside containers. Docker is becoming the standard to develop, build and share containers.

According to their website

Docker is an open platform for developing, shipping, and running applications. Docker enables you to separate your applications from your infrastructure so you can deliver software quickly. With Docker, you can manage your infrastructure in the same ways you manage your applications. By taking advantage of Docker’s methodologies for shipping, testing, and deploying code quickly, you can significantly reduce the delay between writing code and running it in production.

Docker is a great tool in multiple cases, like when you want to package an application and show it to someone, or you want to do software installation tests without having to install software on your own operating system.

With Docker Compose we can go a step further, it gives us a lot of options to develop on containers, as well as a minimum of orchestration between them.

If you've never worked with Docker, I recommend that you take a look at their website. They have very good and complete tutorials for all levels. Specifically, this may seem simple but it helps a lot to understand the key concepts of container application development.

We often find an infinity of tutorials and how-to's that show how to do this work of orchestration, and they do many unnecessary things, and aren't automated between independent containers.

This results in unstable development systems, dependent on external scripts that instead of helping, make the task difficult. And this is just what Docker Compose wants to avoid.

There are several approaches for which Docker Compose can be a good use case. I'm going to focus on two of them; Development environments and Single host deployments.

The goal in this post is to explain how to mount a Node.js environment with Docker Compose and be able to write two different Compose files, one that serves us to develop locally and another, with an additional container, that will enable us to be able to deploy our application to any server on the internet.

The application Node.js that we will dockerize, is one of the example applications that appear in the official page of Socket.IO, a chat with websockets.

Our project will have the following structure:

⇒  ls 

We'll start with the Node.js part consisting of three files; index.js, index.html and package.json. What the Node files do, its explained in Socket.IO much better than I could do, since I am no expert in Java Script, but it's enough to know that they have the logic of the chat. The file that interests us is package.json, since it contains the necessary dependencies to be able to execute the application.

  "name": "socket-chat-example",
  "version": "0.0.1",
  "description": "my first app",
  "dependencies": {
    "express": "4.10.2",
    "": "1.2.0"

In order to be able to dockerize our application, the only thing we have to do is to define a Dockerfile that 'holds' all the necessary software to work.

A Dockerfile, is a text file that contains a series of commands to execute in the selected image, as it is executed, it is composing our container.

Something like this:

FROM node:6.9
RUN mkdir /code
ADD . /code/
RUN npm install

With 'FROM node:6.9' we are telling it the image that has to start to create the container, the 'RUN' command will execute in the container any command we tell it, in this case create a directory. 'WORKDIR' positions the directory indicated, 'ADD' copies the project to the destination directory in the container.

It is important to pay attention to the last line ('RUN npm install') since it is the one that installs the package needed for the application.

With this we already have a fully functional container with Node.js installed and running in it. It's that easy!

The next step is to define a Docker Compose file (docker-compose.yml) that looks like this:

version: '2'
    build: .
      - .:/code
      - /code/node_modules
    command: nodejs index.js
      - "3000:3000"

A Docker Compose file consists of defining your application with services. In this case we only define one service, the container Node.js.

We tell it to search the Dockerfile with 'build .', and map the necessary volumes to the container. We define 'command' to say to the container what command to execute when the Dockerfile script finishes. With 'ports' we open the necessary ports for Node.js (external port:internal port)

Great. We can now start the dockerize application Node.js with the following command:

$ docker-compose up

If this is the first time you run this command, Docker will download everything you need, in a few seconds you should see something similar to this:

Building node
Step 1 : FROM node:6.9
6.9: Pulling from library/node
5040bd298390: Pull complete
fce5728aad85: Pull complete
76610ec20bf5: Pull complete
52f3db4b5710: Pull complete
7e5867712a67: Pull complete
563b602246dd: Pull complete
043696f38236: Pull complete
Digest: sha256:40bc08204b9beae97e28c3fc669a3fa1868dea629fd02ec8ec2c1b706cb1f350
Status: Downloaded newer image for node:6.9
 ---> 88717adf5e8a
Step 2 : RUN mkdir /code
 ---> Running in d60a15635dd5
 ---> a3fba1fcea4a
Removing intermediate container d60a15635dd5
Step 3 : WORKDIR /code
 ---> Running in 83d57387b055
 ---> 1dff2466cec9
Removing intermediate container 83d57387b055
Step 4 : ADD . /code/
 ---> 370dbc97eb00
Removing intermediate container 1ab92c89c59c
Step 5 : RUN npm install
 ---> Running in 78cb9ac2f749
Output of npm install ...
 ---> 703b87fedc3a
Removing intermediate container 78cb9ac2f749
Successfully built 703b87fedc3a
Creating chatnode_node_1
Attaching to chatnode_node_1
node_1   | listening on *:3000

Congratulations, you now have your own completely dockerized Node.js development environment running! :). I highly recommend that you explore the various Docker Compose options for yourself, but for now you just need to know that if you press 'Ctrl-C', the Docker Compose run will stop, although to be sure you can always do: $ docker-compose stop.

To verify that the chat works you can open a browser pointing to http://localhost:3000 and send some messages.

Chat working

Well, now comes the interesting part of Docker Compose, we can take as base our file docker-compose.yml and generate a similar one, docker-compose-prod.yml in which we will add one more service. This will allow us to mount a web server (Nginx), and be able to distribute our dockerized application Node.js to any internet server.

version: '2'

    image: nginx:latest
      - ./chat_site.conf:/etc/nginx/conf.d/site.conf
      - "91:80"

      - node

    build: .
      - .:/code
      - /code/node_modules
    command: nodejs index.js
      - "3000:3000" 

As you can see, we've added a new service to the file, the nginx service, this allows us to expose an HTTP interface and be able to do reverse-proxy instead of exposing Node.js itself.

The only volume that we need to map in this case is a file with the nginx configuration, let's take a look:

server {
    listen 80;

    server_name node.example;

    location / {
        proxy_pass http://node:3000;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
        proxy_set_header Host $host;
        proxy_cache_bypass $http_upgrade;

It is a classic reverse-proxy file of nginx, the only thing to note is that the variable 'proxy_pass' points to 'node' which is the name of the service that we have previously defined in the Docker Compose.

We continue with the Docker Compose, exposing the port 80 both internally and externally. Remember that exposing HTTP instead of HTTPS is insecure and you should not do so, but this is an example and there is nothing wrong with it.

Last, but not least, we have 'links' which indicates which containers can communicate with each other. As we are doing reverse-proxy from Nginx to Node.js, we indicate that it has to have a link to it.

And this is it, just deploy it on any server running $ docker-compose -f docker-compose-prod.yml up and Docker will do the rest :)

It is important to clarify that the use of Docker Compose in production environments is quite small and almost always goes towards solutions like Docker Swarm or more complex like Kubernetes, although personally I consider Docker Compose as a very good entry point if what you intended is to practice generating containers, configure them and make a small orchestration, so I hope it helps and someone can take advantage of it.

You can take a look at the project on GitHub and do your own tests.