Day 1 Docker - Assignment

What is Docker?

Docker is a popular open-source platform for developing, deploying, and running applications. It uses containerization technology to create lightweight and portable containers that can run applications on any machine with the Docker platform installed, regardless of the operating system or hardware configuration.

Containers provide a way to package an application and its dependencies into a single bundle that can be easily deployed and managed. With Docker, developers can create, test, and deploy applications quickly and efficiently, without worrying about compatibility issues or complex deployment processes.

Docker provides a command-line interface and a web-based graphical user interface to manage containers, images, networks, and other resources. It also supports automation and orchestration tools like Docker Compose and Kubernetes to help manage complex deployments and scale applications.

Why We need docker?

There are several reasons why Docker has become an essential tool for modern software development and deployment:
Portability: Docker containers are portable and can run on any machine with Docker installed, regardless of the underlying operating system or hardware. This allows developers to create a consistent environment for their applications and easily move them between development, testing, and production environments.
Isolation: Docker provides a lightweight, isolated runtime environment for applications and their dependencies. This allows developers to avoid conflicts between different applications or between different versions of the same application.
Efficiency: Docker containers are lightweight and efficient, using fewer resources than traditional virtual machines. This allows developers to run more applications on the same hardware, reducing costs and improving performance.
Consistency: Docker provides a consistent environment for applications, ensuring that they behave the same way on different machines and in different environments. This reduces the risk of errors and makes it easier to troubleshoot issues.
Scalability: Docker makes it easy to scale applications up or down by adding or removing containers as needed. This allows developers to quickly respond to changes in demand and ensure that their applications can handle high traffic volumes.

Overall, Docker provides a flexible, efficient, and scalable platform for developing, deploying, and managing applications, making it an essential tool for modern software development.

What is Container?

A container is a lightweight and portable executable package that contains all the necessary software and dependencies needed to run an application. Containers provide a way to isolate an application and its dependencies from the host system and other applications, ensuring that they run consistently and predictably across different environments.

Containers are similar to virtual machines, but they are much more lightweight and efficient. Unlike virtual machines, which require a separate operating system and hardware resources for each instance, containers share the same host operating system and only require the resources needed to run the application.

Containers use a technology called containerization to provide this isolation and portability. Containerization uses kernel-level features of the operating system to create a separate, isolated environment for each container. This allows containers to run on any system with the necessary containerization technology installed, regardless of the underlying hardware or operating system.

Containers are commonly used for application deployment, allowing developers to package their applications and dependencies into a single container that can be easily deployed and managed. They are also used for testing, continuous integration and delivery, and other aspects of software development and deployment.

How Container Works?

Containers work by leveraging the operating system's built-in isolation features to create an isolated environment for an application to run in. Here's a high-level overview of how containers work:

1. Containerization technology creates an isolated environment on the host operating system, with its own file system, network, and process space.
2. A container image is created by bundling an application and its dependencies together in a self-contained package that can be run in the isolated container environment.
3. The container image is used to create a container instance, which is a running instance of the container environment.
4. When the container is started, the container runtime sets up the isolated environment and starts the application inside it.
5. The application runs in the container environment, isolated from the host system and other applications. Any changes made to the container environment or the application inside it are contained within the container and do not affect the host system or other containers.
6. The container can be stopped or restarted, and changes made to the container environment can be saved in a new container image for future use.

Overall, containers provide a lightweight, portable, and isolated runtime environment for applications, allowing them to run consistently and predictably across different environments.

How to install Docker?

The steps to install Docker may vary depending on your operating system. We can follow steps from below link to install docker on different OS.
https://www.devopsschool.com/blog/docker-installation-and-configurations/

What are the components docker?

Docker is composed of several components that work together to provide a complete platform for developing, deploying, and managing applications in containers. The main components of Docker are:

1. Docker Engine: This is the core component of Docker and provides the runtime environment for containers. It includes a daemon process that manages container lifecycle, storage, networking, and other system-level functions.
2. Docker Hub: This is the official repository of Docker images, where users can browse, download, and share container images. It also provides a registry service that allows users to store and share their own container images.
3. Docker CLI: This is the command-line interface for Docker and provides a way to interact with the Docker Engine and other Docker components. It allows users to create, start, stop, and manage containers, images, networks, and other Docker resources.
4. Docker Compose: This is a tool for defining and running multi-container Docker applications. It allows users to define a set of containers and their dependencies in a YAML file, and then start and stop them as a single unit.
5. Docker Swarm: This is Docker's native orchestration tool for managing clusters of Docker hosts. It allows users to create and manage a swarm of Docker nodes, deploy services across the swarm, and scale services up or down as needed.

Overall, these components work together to provide a comprehensive platform for developing, deploying, and managing containerized applications with Docker.

What is a container lifecycle commands?

Container lifecycle commands are a set of Docker CLI commands that allow users to manage the lifecycle of Docker containers. Here are some of the most common container lifecycle commands:

docker run: This command creates a new container from an image and starts it. It can be used to specify container options such as port mapping, environment variables, and container name.

docker run -it <Container name/ID> /bin/bash

docker start: This command starts an existing stopped container.

docker start <Container ID/Name>

docker stop: This command stops a running container.

docker stop <Container ID/Name>

docker restart: This command stops and then starts an existing container.

docker restart <Container ID/Name>

docker kill: This command sends a signal to a running container to force it to stop immediately.

docker kill <Container ID/Name>

docker rm: This command removes one or more stopped containers.

docker rm <Container ID/Name>

docker ps: This command lists the running containers on a Docker host.
docker logs: This command displays the logs of a running container.

docker logs <Container name/ID>

docker inspect: This command provides detailed information about a container, including its configuration, network settings, and environment variables.

docker inspect <Container name/ID>

docker exec: This command allows users to run a command inside a running container.

docker inspect <Container ID/Name>

docker pause: It stops all the processes running inside the container and freezes its state, so no further CPU or memory resources are consumed.

docker pause <Container ID/Name>

docker un-pause: It resumes the execution of its processes from where it was paused. This means that the container will continue to consume CPU and memory resources as before.

docker unpause <Container ID/Name>

Overall, these commands allow users to create, start, stop, restart, and manage containers throughout their lifecycle with Docker.

What is docker pause/unpuase?

Docker pause and unpause are commands used to temporarily stop and resume the execution of a Docker container, respectively.

When you pause a Docker container, it stops all the processes running inside the container and freezes its state, so no further CPU or memory resources are consumed. This can be useful in situations where you need to temporarily suspend a container's activities, but you don't want to stop or remove it completely.

On the other hand, when you unpause a Docker container, it resumes the execution of its processes from where it was paused. This means that the container will continue to consume CPU and memory resources as before.

To pause a running container, you can use the following command:
docker pause <container_name or container_id>
To unpause a paused container, you can use the following command:
docker unpause <container_name or container_id>

It's worth noting that not all containers can be paused or resumed. For example, containers that are running with the ‘—privileged’ flag or that have certain system capabilities might not support these commands. Additionally, if a container has been paused for an extended period, its internal state might have changed, so resuming it could lead to unexpected behavior.

What is docker stop/kill?

Docker stop and kill are commands used to stop and terminate the execution of a Docker container, respectively.

When you stop a Docker container, it sends a signal (SIGTERM) to the main process running inside the container, asking it to gracefully shut down. The container will then stop its processes in an orderly fashion, releasing any resources it has acquired, and finally terminate.

To stop a running container, you can use the following command:
docker stop <container_name or container_id>

If the container does not respond to the SIGTERM signal, Docker waits for a default timeout of 10 seconds before forcefully terminating it.

On the other hand, when you kill a Docker container, it sends a signal (SIGKILL) to the main process running inside the container, forcibly terminating it without giving it a chance to clean up.

To kill a running container, you can use the following command:
docker kill <container_name or container_id>

It's worth noting that when you use the kill command, you might lose any data that the container was processing or holding in memory, as the container's main process is abruptly terminated without any chance to perform any cleanup operations.

In summary, the stop command should be used when you want to gracefully shut down a container, while the kill command should be used when you want to forcibly terminate it.

How to get inside a container?

To get inside a container, you can use the docker exec command followed by the container ID or name and the shell command you want to execute. For example, if you have a container running with the name ‘my-container’, you can use the following command to access the shell inside the container:
docker exec -it my-container sh

The -it option stands for "interactive terminal" which allows you to interact with the shell inside the container.

Alternatively, you can also use the docker attach command to attach your terminal to a running container, which allows you to access the container's console. For example:
docker attach my-container

However, note that the docker attach command does not create a new shell instance, so it will attach to the primary process running inside the container. This means that if you exit the shell or stop the process, the container will also stop.

How to access container from outside?

To access a container from outside, you need to expose its ports to the host machine. When you expose a port, you're making it accessible to the outside world.

Here's an example of how to expose port 80 from a container running an HTTP server:
docker run -d -p 8080:80 my-http-server

This command starts a container running the my-http-server image and exposes its port 80 on the container as port 8080 on the host machine. You can then access the HTTP server by visiting http://localhost:8080 in your web browser.

Note that you can also specify the IP address of your host machine instead of localhost if you want to access the container from a remote machine.

You can also expose multiple ports by adding additional -p flags to the docker run command. For example, to expose ports 80 and 443 for an HTTPS server, you can use:
docker run -d -p 8080:80 -p 8443:443 my-https-server

In this example, port 80 on the container is exposed as port 8080 on the host machine, and port 443 on the container is exposed as port 8443 on the host machine.

What is the rule for container is running?

In Docker, a container is considered running if its primary process is still running. This means that if the process inside the container stops or crashes, the container is no longer considered running.

You can check the status of your containers by using the docker ps command, which shows a list of all running containers. The output of this command includes information such as the container ID, image name, container name, and the ports that are being exposed.

If you want to see all containers, including those that are not currently running, you can use the docker ps -a command.
This will show a list of all containers, whether they're running or not.

You can also use the docker container ls command as a shorthand for docker ps.

If you want to check the status of a specific container, you can use the docker inspect command, followed by the container ID or name. This will give you detailed information about the container, including its status, state, and configuration. For example, to inspect a container with the name my-container, you can use the following command:
docker inspect my-container
This will give you detailed information about the container, including its status and state.