Docker containers run on and made changes to images. Generally, we use existing images which is like a template to create a new container. A lot of Linux distribution and software provide serve Docker images. But in some cases, we may need to create or enhance the existing image. Dockerfile can be used to create new images by providing instructions about the new images.
Dockerfile
Dockerfile is a simple text file that contains configuration for the Docker Image which will be created. Dockerfile contains Dockerfile Commands to change the properties of the image. We can also call a Dockerfile as a recipe for an image.
Here is a simple and lean Dockerfile. This file simple derive Base Image from current and latest Ubuntu Docker image and then updates the existing packages. After update is completed apache2
package is install. Generally Dockerfile’s are more complicated then this example as we will see below.
#This is a sample Image
FROM ubuntu
MAINTAINER poftut@gmail.com
RUN apt-get update
RUN apt-get install –y apache2

Build Dockerfile and Create New Image
We will start with simple steps where we will build previously given Dockerfile example. This build will create an image with the -t
option of docker build
command poftut1
.
$ mkdir poftut1
$ cd poftut1/
$ vim Dockerfile
After the DockerFile is created with the example content we can build our image with docker build
command. We will require sudo because the current user does not have enough rights to create Docker image and we get root
privileges.
$ sudo docker build -t poftut1 .

We can see from image given Dockerfile instructions are executed line by line.
- Step 1 is getting base
ubuntu
image - Step 2 is setting Maintainer information
- Step 3 is running
apt-get update
command - Step 4 is installing
apache2
withapt
package manager.
Run and Use Docker Image
We can use this Docker image named poftut1
like a regular image for example ubuntu
. We will create a new container from poftut1
image with docker run
command.
$ sudo docker run -t -i poftut1 bash

Dockerfile Commands
Upto now we have learned simple steps to build an image with Dockerfile
. there are a lot of different Dockerfile commands which can be used to run command, create file, create metadata, copy file etc.
ADD – Copy File From Local System Into Image
Add is very useful command which is used to copy files and folders from local system where docker runs into the image file. This can be used to copy special configuration, copy applications or data. We can also use URL’s for [SOURCE DIRECTORY] like https://www.poftut.com/data
Syntax
ADD [SOURCE DIRECTORY] [DESTINATION DIRECTORY]
In this example we will copy the httpd.conf
file into the images /etc/httpd/httpd.conf
.
ADD httpd.conf /etc/httpd/httpd.conf
ARG – Provide Build Time Arguments
If we want to provide some argument in key value format in the build time we can use ARG
directive. This argument provided with the build
command. If we want to use default value we can set with ARG
directive.
Syntax
ARG [NAME] [=DEFAULT VALUE]
In this example we will set build time argument VERSION
with the default value 18.10
ARG VERSION="18.01"
CMD – Run Command At Container Start
CMD
is another useful command which is used to run commands at the start of the container. CMD
will not run during image build. When new container is created this command will be run.
Syntax
CMD [COMMAND] [ARGUMENT1] [ARGUMENT2]
In this example, we want to print Hello Poftut to the terminal when a new container is created from this image. The command will be echo
and argument1 will be "Hello Poftut"
CMD "echo" "Hello Poftut"
ENTRYPOINT – Run Single Command On Foreground
ENTRYPOINT
is used to set single command which will run on foreground when a container starts. For example if we want to run a web server as container we can set the web server daemon as ENTRYPOINT.
Syntax
ENTRYPOINT [COMMAND]
In this example we will start the httpd
command when a container start.
ENTRYPOINT /bin/httpd
ENV – Set Environment Variables In Key Value
ENV
command can be used in a Dockerfile in order to set related image environment variables like key value pairs. This can be used like a database or communication channel with the image.
Syntax
ENV [KEY] [VALUE]
In this example we will set the thread count which will be used by the daemon service as environment variable.
ENV THREADS 20
EXPOSE – Redirect Host Port To The Container Port
EXPOSE
is used to redirect container port to the local system port which it runs. For example if run web server in a container TCP port 80 and want to use local system port 80 we can use EXPOSE.
Syntax
EXPOSE [PORT]
In this example we will redirect port 8080 to the local system port.
EXPOSE 8080
FROM – Use Given Base Image
FROM
is used to set base image for the created image. This is very important command because it will create base image from an existing image like ubuntu
, centos
etc. Base image will be searched in the local system and Docker Hub.
Syntax
FROM [IMAGE NAME]
In this example we will use CentOS image from Docker Hub.
FROM centos
If we want we can also specify the version of the image like ubuntu18.10
etc.
FROM ubuntu18.10
MAINTAINER – Set Author Information or Image Metadata
MAINTAINER
is used to set information like author name, email etc. Simply we can set some informational data for the container. This information is like comment in programming languages.
Syntax
MAINTAINER [NAME]
In this example we will set the author email which is poftut@gmail.com
MAINTAINER poftut@gmail.com
RUN – Run Command During Image Build
During the build of the image we need to take some actions. These actions can be taken with the RUN
command. For example we can install a package with the apt
command for a ubuntu
image.
Syntax
RUN [COMMAND]
In this example we will install apache2
package and then remove cache files.
RUN apt update
RUN apt install apache2
RUN apt autoremove
USER – Set Username
The USER
directive can be used to set UID or username which is to run the image.
Syntax
USER [UID or USERNAME]
In this example we will set the user name as ismail
USER ismail
VOLUME – Mount Local System Directory In to Container
In some cases we may need to mount local system path or directory into the running container. We can use VOLUME
directive in order to mount local system path like /home/ismail
into the running container given path like /myhome
etc.
Syntax
VOLUME [LOCAL SYSTEM PATH] [CONTAINER PATH]
In this example we will mount local path /home/ismail
into container path /myhome
which will be created automatically.
VOLUME /home/ismail /myhome
WORKDIR – Change or Set Current Working Directory
As we can run commands during the build of image we may need also change working directory which can affect command execution. We will use WORKDIR
to change current working directory.
Syntax
WORKDIR [PATH]
In this example we will set /tmp
as the current working directory
WORKDIR /tmp