Writing your first Dockerfile

A Dockerfile consists of a series of text instructions to guide the Docker daemon to form an image, and a Dockerfile must start with the FROM directive. For example, we may have an image built from the following one-liner:

docker commit $(                         \
  docker start $(                        \
    docker create alpine /bin/sh -c      \
      "echo My custom build > /etc/motd" \
))

This roughly equates to the following Dockerfile:

FROM alpine
RUN echo "My custom build" > /etc/motd

Obviously, building with a Dockerfile is much more concise and precise.

The docker build [OPTIONS] [CONTEXT] command is the only command associated with building tasks. A context can be a local path, URL, or stdin, which denotes the location of the Dockerfile. Once a build is triggered, the Dockerfile, alongside everything under the context, will be sent to the Docker daemon beforehand and then the daemon will start to execute instructions in the Dockerfile sequentially. Every execution of the instructions results in a new cache layer, and the ensuing instruction is executed at the new cache layer in the cascade. Since the context will be sent somewhere that isn't guaranteed to be a local path, and sending too many irrelevant files takes time, it's a good practice to put the Dockerfile, code, necessary files, and a .dockerignore file in an empty folder to make sure the resultant image contains only the desired files.

The .dockerignore file is a list indicating which files under the same directory can be ignored at build time. It typically looks as follows:

$ cat .dockerignore
# ignore .dockerignore, .git
.dockerignore
.git
# exclude all *.tmp files and vim swp file recursively
**/*.tmp
**/[._]*.s[a-w][a-z]
# exclude all markdown files except README*.md
!README*.md

Generally, docker build will try to locate a file named Dockerfile under the context to start a build. Sometimes, however, we may want to give it another name, which we can do using the -f (--file) flag. Another useful flag, -t (--tag), is able to give an image one or more repository tags after an image is built. Let's say we want to build a Dockerfile named builder.dck under ./deploy and label it with the current date and the latest tag. The command to do this is as follows:

## We can assign the image with more than one tag within a build command
$ docker build -f deploy/builder.dck               \
   -t my-reg.com/prod/teabreaker:$(date +"%g%m%d") \
   -t my-reg.com/prod/teabreaker:latest .