Generic Top

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:


1. Overview

Docker is a tool for creating, deploying, and running applications easily. It allows us to package our applications with all the dependencies, and distribute them as individual bundles. Docker guarantees that our application will run in the same way on every Docker instance.

When we start using Docker, there are two main concepts we need to be clear on — images and containers.

In this tutorial, we'll learn what they are and how they differ.

2. Docker Images

An image is a file that represents a packaged application with all the dependencies needed to run correctly. In other words, we could say that a Docker image is like a Java class.

Images are built as a series of layers. Layers are assembled on top of one another. So, what is a layer? Simply put, a layer is an image.

Let's say we want to create a Docker image of a Hello World Java application. The first thing we need to think about is what does our application need.

To start, it is a Java application, so we will need a JVM. OK, this seems easy, but what does a JVM need to run? It needs an Operating System. Therefore, our Docker image will have an Operating System layer, a JVM, and our Hello World application.

A major advantage of Docker is its large community. If we want to build on to an image, we can go to Docker Hub and search if the image we need is available.

Let's say we want to create a database, using the PostgreSQL database. We don't need to create a new PostgreSQL image from scratch. We just go to Docker Hub, search for postgres, which is the Docker official image name for PostgresSQL, choose the version we need, and run it.

Every image we create or pull from Docker Hub is stored in our filesystem and is identified by its name and tag.  It can also be identified by its image id.

Using the docker images command, we can view a list of images we have available in our filesystem:

$ docker images
REPOSITORY           TAG                 IMAGE ID            CREATED             SIZE
postgres             11.6                d3d96b1e5d48        4 weeks ago         332MB
mongo                latest              9979235fc504        6 weeks ago         364MB
rabbitmq             3-management        44c4867e4a8b        8 weeks ago         180MB
mysql                8.0.18              d435eee2caa5        2 months ago        456MB
jboss/wildfly        18.0.1.Final        bfc71fe5d7d1        2 months ago        757MB
flyway/flyway        6.0.8               0c11020ffd69        3 months ago        247MB
java                 8-jre               e44d62cf8862        3 years ago         311MB

3. Running Docker Images

An image is run using the docker run command with the image name and tag. Let's say we want to run the postgres 11.6 image:

docker run -d postgres:11.6

Notice we provided the -d option. This tells Docker to run the image in the background — also known as the detached mode.

Using the docker ps command we can check if our image is running we should use this command:

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS              PORTS               NAMES
3376143f0991        postgres:11.6       "docker-entrypoint.s…"   3 minutes ago       Up 3 minutes        5432/tcp            tender_heyrovsky

Notice the CONTAINER ID in the output above. Let's take a look at what a container is and how it is related to an image.

4. Docker Containers

A container is an instance of an image. Each container can be identified by its ID. Going back to our Java development analogy, we could say that a container is like an instance of a class.

Docker defines seven states for a container: created, restarting, running, removing, paused, exited, and dead. This is important to know. Since a container is just an instance of the image, it doesn't need to be running.

Now let's think again about the run command we have seen above. We have said it is used to run images, but that is not totally accurate. The truth is that the run command is used to create and start a new container of the image.

One big advantage is that containers are like lightweight VMs. Their behaviors are completely isolated from each other. This means that we can run multiple containers of the same image, having each one in a different state with different data and different IDs.

Being able to run multiple containers of the same image at the same time is a great advantage because it allows us an easy way of scaling applications. For example, let's think about microservices. If every service is packaged as a Docker image, then that means that new services can be deployed as containers on demand.

5. Containers Lifecycle

Earlier, we mentioned the seven states of a container, Now, let's see how we can use the docker command-line tool to process the different lifecycle states.

Starting up a new container requires us to create it and then start it. This means that it has to go through the create state before it can be running. We can do this by creating and starting the container explicitly:

docker container create <image_name>:<tag>
docker container start <container_id>

Or we can easily do this with the run command:

docker run <image_name>:<tag>

We can pause a running container and then put it on running state again:

docker pause <container_id>
docker unpause <container_id>

A paused container will show “Paused” as the status when we check the processes:

$ docker ps
CONTAINER ID        IMAGE               COMMAND                  CREATED             STATUS                  PORTS               NAMES
9bef2edcad7b        postgres:11.6       "docker-entrypoint.s…"   5 minutes ago       Up 4 minutes (Paused)   5432/tcp            tender_heyrovsky

We can also stop a running container and then rerun it:

docker stop <container_id>
docker start <container_id>

And finally, we can remove a container:

docker container rm <container_id>

Only containers in the stopped or created state can be removed.

For more information regarding the Docker commands, we can refer to the Docker Command Line Reference.

6. Conclusion

In this article, we discussed Docker images and containers and how they differ. Images describe the applications and how they can be run. Containers are the image instances, where multiple containers of the same image can be run, each in a different state.

We have also talked about the containers' lifecycle and learned the basic commands to manage them.

Now that we know the basics, it's time to learn more about the exciting world of Docker and to start increasing our knowledge!

Generic bottom

Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

Generic footer banner
Comments are closed on this article!