6.

CONTAINERIZATION USING DOCKER

Docker Interview Question & Answers

Docker interview question and answers for

BEGINER LEVEL
1. What is Docker?
Docker is an open-source platform that allows you to automate the
deployment and management of applications using containerization. It
provides an isolated environment called a container that contains all the
necessary dependencies to run an application.

2. What is a container?
A container is a lightweight and isolated runtime environment that
encapsulates an application and its dependencies. It provides a consistent
and reproducible environment, ensuring that the application behaves the
same way across different systems.

3. What are the benefits of using Docker?

- Portability: Docker containers can run on any system that supports
Docker, making it easy to deploy applications across different
environments.
- Scalability: Docker allows you to scale your application horizontally by
running multiple containers on different hosts.
- Isolation: Containers provide isolation between applications and their
dependencies, preventing conflicts and ensuring consistent behavior.
- Efficiency: Docker uses a layered file system and shared resources,
enabling faster startup times and efficient resource utilization.
- Version control: Docker enables versioning of containers, allowing you
to roll back to previous versions if needed.

4. How does Docker differ from virtual machines?

Docker containers and virtual machines (VMs) both provide isolation, but
they work differently. VMs emulate an entire operating system, running
multiple instances on a hypervisor, while Docker containers share the host
system's kernel and only isolate the application and its dependencies.
VMs are typically larger in size and slower to start, while Docker
containers are lightweight and start quickly. Docker also provides better
resource utilization since it shares the host's kernel and uses a layered file
system.

5. What is a Docker image?

A Docker image is a read-only template that contains the necessary files,
dependencies, and instructions to create a Docker container. It is built
based on a Dockerfile, which specifies the steps to create the image.

6. What is a Dockerfile?
A Dockerfile is a text file that contains a set of instructions to build a
Docker image. It specifies the base image, the application's dependencies,
environment variables, and other configurations needed to create the
image.
7. How do you create a Docker container from an image?
To create a Docker container from an image, you use the `docker run`
command followed by the image name. For example:
```
docker run image_name
```
This command will start a new container based on the specified image.

8. How do you share data between a Docker container and the host
system?
You can share data between a Docker container and the host system using
Docker volumes or bind mounts. Docker volumes are managed by Docker
and are stored in a specific location on the host system. Bind mounts, on
the other hand, allow you to mount a directory or file from the host system
into the container.

9. How can you link multiple Docker containers together?

Docker provides a feature called container networking, which allows you
to link multiple containers together. You can create a user-defined network
using the `docker network create` command and then connect containers to
that network using the `--network` option when running containers.
Alternatively, you can use Docker Compose, a tool for defining and
running multi-container Docker applications. Compose uses a YAML file
to define the services and their relationships, making it easier to manage
multiple containers.
10. How can you troubleshoot issues with Docker containers?
Some common troubleshooting steps for Docker containers are:
- Checking the container logs using the `docker logs` command.
- Inspecting the container's metadata and configurations using `docker
inspect`.
- Accessing the container's shell using `docker exec -it <container_id>
/bin/bash` to investigate the container's internal state.
- Verifying that the necessary ports are exposed and reachable.
- Checking resource utilization on the
host system to ensure it has enough capacity.
Remember to tailor your answers based on your understanding and
experience with Docker. Good luck with your interview!
Docker interview question and answers for
INTERMEDIATE LEVEL
1. Explain the concept of Docker Compose.
Docker Compose is a tool that allows you to define and manage multi-
container Docker applications. It uses a YAML file to define the services,
their configurations, and the relationships between them. Compose
simplifies the process of running multiple containers together, enabling
easier orchestration and management of complex applications.

2. What is the difference between Docker Compose and Docker

Swarm?
Docker Compose and Docker Swarm are both tools for managing Docker
containers, but they serve different purposes. Docker Compose is used for
defining and running multi-container applications on a single host. It
focuses on the development and testing environments.
Docker Swarm, on the other hand, is a native clustering and orchestration
tool provided by Docker. It allows you to create and manage a swarm of
Docker nodes (hosts) to deploy and scale services across multiple
machines. Swarm is more suitable for production environments and
provides features like service discovery, load balancing, and high
availability.

3. How can you scale Docker containers in Docker Swarm?

In Docker Swarm, you can scale your services by changing the replica
count. The replica count represents the number of instances (containers)
running for a particular service. You can use the following command to
scale a service:
```
docker service scale <service_name>=<replica_count>
```
For example, to scale a service named "web" to have three replicas:
```
docker service scale web=3
```

4. What is Docker Registry and why is it used?

Docker Registry is a service for storing and distributing Docker images. It
serves as a centralized repository for Docker images that can be shared
across multiple hosts. The default Docker Registry is Docker Hub
(hub.docker.com), but you can also set up a private registry.
Docker Registry allows you to push and pull images, making it easier to
share and distribute containerized applications. It plays a crucial role in
enabling collaboration and seamless deployment of Docker containers.

5. Explain the concept of Docker volumes and their importance.

Docker volumes are a way to persist and manage data associated with
Docker containers. A volume is a directory stored outside the container's
filesystem, which can be shared and reused by multiple containers.
Volumes are separate from the container lifecycle, meaning the data
remains intact even if the container is stopped or deleted.
Docker volumes are important because they enable data persistence and
sharing between containers. They allow you to decouple data from the
container itself, making it easier to manage and maintain applications that
require persistent storage.

6. What are Docker labels and how are they used?

Docker labels are key-value metadata pairs that can be applied to Docker
objects like containers, images, and volumes. They provide a way to attach
custom metadata to these objects, making it easier to categorize and
manage them.
Labels are commonly used for organizing and annotating containers or
images based on their characteristics, such as version, environment, or
purpose. They can be utilized for filtering, searching, and implementing
custom automation or tooling around Docker resources.

7. How can you pass environment variables to a Docker container?

You can pass environment variables to a Docker container using the `-e` or
`--env` flag when running the container with the `docker run` command.
For example:
```
docker run -e VARIABLE_NAME=value image_name
```
Alternatively, you can define environment variables in a Docker Compose
file using the `environment` key under a service definition.

8. Explain the concept of Docker overlay network.

Docker overlay network is a built-in network driver that allows
communication between Docker services running on different Docker
nodes in a swarm. It facilitates multi-host networking for containerized
applications. Overlay networks provide automatic service discovery, load
balancing,
and secure communication between containers across different hosts.
Overlay networks are created using the `docker network create` command
with the `--driver overlay` option. They enable seamless communication
and cooperation between services running on different nodes within a
Docker swarm.

9. How can you secure Docker containers?

To secure Docker containers, you can implement the following best
practices:
- Regularly update Docker and container images to include security
patches.
- Use minimal and trusted base images to reduce the attack surface.
- Apply the principle of least privilege by running containers with
restricted user permissions.
- Isolate containers by running them in separate networks and using
appropriate network segmentation.
- Implement resource constraints to prevent containers from monopolizing
system resources.
- Limit container capabilities and restrict access to sensitive host
directories.
- Monitor container activity, log output, and implement centralized
logging.
- Apply container runtime security tools and scan images for
vulnerabilities before deployment.
10. How can you monitor Docker containers?
There are several ways to monitor Docker containers:
- Use the `docker stats` command to view real-time resource usage
statistics for running containers.
- Implement a container orchestration tool like Docker Swarm or
Kubernetes, which provide built-in monitoring capabilities.
- Utilize third-party monitoring tools specifically designed for Docker
container monitoring, such as Prometheus, cAdvisor, or Datadog.
- Implement centralized logging by collecting and analyzing container logs
using tools like ELK Stack (Elasticsearch, Logstash, Kibana) or Splunk.

Docker interview question and answers for

ADVANCED LEVEL
1. What is Docker orchestration, and why is it important?
Docker orchestration is the process of managing and coordinating multiple
Docker containers to work together as a distributed application. It involves
tasks such as container deployment, scaling, load balancing, service
discovery, and high availability.
Orchestration is important because it enables the deployment and
management of complex, multi-container applications at scale. It
automates tasks that would be cumbersome and error-prone to perform
manually, and it ensures that containers are deployed consistently and
reliably across different hosts or a cluster of nodes.

2. Explain the role of container registries in a containerized

environment.
Container registries play a crucial role in a containerized environment.
They serve as repositories for storing and distributing Docker images. A
container registry allows users to push their custom-built images and pull
images from other sources.
Registries provide a central location for teams to collaborate and share
container images. They facilitate version control, enable easy deployment
across different environments, and promote reusability of images. Popular
container registries include Docker Hub, Amazon ECR, Google Container
Registry, and private registries like Harbor.

3. How does Docker Swarm handle service discovery and load

balancing?
Docker Swarm provides built-in service discovery and load balancing
capabilities. When you deploy services to a Swarm cluster, each service is
assigned a unique DNS name that other services can use to communicate.
Swarm load balances incoming requests across all the available replicas of
a service. It distributes traffic evenly based on the configured load
balancing strategy, such as round-robin or source IP affinity. Load
balancing ensures that requests are evenly distributed among the
containers running the service, improving performance and availability.

4. What are the benefits of using Docker secrets?

Docker secrets are a secure way to manage sensitive data, such as
passwords, API keys, or certificates, within Docker containers. The
benefits of using Docker secrets include:
- Enhanced security: Secrets are encrypted and only accessible to
containers that have explicit access to them, reducing the risk of exposure.
- Easy management: Secrets can be managed using the Docker CLI or
Docker API, making it convenient to create, update, and rotate secrets.
- Integration with orchestration tools: Orchestration tools like Docker
Swarm can automatically distribute secrets to the appropriate containers,
simplifying the management of sensitive information in a distributed
environment.

5. How does Docker handle container networking across multiple

hosts?
Docker provides various networking options for container communication
across multiple hosts:
- Docker Overlay Network: Docker Swarm uses overlay networks to
create a virtual network that spans multiple Docker hosts. It allows
containers running on different hosts to communicate securely.
- Docker Bridge Network: By default, Docker creates a bridge network for
containers on a single host. To enable container communication across
hosts, you can use the `--driver=bridge` option when creating the network
and configure the necessary routing.
- External Network: Docker containers can also connect to external
networks using the `--network=host` option. This allows the containers to
share the host's network stack, enabling direct communication with the
host's network interfaces.

6. How can you achieve zero-downtime deployments in Docker?

To achieve zero-downtime deployments in Docker, you can use strategies
like rolling updates and blue-green deployments:
- Rolling Updates: In a rolling update, you gradually update the containers
in a service one by one, while the other containers continue serving
requests. This ensures that the service remains available during the update
process.
- Blue-Green Deployments: In a blue-green deployment, you have two
identical environments, one active (blue) and one inactive (green). You
update the inactive environment with the new version of the application,
perform any necessary tests, and then switch the traffic from the active
environment to
the updated one. This approach eliminates downtime as the switch
happens instantaneously.

7. What is Docker content trust, and how does it enhance security?

Docker Content Trust is a security feature that allows you to verify the
authenticity and integrity of Docker images. It uses digital signatures and
cryptographic verification to ensure that only trusted images are used in
your environment.
When Docker Content Trust is enabled, Docker only allows the use of
signed images. Images must be signed by trusted entities and the
signatures must match the content of the image. This prevents the use of
unauthorized or tampered images, reducing the risk of running
compromised containers in your infrastructure.

8. Explain the concept of multi-stage builds in Docker.

Multi-stage builds in Docker allow you to optimize the size and efficiency
of your Docker images. With multi-stage builds, you can separate the build
environment from the runtime environment, resulting in smaller and more
secure final images.
In a multi-stage build, you define multiple stages in your Dockerfile. Each
stage can have its own base image, dependencies, and build instructions.
The final stage includes only the necessary artifacts from the earlier stages,
discarding any unnecessary build tools or intermediate files. This helps to
reduce the image size and improve runtime performance.

9. How can you secure communication between Docker containers?

To secure communication between Docker containers, you can implement
the following practices:
- Use secure network protocols like HTTPS or TLS for communication
between containers.
- Implement network segmentation and firewall rules to restrict access
between containers.
- Encrypt sensitive data at rest and in transit using tools like OpenSSL or
Let's Encrypt certificates.
- Utilize container network security solutions, such as Docker Secrets, to
securely manage and distribute sensitive information.
- Regularly update and patch containers and their underlying host systems
to address any security vulnerabilities.

10. What are the challenges of running stateful applications in Docker

containers?
Running stateful applications in Docker containers presents some
challenges due to the ephemeral nature of containers. Key challenges
include:
- Data persistence: Containers are designed to be stateless, so managing
data persistence and durability requires using Docker volumes or external
storage solutions.
- Scalability: Scaling stateful applications horizontally across multiple
containers can be complex due to shared data dependencies and potential
data consistency issues.
- Backup and recovery: Ensuring proper backup and recovery mechanisms
for stateful data within containers can be more challenging than with
traditional infrastructure.
- State synchronization: Coordinating state synchronization between
multiple containers running the same stateful application can introduce
complexities and overhead.

Docker interview question and answers SCENARIO

BASED
Scenario 1:
You have a microservices-based application that consists of multiple
services, and you need to deploy and manage them using Docker. How
would you approach this?
Answer:
For deploying and managing a microservices-based application using
Docker, I would follow these steps:
1. Containerize each microservice: I would create a Dockerfile for each
microservice, specifying the necessary dependencies, configurations, and
build instructions.
2. Build Docker images: Using the Dockerfiles, I would build Docker
images for each microservice using the `docker build` command. This
would generate separate images for each microservice.
3. Set up a Docker orchestration tool: I would choose a Docker
orchestration tool like Docker Swarm or Kubernetes to manage the
deployment, scaling, and high availability of the microservices.
4. Define the deployment configuration: Using the chosen orchestration
tool, I would create a configuration file (e.g., Docker Compose file or
Kubernetes manifest) that defines the services, their dependencies,
network configuration, and resource requirements.
5. Deploy the microservices: I would use the orchestration tool to deploy
the microservices by running the configuration file. This would start the
containers based on the defined images and ensure that they are running
and accessible.
6. Implement service discovery and load balancing: I would configure the
orchestration tool to provide service discovery and load balancing
capabilities. This would enable seamless communication between the
microservices and distribute incoming requests across multiple instances.
7. Monitor and scale: I would set up monitoring and logging tools to track
the health and performance of the microservices. If needed, I would scale
the services horizontally by increasing the number of replicas to handle
higher traffic or improve performance.

Scenario 2:
You are working on a project that requires running multiple
containers with different versions of the same software. How would
you manage this situation effectively?
Answer:
To manage multiple containers with different software versions
effectively, I would use Docker features like image tagging, container
naming, and version control.
1. Tagging Docker images: When building Docker images, I would use
version-specific tags to differentiate between different software versions.
For example, I would tag an image as `software:v1.0`, `software:v1.1`, and
so on.
2. Container naming: When running containers, I would assign unique
names to each container using the `--name` option. This helps in
identifying and managing containers with different versions.
3. Version control of Dockerfiles: I would maintain version control for
Dockerfiles using a version control system like Git. This allows me to
track changes made to Dockerfiles and easily switch between different
versions when building images.
4. Managing container instances: Using Docker orchestration tools like
Docker Swarm or Kubernetes, I would define and manage separate
services or deployments for each software version. This ensures that
containers with different versions are isolated and can be managed
independently.
5. Monitoring and logging: I would set up monitoring and logging tools to
keep track of the performance, health, and logs of containers with different
versions. This helps in identifying any issues specific to certain versions
and facilitates troubleshooting.
6. Testing and rollout: Before deploying new versions, I would thoroughly
test them in a staging environment to ensure compatibility and stability.
Once validated, I would roll out the new versions gradually, monitoring
their behavior and addressing any issues that may arise.
By following these steps, I can effectively manage multiple containers
with different versions of the same software, ensuring isolation, version
control, and streamlined deployment processes.
Certainly! Here are a few more scenario-based Docker interview questions
and answers:

Scenario 3:
You have a legacy application that requires specific configurations
and dependencies to run. How would you containerize and deploy this
application using Docker?
Answer:
To containerize and deploy a legacy application with specific
configurations and dependencies using Docker, I would follow these steps:
1. Identify application requirements: Analyze the legacy application to
understand its specific configurations, dependencies, and any external
services it requires.
2. Create a Dockerfile: Based on the application requirements, create a
Dockerfile that includes the necessary steps to install dependencies,
configure the application, and expose any required ports.
3. Build a Docker image: Use the Dockerfile to build a Docker image that
encapsulates the legacy application and its dependencies. This can be done
using the `docker build` command.
4. Test the Docker image: Run the Docker image as a container to ensure
that the legacy application functions correctly within the containerized
environment. Perform thorough testing to verify its behavior and
compatibility.
5. Store configuration externally: If the legacy application requires specific
configurations, consider storing them externally, such as using
environment variables or mounting configuration files as volumes during
container runtime.
6. Deploy the Docker container: Use a container orchestration tool like
Docker Swarm or Kubernetes to deploy the Docker container. Define the
necessary environment variables, network configuration, and any required
volume mounts during deployment.
7. Monitor and manage the container: Set up monitoring and logging for
the deployed container to track its performance and troubleshoot any
issues. Regularly maintain and update the Docker image as needed to
ensure security and compatibility.
By following these steps, you can successfully containerize and deploy a
legacy application, ensuring that it runs with the required configurations
and dependencies while benefiting from the advantages of Docker.

Scenario 4:
You need to deploy a multi-container application with interdependent
services that communicate with each other. How would you set up
networking and communication between these containers in Docker?
Answer:
To set up networking and communication between interdependent
containers in Docker, I would follow these steps:
1. Define a Docker network: Create a Docker network using the `docker
network create` command. This network will allow containers to
communicate with each other using DNS-based service discovery.
2. Run the containers on the same network: When running the containers,
assign them to the same Docker network using the `--network` option.
This ensures that they can communicate with each other.
3. Assign unique container names: Provide unique names to each container
using the `--name` option. This makes it easier to reference and
communicate with specific containers.
4. Utilize container DNS names: Docker automatically assigns DNS
names to containers based on their names. Containers can communicate
with each other using these DNS names as hostnames.
5. Expose necessary ports: If a container needs to expose a port for
communication with external services, use the `--publish` or `-p` option to
map the container's port to a host port.
6. Configure environment variables: Set environment variables in each
container to specify connection details or configuration parameters
required for inter-container communication.
7. Test communication between containers: Validate the communication
between containers by running tests or executing commands within the
containers to ensure that they can access and communicate with the
required services.
By following these steps, you can set up networking and enable
communication between interdependent containers in Docker, allowing
them to work together as a cohesive application.

Docker Commands
1. **docker run**: Create and start a new container.
```
docker run -d --name mycontainer nginx
```
Output: Container ID (e.g., "e45fd9876f54")
Explanation: This command creates and starts a new container using the
"nginx" image in the background (detached mode) with the name
"mycontainer."

2. **docker ps**: List running containers.

```
docker ps
```
Output: List of running containers
Explanation: This command displays a list of currently running
containers along with their details such as Container ID, Image, Status,
Ports, and Names.

3. **docker images**: List available images.

```
docker images
```
Output: List of available images
Explanation: This command shows a list of images available on the
local Docker host, including their Repository, Tag, Image ID, and Size.
4. **docker pull**: Download an image from a registry.
```
docker pull ubuntu:latest
```
Output: Status messages indicating the progress of the image download
Explanation: This command downloads the latest version of the
"ubuntu" image from the Docker registry.

5. **docker stop**: Stop a running container.

```
docker stop mycontainer
```
Output: None
Explanation: This command stops the specified container with the name
"mycontainer."

6. **docker rm**: Remove a container.

```
docker rm mycontainer
```
Output: None
Explanation: This command removes the specified container with the
name "mycontainer."

7. **docker rmi**: Remove an image.

```
docker rmi nginx
```
Output: None
Explanation: This command removes the specified image with the name
"nginx" from the local Docker host.

8. **docker exec**: Run a command in a running container.

```
docker exec -it mycontainer bash
```
Output: Command prompt inside the container
Explanation: This command runs the "bash" command inside the
running container with the name "mycontainer," allowing you to interact
with the container's shell.
9. **docker logs**: Fetch the logs of a container.
```
docker logs mycontainer
```
Output: Container logs
Explanation: This command retrieves and displays the logs of the
specified container with the name "mycontainer."

10. **docker build**: Build a new image from a Dockerfile.

```
docker build -t myimage .
```
Output: Image build process output
Explanation: This command builds a new Docker image using the
Dockerfile present in the current directory and assigns it the name
"myimage."

11. **docker tag**: Add a tag to an image.

```
docker tag myimage myrepo/myimage:v1.0
```
Output: None
Explanation: This command adds a new tag ("v1.0") to the existing
image "myimage" and assigns it a new repository name
"myrepo/myimage."

12. **docker push**: Push an image to a registry.

```
docker push myrepo/myimage:v1.0
```
Output: Status messages indicating the progress of the image push
Explanation: This command pushes the specified image with the tag
"v1.0" to the Docker registry under the repository "myrepo/myimage."

13. **docker network ls**: List networks.

```
docker network ls
```
Output: List of available networks
 Explanation: This command displays a list of available networks on the
Docker host, including their Network ID
, Name, Driver, and Scope.

14. **docker network create**: Create a new network.

```
docker network create mynetwork
```
Output: Network ID (e.g., "ab12cd34ef56")
Explanation: This command creates a new Docker network with the
name "mynetwork" using the default bridge driver.

15. **docker network connect**: Connect a container to a network.

```
docker network connect mynetwork mycontainer
```
Output: None
Explanation: This command connects the specified container
("mycontainer") to the network with the name "mynetwork."

16. **docker volume ls**: List volumes.

```
docker volume ls
```
Output: List of available volumes
Explanation: This command lists the available Docker volumes on the
host, showing their names and mount points.

17. **docker volume create**: Create a new volume.

```
docker volume create myvolume
```
Output: Volume name (e.g., "myvolume")
Explanation: This command creates a new Docker volume with the
name "myvolume" for persistent data storage.

18. **docker volume inspect**: Inspect a volume.

```
docker volume inspect myvolume
 ```
Output: Volume details in JSON format
Explanation: This command provides detailed information about the
specified volume, including its name, mount point, and driver.

19. **docker volume rm**: Remove a volume.

```
docker volume rm myvolume
```
Output: None
Explanation: This command removes the specified Docker volume with
the name "myvolume" from the host.

20. **docker-compose up**: Create and start containers defined in a

Compose file.
```
docker-compose up -d
```
Output: Status messages indicating the creation and startup of containers
Explanation: This command creates and starts containers defined in a
Docker Compose file in the background (detached mode).

21. **docker-compose down**: Stop and remove containers defined in

a Compose file.
```
docker-compose down
```
Output: Status messages indicating the shutdown and removal of
containers
Explanation: This command stops and removes the containers defined
in a Docker Compose file.

22. **docker-compose logs**: Fetch the logs of containers defined in a

Compose file.
```
docker-compose logs myservice
```
Output: Logs of the specified service in the Compose file
Explanation: This command retrieves and displays the logs of the
specified service ("myservice") defined in a Docker Compose file.
23. **docker-compose build**: Build images defined in a Compose
file.
```
docker-compose build
```
Output: Image build process output
Explanation: This command builds the Docker images defined in a
Docker Compose file, based on the corresponding build configurations.

24. **docker inspect**: Display detailed information about a

container or image.
```
docker inspect mycontainer
```
Output: Detailed information about the container in JSON format
Explanation: This command provides in-depth information about the
specified container, including its configuration, network settings, and
more.

25. **docker cp**: Copy files/folders between a container and the

host.
```
docker cp myfile.txt mycontainer:/path/to/destination
```
Output: None
Explanation: This command copies the specified file ("myfile.txt")
from the host to the specified container ("mycontainer") at the given
destination path.

26. **docker top**: Display the running processes of a container.

```
docker top mycontainer
```
Output: List of running processes in the container
Explanation: This command shows the running processes within the
specified container, including
the process ID (PID), user, CPU usage, and more.
27. **docker start**: Start a stopped container.
```
docker start mycontainer
```
Output: None
Explanation: This command starts the specified stopped container
("mycontainer").

28. **docker restart**: Restart a running container.

```
docker restart mycontainer
```
Output: None
Explanation: This command restarts the specified running container
("mycontainer").

29. **docker pause**: Pause a running container.

```
docker pause mycontainer
```
Output: None
Explanation: This command pauses the execution of processes within
the specified container ("mycontainer").

30. **docker unpause**: Unpause a paused container.

```
docker unpause mycontainer
```
Output: None
Explanation: This command resumes the execution of processes within
the specified paused container ("mycontainer").

31. **docker kill**: Send a signal to stop a container.

```
docker kill mycontainer
```
Output: None
Explanation: This command sends a termination signal to the specified
container ("mycontainer"), causing it to stop immediately.
32. **docker rename**: Rename a container.
```
docker rename mycontainer newname
```
Output: None
Explanation: This command renames the specified container from
"mycontainer" to "newname."

33. **docker stats**: Display real-time resource usage of containers.

```
docker stats
```
Output: Real-time statistics of resource usage for all running containers
Explanation: This command continuously displays live resource usage
statistics (CPU, memory, network I/O, etc.) for all running containers.

34. **docker attach**: Attach to a running container.

```
docker attach mycontainer
```
Output: Console output of the attached container
Explanation: This command attaches to the specified running container
("mycontainer") and displays its console output in the terminal.

35. **docker commit**: Create a new image from a container's

changes.
```
docker commit mycontainer myimage:v2.0
```
Output: New image ID (e.g., "a1b2c3d4e5f6")
Explanation: This command creates a new Docker image from the
changes made to the specified container ("mycontainer") and assigns it the
name "myimage" with the tag "v2.0."

36. **docker login**: Log in to a Docker registry.

```
docker login myregistry.com
```
Output: Login successful message
 Explanation: This command logs in to the specified Docker registry
("myregistry.com") using the credentials provided by the user.

37. **docker logout**: Log out from a Docker registry.

```
docker logout myregistry.com
```
Output: Logout successful message
Explanation: This command logs out from the specified Docker registry
("myregistry.com") and clears the authentication credentials.

38. **docker history**: Show the history of an image.

```
docker history myimage
```
Output: Image history, showing layers and their details
Explanation: This command displays the history of the specified
Docker image ("myimage"), including each layer's commands and sizes.

39. **docker events**: Get real-time events from the server.

```
docker events
```
Output: Real-time events occurring on the Docker server
Explanation: This command continuously streams real-time events
from the Docker server, providing information about container and image
events, such as create, start, stop, etc.

40. **docker pause**: Pause all processes within a container.

```
docker pause mycontainer
```
Output: None
Explanation
: This command pauses all processes running inside the specified container
("mycontainer"), effectively freezing its execution.

41. **docker unpause**: Unpause all processes within a container.

```
docker unpause mycontainer
 ```
Output: None
Explanation: This command resumes the execution of all processes
within the specified paused container ("mycontainer").

42. **docker save**: Save an image to a tar archive.

```
docker save -o myimage.tar myimage
```
Output: Tar archive file "myimage.tar"
Explanation: This command saves the specified Docker image
("myimage") to a tar archive file named "myimage.tar."

43. **docker load**: Load an image from a tar archive.

```
docker load -i myimage.tar
```
Output: None
Explanation: This command loads a Docker image from the specified
tar archive file ("myimage.tar") and makes it available on the local Docker
host.

44. **docker import**: Import an image from a tar archive.

```
docker import myimage.tar myimage
```
Output: Image ID of the imported image (e.g., "a1b2c3d4e5f6")
Explanation: This command imports a Docker image from the specified
tar archive file ("myimage.tar") and assigns it the name "myimage."

45. **docker export**: Export a container's filesystem as a tar

archive.
```
docker export mycontainer > mycontainer.tar
```
Output: Tar archive file "mycontainer.tar"
Explanation: This command exports the filesystem of the specified
container ("mycontainer") as a tar archive file named "mycontainer.tar."
46. **docker import**: Import a previously exported container as a
new image.
```
docker import mycontainer.tar myimage
```
Output: Image ID of the imported image (e.g., "a1b2c3d4e5f6")
Explanation: This command imports a previously exported container
(as a tar archive) and creates a new Docker image with the name
"myimage."

47. **docker system df**: Show Docker disk usage.

```
docker system df
```
Output: Disk usage summary of Docker resources
Explanation: This command displays a summary of Docker's disk
usage, including the total size, used space, and available space for
containers, images, volumes, and more.

48. **docker system prune**: Remove unused data (containers,

images, networks, volumes, etc.).
```
docker system prune
```
Output: Confirmation message for the deletion of unused data
Explanation: This command removes unused Docker resources such as
stopped containers, unused images, networks not used by any container,
and dangling volumes.

49. **docker version**: Show the Docker version information.

```
docker version
```
Output: Docker version details (Client and Server)
Explanation: This command displays the version information of the
Docker client and server.

50. **docker info**: Show system-wide Docker information.

```
docker info
 ```
Output: System-wide Docker information (e.g., Containers, Images,
Storage Driver, etc.)
Explanation: This command provides detailed information about the
Docker installation and configuration on the host system, including the
number of containers, images, storage driver used, etc.