Skip to content

Latest commit

 

History

History
362 lines (267 loc) · 10.2 KB

ch03.adoc

File metadata and controls

362 lines (267 loc) · 10.2 KB

Build a Docker Image

PURPOSE: This chapter explains how to create a Docker image.

As explained in [Docker_Basics], Docker image is the build component of Docker and a read-only template of application operating system.

Dockerfile

Docker build images by reading 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. docker build command uses this file and executes all the commands in succession to create an image.

build command is also passed a context that is used during image creation. This context can be a path on your local filesystem or a URL to a Git repository.

Dockerfile is usually called Dockerfile. The complete list of commands that can be specified in this file are explained at https://docs.docker.com/reference/builder/. The common commands are listed below:

Table 1. Common commands for Dockerfile
Command Purpose Example

FROM

First non-comment instruction in Dockerfile

FROM ubuntu

COPY

Copies mulitple source files from the context to the file system of the container at the specified path

COPY .bash_profile /home

ENV

Sets the environment variable

ENV HOSTNAME=test

RUN

Executes a command

RUN apt-get update

CMD

Defaults for an executing container

CMD ["/bin/echo", "hello world"]

EXPOSE

Informs the network ports that the container will listen on

EXPOSE 8093

Create your first Docker image

Create a new directory.

Create a new text file, name it Dockerfile, and use the following contents:

FROM ubuntu

CMD ["/bin/echo", "hello world"]

This image uses ubuntu as the base image. CMD command defines the command that needs to run. It provides a different entry point of /bin/echo and gives the argument “hello world”.

Build the image:

> docker build -t helloworld .
Sending build context to Docker daemon 2.048 kB
Step 0 : FROM ubuntu
Pulling repository docker.io/library/ubuntu
a5a467fddcb8: Download complete
3fd0c2ae8ed2: Download complete
9e19ac89d27c: Download complete
ac65c371c3a5: Download complete
Status: Downloaded newer image for ubuntu:latest
 ---> a5a467fddcb8
Step 1 : CMD /bin/echo hello world
 ---> Running in 132bb0bf823f
 ---> e81a394f71e3
Removing intermediate container 132bb0bf823f
Successfully built e81a394f71e3

. in this command is the context for docker build.

List the images available:

> docker images
REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
helloworld          latest              9c0e7b56cbee        13 minutes ago      187.9 MB

Run the container:

docker run helloworld

to see the output:

hello world

If you do not see the expected output, check your Dockerfile, build the image again, and now run it!

Change the base image from ubuntu to busybox in Dockerfile. Build the image again:

docker build -t helloworld2 .

and view the images using docker images command:

REPOSITORY          TAG                 IMAGE ID            CREATED             VIRTUAL SIZE
helloworld          latest              e81a394f71e3        26 minutes ago      187.9 MB
helloworld2         latest              c458787fadcf        3 seconds ago       1.113 MB
ubuntu              latest              a5a467fddcb8        2 days ago          187.9 MB
busybox             latest              3d5bcd78e074        4 days ago          1.113 MB

Note how base images for Ubuntu and Busybox are downloaded.

Create your first Docker image using Java

Create a simple Java application

Create a new Java project:

mvn archetype:generate -DgroupId=org.examples.java -DartifactId=helloworld -DinteractiveMode=false

Build the project:

cd helloworld
mvn package

Run the Java class:

java -cp target/helloworld-1.0-SNAPSHOT.jar org.examples.java.App

This shows the output:

Hello World!

Let’s package this application as a Docker image.

Java Docker image

Pull the latest Docker image for Java:

docker pull java

Run the container in an interactive manner:

docker run -it java

Check the version of Java:

root@44b355b45ab1:/# java -version
openjdk version "1.8.0_72-internal"
OpenJDK Runtime Environment (build 1.8.0_72-internal-b15)
OpenJDK 64-Bit Server VM (build 25.72-b15, mixed mode)

A different version may be seen in your case.

Package and Run Java application as Docker image

Create a new Dockerfile in helloworld directory:

FROM java

COPY target/helloworld-1.0-SNAPSHOT.jar /usr/src/helloworld-1.0-SNAPSHOT.jar

CMD java -cp /usr/src/helloworld-1.0-SNAPSHOT.jar org.examples.java.App

Build the image:

docker build -t hello-java .

Run the image:

docker run hello-java

This displays the output:

Hello World!

Package and Run Java Application using Docker Maven Plugin

Docker Maven Plugin allows you to manage Docker images and containers using Maven. It comes with predefined goals:

Goal Description

docker:build

Build images

docker:start

Create and start containers

docker:stop

Stop and destroy containers

docker:push

Push images to a registry

docker:remove

Remove images from local docker host

docker:logs

Show container logs

Create the Docker image:

cd docker-java-sample
mvn package -Pdocker

This will show an output like:

[INFO] DOCKER> [hello-java] : Built image sha256:09ab7

The list of images can be checked:

docker images | grep hello-java
hello-java          latest              09ab715ec59d        44 seconds ago      642.4 MB

Run the Docker container:

mvn install -Pdocker

This will show an output like:

[INFO] DOCKER> [hello-java] : Start container 11550a8dc086
[INFO] DOCKER> [hello-java] : Waited on log out 'Hello' 503 ms
[INFO]
[INFO] --- docker-maven-plugin:0.14.2:logs (docker:start) @ helloworld ---
11550a> Hello World!

This is similar output when running the container using docker run command.

Only one change was required in the project to enable Docker packaging and running. A Maven profile is added in pom.xml:

<profiles>
    <profile>
        <id>docker</id>
        <build>
            <plugins>
                <plugin>
                    <groupId>io.fabric8</groupId>
                    <artifactId>docker-maven-plugin</artifactId>
                    <version>0.14.2</version>
                    <configuration>
                        <images>
                            <image>
                                <name>hello-java</name>
                                <build>
                                    <from>java</from>
                                    <assembly>
                                        <descriptorRef>artifact</descriptorRef>
                                    </assembly>
                                    <cmd>java -cp maven/${project.name}-${project.version}.jar org.examples.java.App</cmd>
                                </build>
                                <run>
                                    <wait>
                                        <log>Hello</log>
                                    </wait>
                                </run>
                            </image>
                        </images>
                    </configuration>
                    <executions>
                        <execution>
                            <id>docker:build</id>
                            <phase>package</phase>
                            <goals>
                                <goal>build</goal>
                            </goals>
                        </execution>
                        <execution>
                            <id>docker:start</id>
                            <phase>install</phase>
                            <goals>
                                <goal>start</goal>
                                <goal>logs</goal>
                            </goals>
                        </execution>
                    </executions>
                </plugin>
            </plugins>
        </build>
    </profile>
</profiles>

Dockerfile Command Design Patterns

Difference between CMD and ENTRYPOINT

TL;DR CMD will work for most of the cases.

Default entry point for a container is /bin/sh, the default shell.

Running a container as docker run -it ubuntu uses that command and starts the default shell. The output is shown as:

> docker run -it ubuntu
root@88976ddee107:/#

ENTRYPOINT allows to override the entry point to some other command, and even customize it. For example, a container can be started as:

> docker run -it --entrypoint=/bin/cat ubuntu /etc/passwd
root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
sys:x:3:3:sys:/dev:/usr/sbin/nologin
. . .

This command overrides the entry point to the container to /bin/cat. The argument(s) passed to the CLI are used by the entry point.

Difference between ADD and COPY

TL;DR COPY will work for most of the cases.

ADD has all capabilities of COPY and has the following additional features:

  1. Allows tar file auto-extraction in the image, for example, ADD app.tar.gz /opt/var/myapp.

  2. Allows files to be downloaded from a remote URL. However, the downloaded files will become part of the image. This causes the image size to bloat. So its recommended to use curl or wget to download the archive explicitly, extract, and remove the archive.

Import and export images

Docker images can be saved using save command to a .tar file:

docker save helloworld > helloworld.tar

These tar files can then be imported using load command:

docker load -i helloworld.tar