Starting Docker Journey — Part1

We will start by first looking at why do we need Docker, what are the challenges being faced earlier before Docker came into existence and so on..

After that, we will move on to learning some Docker in detail.

1. World Before Docker

Let’s take an example of how a development environment used to be setup earlier before docker. On a very high level, the below steps are needed while setting up any env:

1. A virtual machine with its own OS (Guest OS)

* For those VMs, Create Users, profiles..

2. Install required Software

* Web Servers, Databases…

* Create required Database users..

3. Deploy Application

* Configure application properties

— — — — — — — — — — — — — — — — — — — — — — — — — — — — — —

Now, let’s see the issue in this environment setup system:

1. Compatibility of applications/software with the underlying OS
2. Compatibility between services and libraries and dependencies
3. Long setup time for the environment on each machine
4. Different Dev/QA envs

This compatibility matrix issue is usually referred as MATRIX FROM HELL

So, this made developing, building and shipping the product quite difficult.

2. Virtual Machines

Let’s take an another example of how VMs usually setup.

Usually VMs has their own Guest OS, and each VM is being hosted on some Host OS.

Consider the below image. Here we can see, we have a system with a HOST OS having an underlying hardware to support the OS.

Now on top of that HOST OS, there is a layer called HyperVisor, which basically support running Guest OS(Virtual Machines) on the Host OS.

And on top of Hypervisor, we are having various VMS, each VM having its own Guest OS.

VM Architecture

Advantages of these VMs:

1. These VMS run in isolation, thus one VM does not impact any other VM
2. Each

Disadvantages of these VMS:

1. Resource Utilisation: CPU, RAM, Disk consumed by Guest OS
2. Performance Overhead: Multiple OS + Hypervisor Transition Layer
3. Cost Overhead: Software License (Guest OS) (capex) and VM Maintenance Cost (opex)

3. Container Engine

So in last section, we saw some drawbacks of VMs. Almost all those drawbacks can be removed, if just remove the Guest OS from the picture.

Docker Containers exactly does this. Unlike HyperVisor layer in case of Guest/Host VM mechanism, here we have a Container Engine on Top of host OS.

Containers are light-weight and work without any Guest OS. All the applications/softwares can be installed within a container, and they use the underlying Host OS and hardware to run

Container Architecture

4. Starting with Docker

Docker is an open platform for developing, shipping, and running applications.

Docker is available in two editions:

• Community Edition (CE)
• Enterprise Edition (EE)

Docker Containers Are Everywhere today : Linux, Windows, Data center, Cloud, Serverless, etc.

5. Docker Architecture

• Docker uses a client-server architecture.
• The Docker client talks to the Docker daemon, which does all the work of building, running, and distributing Docker containers.
• The Docker client and daemon communicate using a REST API, hence Docker client and daemon can run either on the same system, or you can connect a Docker client to a remote Docker daemon.

5.1 — Docker daemon

• The Docker daemon (dockerd) listens for Docker API requests and manages Docker objects such as images, containers, networks, and volumes.
• A daemon can also communicate with other daemons to manage Docker services.

5.2 — The Docker client

• The Docker client (docker) is the primary way that many Docker users interact with Docker.
• When you use commands such as docker run, the client sends these commands to dockerd, which carries them out.
• The docker command uses the Docker API. The Docker client can communicate with more than one daemon.

5.3 — Docker Desktop

• Docker Desktop is an easy-to-install application for your Mac or Windows environment that enables you to build and share containerized applications and microservices.
• Docker Desktop includes the Docker daemon (dockerd), the Docker client (docker), Docker Compose, Docker Content Trust, Kubernetes, and Credential Helper.

5.4 — Docker registries

• A Docker registry stores Docker images. Docker Hub is a public registry that anyone can use, and Docker is configured to look for images on Docker Hub by default.
• You can even run your own private registry.
• When you use the docker pull or docker run commands, the required images are pulled from your configured registry.
• When you use the docker push command, your image is pushed to your configured registry.

5.5 — Docker objects

When you use Docker, you are creating and using images, containers, networks, volumes, plugins, and other objects. This section is a brief overview of some of those objects.

5.5.1 Images

• An image is a read-only template with instructions for creating a Docker container.
• Often, an image is based on another image, with some additional customization. For example, you may build an image that is based on the ubuntu image, but installs the Apache web server
• To build your own image, you create a Dockerfile with a simple syntax for defining the steps needed to create the image and run it.

5.5.2 Containers

• A container is a runnable instance of an image.
• You can create, start, stop, move, or delete a container using the Docker API or CLI.
• A container is defined by its image as well as any configuration options you provide to it when you create or start it.
• When a container is removed, any changes to its state that are not stored in persistent storage disappear.

Example docker run command

The following command runs a ubuntu container, attaches interactively to your local command-line session, and runs /bin/bash.

$ docker run -i -t ubuntu /bin/bash

When you run this command, the following happens:

1. If you do not have the ubuntu image locally, Docker pulls it from your configured registry, as though you had run docker pull ubuntu manually.
2. Docker creates a new container, as though you had run a docker container create command manually.
3. Docker allocates a read-write filesystem to the container, as its final layer. This allows a running container to create or modify files and directories in its local filesystem.
4. Docker creates a network interface to connect the container to the default network, since you did not specify any networking options. This includes assigning an IP address to the container. By default, containers can connect to external networks using the host machine’s network connection.
5. Docker starts the container and executes /bin/bash. Because the container is running interactively and attached to your terminal (due to the -i and -t flags), you can provide input using your keyboard while the output is logged to your terminal.
6. When you type exit to terminate the /bin/bash command, the container stops but is not removed. You can start it again or remove it.

There is much more to docker, and in next part, I will cover Docker commands, Docker compose, Docker images, Docker Networking, and so on...

I hope you enjoyed reading this article, as much as I enjoyed writing it. If you like this article please let me know! But, more importantly if you disagree with this article please, please, please let me know! I made this with the hope of helping the community so if it is off it defeats the purpose! If you have a suggestion or critique please feel free to drop in any comments.