Typing and running complex docker commands in the terminal can sometimes feel like repetitive and tedious work. In this article, we will learn how to simplify running docker commands by using Make and Makefiles.

Pre-requisites

To follow along with this article, you need to have the following packages installed in your development environment:

• Docker

• Docker-compose

• make

What is Make?

Make is a Unix utility tool that executes and compiles software programs. For Make to do its job, it reads instructions that are defined in a Makefile.

What is a Makefile?

A Makefile is a file that contains a set of rules or commands that are executed by the make utility tool.

Why use Make and Makefiles?

Make was primarily developed to compile software programs, but it's flexible enough to be used for other use cases. One of the use cases is the ability to wrap complex bash or shell commands into simple memorable actions (similar to functions in object-oriented programming languages). This saves you the hustle of having to remember and type long commands into the terminal every time you need to use them. This is especially useful if you work with tools like docker or docker-compose where you frequently have to run longer docker commands in the terminal.

Understanding Makefile syntax

Before we dive into how to use Makefiles, it is worth considering its syntax. Below is the structure of a Makefile.

target: dependencies
  commands

In the above syntax, target can be a name of a file, an executable or a name of action. In our case, the target will be the name of an action since we have no dependencies. When a target is not a name of a file and does not have dependencies it is referred to as a phony target.

dependencies are file objects that are taken as inputs to create the target. In our case, we do not need the dependencies.

commands are rules that can be executed by the shell. This is where we place our docker-related commands.

note that the command needs to be tab-delimited not space delimited

Docker-compose use case

Now that we know what Make and Makefile is and their structure, let's put them to use. In the following example, we will use the Make tool and Makefile to simplify running docker-compose commands.

Suppose we have two docker-compose files (docker-compose-dev.yml and docker-compose-prod.yml), one for the development environment and another for the production environment. For each environment, we have a set of docker commands we need to run. Let's explore how to use Make to run docker-compose commands for the two environments. For demonstration purposes, we will use the docker-compose up, docker-compose down and docker-compose logs commands. We won't be covering the contents of the docker-compose files as it is out of the scope of this article.

1. Create a Makefile

The first step is to create a Makefile. The Makefile should be created in the same directory where the docker-compose files are located.

2. Docker commands for the development environment

Let's add the docker commands for the development environment. We will use our docker-compose file for the development environment named docker-compose-dev.yml. Add the following to the created Makefile

start-dev:
  docker-compose -f docker-compose-dev.yml up

stop-dev:
  docker-compose -f docker-compose-dev.yml down

restart-dev:
  docker-compose -f docker-compose-dev.yml down && docker-compose -f docker-compose-dev.yml up

logs-dev:
  docker-compose logs

Now, to run the application or service in the development environment, run the following commands in the terminal:

make start-dev to start the application in a development environment.

make stop-dev to stop the application.

make restart-dev to restart the application.

make logs-dev to display docker logs.

3. Docker commands for the production environment

Finally, let's add the command for the production environment. In this case, we have a production docker-compose file named docker-compose-prod.yml. Below are the docker commands for the production environment.

start-prod:
  docker-compose -f docker-compose-prod.yml up

stop-prod:
  docker-compose -f docker-compose-prod.yml down

restart-prod:
  docker-compose -f docker-compose-prod.yml down && docker-compose -f docker-compose-prod.yml up

logs-prod:
  docker-compose logs

Use the following commands to run the application for the production environment:

make start-prod to start the application in production.

make stop-prod to stop the application in production.

make restart-prod to restart the application.

make logs-prod to show logs in production.

Conclusion

Make is not only limited to docker commands but can be used for other shell commands to simplify your workflow.

Additional Resources

• Make and Makefile: www3.nd.edu/~zxu2/acms60212-40212/Makefile...

• Docker: docs.docker.com/get-started

• Docker-compose: docs.docker.com/compose

Happy coding!!!