Docker simplifies application deployments that should run in “lightweight virtual-machines” within isolated environments.
I shall briefly describe Docker, focused on its principles and how it may simplify the way we distribute our applications by using containers that package the application alongside its dependencies.
Docker in a Nutshell
Docker is a technology that simplifies the distribution of the applications running “inside” isolated containers, or rather at least conceptually.
Roughly speaking, we can consider containers as “lightweight virtual machines”. They offer a level of isolation for applications while sharing the underlying OS kernel. Therefore, they generally consume less computing resources than traditional virtual machines and are also quicker to spin up. However, there’s the flip side, which is the lower level of isolation, and that may or may not be an issue for your project.
Basic Concepts
Roughly speaking, a container is like an instance of an image, and an image is a recipe of how to build containers.
Images are “static”, while containers are “dynamic”. It’s conceptually similar to Object Oriented Programming, say an image is to a class what a container is to an object.
Interestingly, images are layered, that is, images are composed by aggregating of “check-points”. For every command that you put inside the image recipe, a layer is created. You can check out some past layer when necessary. For example, suppose that the first layer downloads an Ubuntu image, and the second downloads python3, should the download of python3 have failed then you won’t need to download Ubuntu again because its layer was already cached.
Docker Client
docker is the client which communicates with the Docker daemon (dockerd), responsible for executing commands on the client’s behalf.
The docker client offers a variety of commands, let’s try some of them.
To download the latest version of the Alpine OS image from the remote repository into your local cache:
docker pull alpine:latest
To verify all images that you have downloaded:
docker images
To run a container based on the downloaded alpine:latest
image in interactive-mode:
docker run -it alpine:latest
To list all containers that are running:
docker ps
To stop a given container (you have to replace $CONTAINER_ID
with the actual container Id obtained by docker ps
):
docker stop $CONTAINER_ID
Dockerfile
Now that we have seen some basic commands, let’s create an image?
First off, we need to write a Dockerfile, that is, a receipt that the docker will consume to create an image based on it.
A Dockerfile describes a sequence of commands, each with the following structure:
INSTRUCTION param1 param2 … paramN
Where INSTRUCTION
is a valid docker command that receives _param1_
, _param2_
, …, _paramN_
parameters.
Example
As an example, let’s create a fairly simple Linux image with the Alpine OS and Python3 installed, and then run a “Hello World” program written in Python when the container starts up.
Firstly, create a new directory, e.g. /opt/dockertest, and inside of it, add a file hello-docker.py with the following python script:
In the same directory, create a Dockerfile with this content:
In the Dockerfile, every command generates a new layer inside the image.
To build the image and give it the name alpine-python3-hello:
docker build -t alpine-python3-hello .
Docker will execute the commands and generate a new image that will be available to instantiate into containers:
docker run alpine-python3-hello
Finally, you should see the output “Hello World from Docker!” on the standard output.
Conclusion
We’ve discussed the basics of containers and how to use them with Docker, then, we saw some commands followed by an example of how to create an image.
Containers are becoming more and more popular in the software industry, for example, in cloud-based environments where there is a variety of tools emerging (Docker, Kubernetes etc).
I hope that with this quick introduction you should be able to start playing with Docker, or other container technology, in your projects and profit from it.
References
[1] https://docs.docker.com/get-started
[2] https://github.com/docker/labs
Originally published at https://medium.com/@rvarago