Building Custom Images

Creating Docker Images

To create a docker image, following steps define the process:

• Create a Dockerfile. A Dockerfile is a plain text file with a few lines of configuration inside it. This configruration is going to define how the container behaves, what different programs it is going to contain and what it does when it starts as a container.

• The Dockerfile is then passed to the docker client.

• Next, the docker client will pass the file to the docker server. The docker server will use the Dockerfile to build a usable image.

The below diagram illustrates the above process:

Creating a Dockerfile has the following flow:

Building a Dockerfile

As an example, we will create a Dockerfile to create an image that runs redis-server. Following is the content of the Dockerfile we will use to create an image:

# Use an existing docker image as a base
FROM alpine

# Download an install dependencies
RUN apk add --update redis

# Tell the image what to do when it starts as a container
CMD ["redis-server"]

Next, from the directory where the Dockerfile is created, run the following command:

docker build .

The output of the command would look some thing like below:

[+] Building 9.8s (8/8) FINISHED                                                                                                                                                              
 => [internal] load build definition from Dockerfile                                                                                                                                     0.1s
 => => transferring dockerfile: 613B                                                                                                                                                     0.1s
 => [internal] load .dockerignore                                                                                                                                                        0.0s
 => => transferring context: 2B                                                                                                                                                          0.0s
 => [internal] load metadata for docker.io/library/alpine:latest                                                                                                                         4.8s
 => [auth] library/alpine:pull token for registry-1.docker.io                                                                                                                            0.0s
 => [1/3] FROM docker.io/library/alpine@sha256:686d8c9dfa6f3ccfc8230bc3178d23f84eeaf7e457f36f271ab1acc53015037c                                                                          0.6s
 => => resolve docker.io/library/alpine@sha256:686d8c9dfa6f3ccfc8230bc3178d23f84eeaf7e457f36f271ab1acc53015037c                                                                          0.0s
 => => sha256:686d8c9dfa6f3ccfc8230bc3178d23f84eeaf7e457f36f271ab1acc53015037c 1.64kB / 1.64kB                                                                                           0.0s
 => => sha256:c3c58223e2af75154c4a7852d6924b4cc51a00c821553bbd9b3319481131b2e0 528B / 528B                                                                                               0.0s
 => => sha256:6e30ab57aeeef1ebca8ac5a6ea05b5dd39d54990be94e7be18bb969a02d10a3f 1.49kB / 1.49kB                                                                                           0.0s
 => => sha256:b3c136eddcbf2003d3180787cef00f39d46b9fd9e4623178282ad6a8d63ad3b0 2.69MB / 2.69MB                                                                                           0.5s
 => => extracting sha256:b3c136eddcbf2003d3180787cef00f39d46b9fd9e4623178282ad6a8d63ad3b0                                                                                                0.1s
 => [2/3] RUN apk add --update redis                                                                                                                                                     1.5s
 => [3/3] RUN apk add --update gcc                                                                                                                                                       2.5s
 => exporting to image                                                                                                                                                                   0.2s 
 => => exporting layers                                                                                                                                                                  0.2s 
 => => writing image sha256:c5a737c182edf3e86517d93fff78126156a25373da067873642103e265933c90

Next, we use the id of the build image to create and start the container using docker run:

docker run c5a737c182edf3e86517d93fff78126156a25373da067873642103e265933c90

Dockerfile Details

Following is the flow of what docker build command does using the Dockerfile:

Tagging an Image

Rather than starting and running a container using a id, we can tag an image during the build process with a name. Following is how it can be done:

The convention from tagging an image with a name is as follows:

So, the flow of commands for building an image with a tag name and running a container from the built image goes like below:

docker build -t amanalok/redis:latest .
docker run amanalok/redis

Image Generation with Docker Commit

Till now, we created and started a container using a docker image. We can also go the other way and create a docker image using a running container.

Following is an example how to go about image generation using a running container:

docker run -it alpine sh
/ # apk add --update redis

As can be observed above, we started a container using an alpine image and installed redis inside the container. Next, we get the id of this running container and use it to generate an image from it.

docker ps
CONTAINER ID   IMAGE     COMMAND   CREATED              STATUS              PORTS     NAMES
5641b2fb1c27   alpine    "sh"      About a minute ago   Up About a minute             thirsty_hodgkin

docker commit -c 'CMD ["redis-server"]' 5641b2fb1c27
sha256:fe47718978513557c7d7fd9a3f27ba4e937a4e2cb1d9fb1f2dc8f7472ce5a6a2

Finally, using the id of the generated image, we can run a new container:

docker run fe47718978513557c7d7fd9a3f27ba4e937a4e2cb1d9fb1f2dc8f7472ce5a6a2