Docker
can build images automatically by reading the instructions from a Dockerfile. A
Dockerfile is a text document that contains all the commands a user could call
on the command line to assemble an image. Using docker build users can create
an automated build that executes several command-line instructions in
succession.
Now
its time to understand about the docker engine and docker daemon.
Docker
Engine.
Docker engine or Docker is a client server application that
builds and executes containers using Docker components. REST API is a primary
mode of communication between Docker Client and Docker Daemon.
Docker Daemon.
Docker Daemon is a
server which interacts with the operating system and performs all kind of
services. The Docker Daemon listens for REST API request and performs the
operation. A command dockerd is used to start a Docker Daemon. Docker Host runs
the Docker Daemon and Registry.
Docker Daemon checks the client request and
communicates with the Docker components in order to perform a service whereas,
Docker Engine or Docker is the base engine installed on your host machine to
build and run containers using Docker components and services.
Environment
variables are supported by the following list of instructions in the Dockerfile:
COPY
The COPY instruction copies new files or
directories from <src> and adds them to the filesystem of the container
at the path <dest>.
Multiple <src> resources may be specified
but the paths of files and directories will be interpreted as relative to the
source of the context of the build.
Each <src> may contain wildcards and
matching will be done using Go’s filepath.Match rules. For example:
COPY test.txt relativeDir/
ADD
The ADD instruction copies new files,
directories or remote file URLs from <src> and adds them to the filesystem
of the image at the path <dest>.
Multiple <src> resources may be specified
but if they are files or directories, their paths are interpreted as relative
to the source of the context of the build.
Each <src> may contain wildcards and
matching will be done using Go’s filepath.Match rules
eg: To add all the files starting with
"sye"
ADD sye* /mydir/
CMD
The main purpose of a CMD is to provide
defaults for an executing container. These defaults can include an executable,
or they can omit the executable, in which case you must specify an ENTRYPOINT
instruction as well.
If CMD is used to provide default arguments for
the ENTRYPOINT instruction, both the CMD and ENTRYPOINT instructions should be
specified with the JSON array format.
eg:
FROM ubuntu
CMD echo "This is a test." | wc -
ENTRYPOINT
An ENTRYPOINT allows you to configure a
container that will run as an executable.
eg:
ENTRYPOINT
["java","-jar","/app.jar"]
ENV
The ENV instruction sets the environment
variable <key> to the value <value>. This value will be in the
environment for all subsequent instructions in the build stage and can be
replaced inline in many as well.
eg:
ENV myName="Syed Ghouse"
EXPOSE
The EXPOSE instruction informs Docker that the
container listens on the specified network ports at runtime. You can specify
whether the port listens on TCP or UDP, and the default is TCP if the protocol
is not specified.
The EXPOSE instruction does not actually
publish the port. It functions as a type of documentation between the person
who builds the image and the person who runs the container, about which ports
are intended to be published. To actually publish the port when running the
container, use the -p flag on docker run to publish and map one or more ports,
or the -P flag to publish all exposed ports and map them to high-order ports.
eg:
EXPOSE 80/udp
FROM
The FROM instruction initializes a new build
stage and sets the Base Image for subsequent instructions. As such, a valid
Dockerfile must start with a FROM instruction. The image can be any valid image
– it is especially easy to start by pulling an image from the Public
Repositories.
eg:FROM openjdk:8-jdk-alpine
FROM instructions support variables that are
declared by any ARG instructions that occur before the first FROM
An ARG declared before a FROM is outside of a
build stage, so it can’t be used in any instruction after a FROM. To use the
default value of an ARG declared before the first FROM use an ARG instruction
without a value inside of a build stage:
eg:
ARG VERSION=latest
FROM busybox:$VERSION
ARG VERSION
RUN echo $VERSION > image_version
MAINTAINER
The MAINTAINER instruction sets the Author
field of the generated images. The LABEL instruction is a much more flexible
version of this and you should use it instead, as it enables setting any
metadata you require, and can be viewed easily, for example with docker
inspect. To set a label corresponding to the MAINTAINER field you could use
eg: LABEL
maintainer="syedghouse14@gmail.com"
RUN
The RUN instruction will execute any commands
in a new layer on top of the current image and commit the results. The
resulting committed image will be used for the next step in the Dockerfile.
eg:
RUN ["/bin/bash", "-c",
"echo hello"]
USER sets the UID (or username) which is to run the
container.
VOLUME is used to enable access from the container to
a directory on the host machine.
WORKDIR sets the path where the
command, defined with CMD, is to be executed.
LABEL
The LABEL instruction adds metadata to an
image. A LABEL is a key-value pair. To include spaces within a LABEL value, use
quotes and backslashes as you would in command-line parsing.
eg: LABEL version="1.0"
