Day 19 : Docker Advanced

In the last blog, we learned about how to create a Docker compose file and push it to a repository. Now we will explore the concepts of Docker Volume and Docker Network.

Docker Volume

A Docker volume is a directory that is shared between the host machine and a container, allowing data to be persisted even after the container is deleted or recreated. Volumes are mounted at a specific path within the container, and can be used to store data that needs to be preserved across multiple container runs, such as databases, files, and configurations.

Benefits of using Docker volumes include:

• Persistent data storage: Volumes allow you to store data that persists even after the container is deleted or recreated, ensuring that your data is not lost.

• Easy data sharing: Volumes can be shared between multiple containers, making it easy to share data between different applications or services.

• Flexible data management: Volumes can be created, deleted, and managed easily, allowing you to manage your data in a flexible and efficient way.

Examples of when to use Docker volumes include:

• Databases: Volumes are ideal for storing database data, as they provide a persistent storage solution that can be easily shared between multiple containers.

• File storage: Volumes can be used to store files that need to be accessed by multiple containers, such as media files or document repositories.

• Configurations: Volumes can be used to store configuration files that need to be shared between multiple containers, such as environment variables or application settings.

To create and use Docker volumes, you can use the docker volume command. For example, to create a new volume, you can run docker volume create my-volume. To mount a volume in a container, you can use the --volume flag when running the container, such as docker run -v my-volume:/data my-image.

There are different types of Docker volumes, including:

• Persistent volumes: These volumes are stored on the host machine and persist even after the container is deleted or recreated.

• Non-persistent volumes: These volumes are stored in memory and are deleted when the container is stopped or recreated.

• Named volumes: These volumes are given a name and can be easily referenced by other containers.

• Unnamed volumes: These volumes are not given a name and are automatically created and deleted when the container is run.

Best practices for using Docker volumes include:

• Use volumes for data that needs to be persisted across multiple container runs.

• Use named volumes for easy reference and management.

• Use non-persistent volumes for data that does not need to be persisted.

• Use volumes in conjunction with Docker Compose for easy management of multi-container applications.

Troubleshooting Docker volumes may involve checking the volume's mount path, ensuring that the volume is properly created and mounted, and verifying that the volume is not corrupted or damaged. You can use Docker's built-in tools, such as docker volume ls and docker volume inspect, to manage and troubleshoot volumes. Additionally, you can use third-party tools, such as Docker Compose, to simplify the management of volumes and other Docker resources.

Docker Network

A Docker network is a virtual network that allows containers to communicate with each other and with the host machine. It is created and managed by Docker and allows containers to be connected to each other and to the internet.

There are several types of Docker networks, including:

• bridge networks: These networks are created automatically by Docker when you start a container. They are named after the bridge interface that connects the host machine to the container. Bridge networks are useful for development and testing environments, but they are not suitable for production environments because they are not isolated from the host machine.

• host networks: These networks allow containers to communicate directly with the host machine. They are useful for debugging and testing purposes, but they can also be used in production environments where containers need to access resources on the host machine.

• custom networks: These networks are created by the user and can be configured to meet specific requirements. They can be used to isolate containers from each other and from the host machine, and they can be configured to allow access to specific resources.

• overlay networks: These networks are created by Docker and allow containers to communicate with each other even if they are running on different hosts. They are useful for creating distributed applications that span multiple hosts.

To create and manage Docker networks, you can use the Docker network command-line tool. For example, to create a new network, you can run the command docker network create my-network. To connect a container to a network, you can use the --net flag when running the container, such as docker run -net my-network my-image. To manage network settings, you can use the docker network ls command to list all networks, docker network inspect to view details of a network, and docker network rm to remove a network.

Connecting containers to Docker networks is done using the --net flag when running the container. For example, docker run -net my-network my-image will connect the container to the my-network network. You can also connect multiple containers to the same network by using the same --net flag when running each container.

Troubleshooting Docker networks may involve checking network settings, verifying that containers are connected to the correct network, and ensuring that network traffic is not blocked by firewall rules or other security measures. You can use Docker's built-in tools, such as docker network ls and docker network inspect, to manage and troubleshoot networks. Additionally, you can use third-party tools, such as Docker Compose, to simplify the management of networks and other Docker resources.

---

Task-1

• Create a multi-container docker-compose file which will bring UP and bring DOWN containers in a single shot ( Example - Create application and database container )

version: This specifies the version of the Docker Compose file. In this case, it is version 3.3.

services: This section defines the services that make up the application. In this case, there are two services: web and db.

web: This service runs the Django web application. The image property specifies the Docker image to use for the service. In this case, the image is varsha0108/local_django:latest. The deploy section specifies the deployment configuration for the service. In this case, the replicas property is set to 2, which means that two replicas of the service will be running. The ports section specifies that the service should be exposed on ports 8001-8005 on the host machine. The volumes section specifies that the /app directory in the container should be mounted to the my_django_volume volume on the host machine.

db: This service runs a MySQL database. The image property specifies the Docker image to use for the service. In this case, the image is mysql. The ports section specifies that the service should be exposed on port 3306 on the host machine. The environment section specifies that the MYSQL_ROOT_PASSWORD environment variable should be set to test@123. The volumes section specifies that the my_django_volume volume on the host machine should be mounted to the /var/lib/mysql directory in the container.

my_django_volume: This volume is mounted to both the web and db services. This allows the two services to share data. The external keyword in the volume definition tells Docker Compose to use an existing volume named my_django_volume. This volume must be created and mounted on the host machine before starting the containers.

• Use the docker-compose up command with the -d flag to start a multi-container application in detached mode.

• Use the docker-compose scale command to increase or decrease the number of replicas for a specific service. You can also add replicas in deployment file for auto-scaling.

• Use the docker-compose ps command to view the status of all containers, and docker-compose logs to view the logs of a specific service.

• Use the docker-compose down command to stop and remove all containers, networks, and volumes associated with the application

Task-2

• Learn how to use Docker Volumes and Named Volumes to share files and directories between multiple containers.

In this example, at first, I create a shared volume as shown in the image. Then 2 containers are created and the volume is mounted using the -v tag. As the nginx image isn't available locally it pulls from the library in the first instance and in the second instance it doesn't.

• Create two or more containers that read and write data to the same volume using the docker run --mount command.

The docker run --mount and docker run -v commands serve similar purposes in that they both allow you to mount volumes or bind mounts into a Docker container, but they have different syntax and provide different levels of flexibility.

1. docker run -v (short syntax for volumes):

   • The -v option is a shorter and simpler way to specify volume mounts.

   • It can be used to either create and use a named volume or to specify a bind mount (host directory).

   • The syntax is as follows:

       rubyCopy codedocker run -v <volume_name_or_path>:<container_path> ...
     

     2)

     docker run --mount (long syntax for volumes):

     • The --mount option provides a more explicit and flexible way to specify volume mounts.

     • It allows you to specify additional options like read-only mounts, volume driver options, and more.

     • The syntax is as follows:

         bashCopy codedocker run --mount type=<mount_type>,source=<source>,target=<target> ...
       

2. Verify that the data is the same in all containers by using the docker exec command to run commands inside each container.

• Use the docker volume ls command to list all volumes and docker volume rm command to remove the volume when you're done.

---

Thankyou for reading until here.See you in the next one.