Running several connected containers

In this topic, we will explore connecting docker containers. Picture having multiple isolated containers that initially operate independently. Our objective integrate them, enabling efficient communication and interaction. Throughout this discussion, we'll learn how to link these diverse containers together.

Running several connected containers

Running several connected containers typically refers to creating a multi-container application where containers communicate with each other. These containers can communicate with each other using Docker's internal networking. Docker-compose offers a streamlined method for orchestrating multiple containers using a docker-compose.yml file. However, containers can also be connected manually by creating custom Docker networks and then attaching containers to these networks. Once on the same network, containers can communicate using container names as hostnames. Manual connection offers detailed control but might be time-consuming with many containers, making tools like docker-compose preferred for more complex setups.

Connecting containers manually

Manually connecting containers in Docker refers to the process of setting up communication between multiple Docker containers without using Docker compose, When we run containers manually, we often use Docker's native networking capabilities to connect containers.

Let's use a sample example with a web application and a database.

Step 1: Create a custom Docker network.

docker network create mynetwork

Step 2: Start a PostgreSQL container.

docker run -d --network=mynetwork --name mydb -e \
  POSTGRES_PASSWORD=mysecretpassword postgres

Step 3: Start a web application container that connects to the PostgreSQL database.

Imagine you have an application that uses environment variables to connect to the database.

You would run:

docker run -d --network=mynetwork --name myapp -e DATABASE_HOST=mydb \
  -e DATABASE_PASSWORD=mysecretpassword myapp-image

Your application should use DATABASE_HOST as the hostname to connect to the PostgreSQL database.

Sharing volumes between containers

To share data between containers, you can use Docker volumes. Volumes are storage units that exist independently of containers, you create a volume and then mount this volume into multiple containers, This approach ensures data persistence and consistency across containers.

Let's take an example where you have two containers that need to access the same configuration files or need to share data.

Step 1: Create a Docker volume

docker volume create sharedvol

Step 2: Start a MySQL container and mount the shared volume for data persistence.

docker run -d --name mysql-container -v sharedvol:/var/lib/mysql mysql

Step 3: Start the WordPress container and mount the same volume to access the MySQL database data.

docker run -d --name wordpress-container -v sharedvol:/var/www/html wordpress

In this scenario, both the MySQL and WordPress containers will be able to access and modify data in the sharedvol volume, which is crucial for applications that require shared or persistent data.

Adding containers to an existing network

If you forgot to add a container to a network at startup, you can still attach it to the network later. First, identify the network using docker network ls. Then use the docker network connect command to attach the running container to the desired network.

Step 1: Connect the container to the existing network.

docker network connect mynetwork nginx-container

Step 2: Verify the connection.

docker container inspect nginx-container

Here, nginx-container is added to mynetwork, allowing to communicate with other containers on the same network.

Running a container in the host network

Running a Docker container in the host network means bypassing the virtual networking provided by Docker and using the host's networking directly.

Step1. Start an Nginx container in the host network

docker run --net=host -d --name nginx-host-container nginx

This command runs an Nginx container directly on the host's network stack. While this method provides performance benefits and easier port mapping, it also poses security risks as the container has unrestricted access to the host network. It can lead to port conflicts and potential exposure of the host system to security vulnerabilities. Therefore, it's crucial to assess the risks and benefits before opting for this setup.

Conclusion

Whether connecting containers manually or using tools like Docker-compose, it's essential to understand the different approaches and their implications. Manual connections provide detailed control and are suitable for simpler setups, while Docker-compose is preferred for more orchestrations. Sharing data between containers using Docker volumes ensures consistency and persistence. Lastly, adding containers to networks post-startup and running containers in the host network are options that offer flexibility but require careful consideration of security and network management. Each method serves specific needs, making it crucial to choose wisely based on your application requirements.