Docker - Containers

---

---

A Docker container is a runtime instance of a Docker image. They can be created by instantiating the image. Docker containers are completely changing software development, deployment, and management. In essence, Docker containers bundle an application along with all of its dependencies into a compact, light package. They can operate reliably in a range of computing environments by using virtualization at the operating system level.

This encapsulation is accomplished through the use of Docker images. Images are essentially blueprints that contain all the files, libraries, and configurations required to run a particular application. Since containers isolate the application and its dependencies from the underlying system, they offer consistency and predictability across a range of environments.

Docker Containers function as independent processes with their filesystem, network interface, and resources, but they are lightweight and efficient because they share the same kernel as the host operating system. They rely on key components of the Docker ecosystem to work, including the Docker Engine, which builds, launches, and manages containers, and the Docker Registry, which serves as a repository for Docker images.

In this chapter, let’s understand how containers work and the important Docker container commands that you will you most frequently.

Key Concepts of Docker Containers

Here are the key concepts and principles that work behind Docker Containers.

Containerization

Essentially, Containers function based on the concept of containerization, which is packing an application together with all of its dependencies into a single package. This package, referred to as a container image, includes all of the necessary runtime environments, libraries, and other components needed to run the application.

Isolation

Operating system-level virtualization is used by Docker containers to offer application isolation. With its filesystem, network interface, and process space, each container operates independently of the host system as a separate process.

By maintaining their independence from one another, containers are kept from interfering with one another's operations thanks to this isolation.

Docker Engine

The Docker Engine is the brains behind Docker containers; it builds, launches, and maintains them. The Docker daemon, which operates in the background, and the Docker client, which lets users communicate with the Docker daemon via commands, are two of the parts that make up the Docker Engine.

Image and Container Lifecycle

The creation of a container image is the first step in the lifecycle of a Docker container. A Dockerfile, which outlines the application's dependencies and configuration, is used to build this image.

The image can be used to instantiate containers, which are instances of the image that are running after it has been created. It is possible to start, stop, pause, and restart containers as one.

Resource Management

Docker containers provide effective resource management because of their shared kernel architecture and lightweight design. Since containers share the operating system kernel of the host system, overhead is decreased and startup times are accelerated.

To ensure maximum performance and scalability, Docker also offers tools for resource usage monitoring and control.

Portability

One of the main benefits of Docker containers is their portability. Container images are self-contained units that are easily deployable and distributed throughout various environments, ranging from production to testing and development.

This portability streamlines the deployment process and lowers the possibility of compatibility problems by enabling "build once, run anywhere".

Docker Container Lifecycle

There are five essential phases in the Docker container lifecycle: created, started, paused, exited, and dead. The lifecycle of a container is represented by its stages, which range from creation and execution to termination and possible recovery.

Comprehending these phases is crucial for proficiently overseeing Docker containers and guaranteeing their appropriate operation in a containerized setting.

Let's explore the stages of the Docker container lifecycle:

The Created State

The "created" state is the first stage. When a container is created with the docker create command or a comparable API call, it reaches this phase. The container is not yet running when it is in the "created" state, but it does exist as a static entity with all of its configuration settings defined.

At this point, Docker reserves the storage volumes and network interfaces that the container needs, but the processes inside the container have not yet begun.

The Started State

The "started" or "running" state is the next stage of the lifecycle. When a container is started with the docker start command or an equivalent API call, it enters this stage.

When a container is in the "started" state, its processes are launched and it starts running the service or application that is specified in its image. While they carry out their assigned tasks, containers in this state actively use CPU, memory, and other system resources.

The Paused State

Throughout their lifecycle, containers may also go into a "paused" state. When a container is paused with the docker pause command, its processes are suspended, thereby stopping its execution.

A container that is paused keeps its resource allotments and configuration settings but is not in use. This state helps with resource conservation and debugging by momentarily stopping container execution without completely stopping it.

The Exited State

A container in the "exited" state has finished executing and has left its primary process. Containers can enter this state when they finish the tasks they are intended to complete or when they run into errors that force them to terminate.

A container that has been "exited" stays stopped, keeping its resources and configuration settings but ceasing to run any processes. In this condition, containers can be completely deleted with the docker rm command or restarted with the docker start command.

The Dead State

A container that is in the "dead" state has either experienced an irreversible error or been abruptly terminated. Critical errors in the containerized application, problems with the host system underneath, or manual intervention can all cause containers to enter this state.

When a container is in the "dead" state, it is not in use and the Docker daemon usually releases or reclaims its resources. To free up system resources, containers in this state need to be deleted using the docker rm command since they cannot be restarted.

Important Docker Container Commands

Now that you have understood the basics of Docker Containers and how they work, let’s look at the most important Docker Container commands with the help of examples.

Listing all Docker Containers

The Docker host's running containers can be listed using the docker ps command. You can use the -a or --all flag to show all containers, including stopped ones, as it only shows running containers by default.

$ docker ps

This command displays the IDs, names, statuses, and other pertinent details of all containers that are currently running. It returns an empty list if no containers are in use.

Running a Docker Container

The primary command for starting and creating Docker containers is “docker run”. If the image isn't already available locally, Docker pulls it from a registry when you run this command. It then starts a fresh container instance by generating one based on that image.

With the help of this command, you can specify several options, including volume mounts, environment variables, port mappings, and more, to tailor the container's configuration to your requirements.

$ docker run -d -p 8080:80 nginx

In this case, the detached mode (-d) of the docker run creates a new container based on the "nginx" image and runs it in the background. Additionally, it maps host port 8080 to container port 80 (-p 8080:80), granting access to the NGINX web server housed within the container.

Stopping a Docker Container

A container can be gracefully stopped by using the docker stop command, which signals the container's main process with a SIGTERM. This enables the container to finish any cleanup operations - such as saving state or cutting off network connections before shutting down.

$ docker stop my_container

This command stops the "my_container" container that is currently operating. Docker waits for the container to gracefully end its life for a configurable duration (10 seconds by default). Docker will automatically terminate the container with a SIGKILL signal if it does not stop within this time limit.

Pausing a Running Container

A running container's processes can be momentarily suspended, or its execution paused, with the docker pause command. This can be helpful for temporarily freeing up system resources, debugging, and troubleshooting problems.

$ docker pause my_container

This command stops the container "my_container" from running. The container uses no CPU or memory when it is paused because its processes are frozen. The container does, however, keep its resource allocation and configuration settings.

Resuming a Docker Container

When a container is paused, its processes can be carried out again by using the docker unpause command. By using this command, the container returns to its initial state and undoes the effects of the docker pause command.

$ docker unpause my_container

The above command resumes the paused container "my_container's" execution and permits its processes to carry on as usual.

Restarting a Container

One easy way to quickly stop and restart an operating container is with the docker restart command. It is frequently used to force a container to reinitialize after experiencing problems or to apply changes to the configuration of a running container.

$ docker restart my_container 

This command pauses and then resumes the execution of the container with the name "my_container.". The processes inside the container are stopped and then restarted upon restarting, enabling any modifications to take effect.

Executing Commands in a Running Docker Container

To run a command inside an already-running container, use the docker exec command. It enables users to run arbitrary commands, like starting a shell session or carrying out a particular program, inside the environment of a container.

$ docker exec -it my_container bash 

This command opens the "my_container" container that is currently running in an interactive shell session (bash). In order to enable interactive input/output, the -it flags allocate a pseudo-TTY and maintain STDIN open even when it is not attached.

Removing a Docker Container

To remove a Docker container or containers, you can use the docker rm command. The container(s) whose ID or name you wish to remove can be specified. This command only removes stopped containers by default; to forcefully remove running containers, you can use the -f or --force flag.

$ docker rm my_container 

The above command deletes the container with the name "my_container.". Unless the -f flag is used to force removal, the container must stop running before being removed.

To clear up disk space on the Docker host, you can use the docker container prune command to remove all stopped containers. It is a practical method of clearing out empty containers and recovering resources.

$ docker container prune

Docker asks for confirmation before continuing, but you can ignore this prompt by passing it with the -f or –force flag.

If you want to remove all Docker containers together, you can use a chain two commands - “docker ps -aq” which is used to obtain a list of all container IDs and combine it with the “docker rm” command to remove all containers, including running containers.

$ docker rm $(docker ps -aq) 

The above command removes every container on the Docker host, regardless of whether it is running or stopped.

Conclusion

To sum up, Docker containers have completely changed how modern software development builds, deploys, and manages applications. Docker containers are lightweight and portable environments that offer many advantages, such as consistency, repeatability, resource efficiency, scalability, and portability, for packaging and running applications.

Using a range of Docker commands and tools, developers can easily create, deploy, and manage containers, facilitating more efficient development workflows and enhanced team collaboration. Docker containers are positioned to stay a key component of the software development ecosystem as containerization gains traction, helping businesses to innovate more quickly and provide value to clients more effectively.

FAQs

Q1. Is Docker a Container or a VM?

Docker is a platform for containerization, meaning it uses containers to run and package apps. Docker containers share the host's kernel and virtualize the operating system, in contrast to virtual machines (VMs), which virtualize hardware.

Because they do not need a separate operating system instance for each application, Docker containers are therefore more lightweight and efficient than virtual machines (VMs).

Q2. What is the difference between Docker and Kubernetes?

Although they have different uses, Docker and Kubernetes are both widely used tools in the container ecosystem. Docker offers tools for building container images and running containers locally or in production environments. It is mainly used for creating, managing, and executing containers.

The deployment, scaling, and management of containerized apps can be automated with Kubernetes, a platform for container orchestration. Docker concentrates on the containerization process itself, whereas Kubernetes manages container clusters and makes sure they are resilient, scalable, and available.

Q3. How do I run a Docker Container?

You can use the "docker run <image>" command to start a Docker container. You have to mention the ID or name of a Docker image that is available either locally or through a registry such as Docker Hub. Then, to create and launch a container from that image, use the docker run command followed by the image's name or ID. To further customize the container's configuration, you can optionally provide more parameters like port mappings, environment variables, and volume mounts.

Q4. What is a Docker Daemon?

The background process that oversees Docker containers on a host system is called the Docker daemon, or "dockerd". It is in charge of managing container images, networks, and volumes in addition to performing container lifecycle tasks including building, launching, stopping, and removing containers. To manage container resources, the Docker daemon interacts with the host operating system's kernel while listening for Docker API requests from the Docker client and executing them on the user's behalf.

Q5. What is the Lifespan of a Docker Container?

A Docker container's lifetime may differ based on its configuration, how it was made, and whether it is operating in attached or detached mode. A Docker container typically runs indefinitely unless its main process ends or the user manually stops or terminates it.

When containers are in detached mode (-d), they operate in the background until they are specifically stopped with the docker stop command or until the Docker daemon is restarted. Restart policies are another way to set up containers so that they will restart on their own in the event of a failure or stop.