How to get Docker containers to talk to each other while running on my local host?


Connection in Docker container can be made using various ways. Some of these are explained in this article. Docker networking using the command line interface and docker-compose. This networking leads to communication between the containers.


Install the below prerequisites before executing the commands.

  • Docker Engine

  • Docker compose


These methods are simple and easy to implement on the local machine.

  • Using CLI commands

  • Using Docker Compose

Using Command Line Interface

Here we are going to create two different containers and connect them using the docker networking features.

Step 1: Create a Docker network

$ docker network create --driver bridge test_network 729f7d54a28063daaaef68693de94e5bd52fe9d65ec2c662021712be2d198511

Check if the new network “test_network” of driver type “bridge” is created or not.

$ docker network ls


0bfc15d4d317 bridge      bridge  local
db9d7d7d4e55 host        host    local
6f035e31161b minikube    bridge  local
dd1341a489b9 mynetwork   bridge  local
574f05aae08a none        null    local
729f7d54a280 test_network bridge local

Step 2: Create the first Docker container

Here we created our first Docker container and connected it with the network “test_network” we created in the previous step.

$ docker run -itd --name container1 --network test_network ubuntu:latest



Step 3: Create a second Docker container

~$ docker run -itd --name container2 --network test_network ubuntu:latest



Step 4: Network check

Check if both containers are created under the “test_network” driver.

$ docker network inspect test_network


      "Name": "test_network",
      "Id": "729f7d54a28063daaaef68693de94e5bd52fe9d65ec2c662021712be2d198511",
      "Created": "2022-12-22T15:45:53.424766976+05:30",
      "Scope": "local",
      "Driver": "bridge",
      "EnableIPv6": false,
      "IPAM": {
         "Driver": "default",
         "Options": {},
         "Config": [
               "Subnet": "",
               "Gateway": ""
   "Internal": false,
   "Attachable": false,
   "Ingress": false,
   "ConfigFrom": {
      "Network": ""
   "ConfigOnly": false,
   "Containers": {
      "dbf034ade04f36fd30609552c22af78ef1be64e32c8629ec1a0737e9af0982b8": {
         "Name": "container1",
         "MacAddress": "02:42:ac:13:00:02",
         "IPv4Address": "",
         "IPv6Address": ""
      "ff0626f1459207871b60514bdd841957d18589e2299a68703f97ec075edcdfae": {
            "Name": "container2",
            "MacAddress": "02:42:ac:13:00:03",
            "IPv4Address": "",
            "IPv6Address": ""
      "Options": {},
      "Labels": {}

Hence “container1” and “container2” both are on the same network.

Step 5: Check the connectivity

Get inside one of the containers and try to ping the other container. If the output shows positive signs, then we are communicating with the other container successfully.

$ docker exec -it container1 /bin/bash

Now we are inside the container1. But first, install the command.

root@dbf034ade04f:/# apt install iputils-ping


Reading package lists... Done
Building dependency tree... Done
Reading state information... Done
The following additional packages will be installed:
   libcap2-bin libpam-cap
The following NEW packages will be installed:
   iputils-ping libcap2-bin libpam-cap
0 upgraded, 3 newly installed, 0 to remove and 0 not upgraded.
Need to get 76.8 kB of archives.
After this operation, 280 kB of additional disk space will be used.
Do you want to continue? [Y/n] y

Now ping the container2.

root@dbf034ade04f:/# ping container2


PING container2 ( 56(84) bytes of data.
64 bytes from container2.test_network ( icmp_seq=1 ttl=64
time=59.1 ms
64 bytes from container2.test_network ( icmp_seq=2 ttl=64
time=0.217 ms
64 bytes from container2.test_network ( icmp_seq=3 ttl=64
time=0.104 ms
64 bytes from container2.test_network ( icmp_seq=4 ttl=64
time=0.213 ms
--- container2 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3010ms
rtt min/avg/max/mdev = 0.104/14.896/59.051/25.492 ms

Successfully able to communicate to the container and no packet was lost. Instead of using the container name, you can even use the IP address of the containers. Similarly, go inside “container2” and ping “container1” to check from the other side.

Using the Docker Compose

Here we will create a Docker Compose file with two container services. These services will be linked to one another and this linking will help the containers to talk to each other.

Step 1: Create the Docker Compose file

version: '3' services: busybox1: image: busybox:latest container_name: busybox_container_1 command: sh -c 'ping busybox2' links: - busybox2 busybox2: image: busybox:latest container_name: busybox_container_2 command: sleep infinity

The container “busybox_container_1” is linked to “busybox_container_2” using the links tag. In the command tag, we used ping to communicate with the other container.

Step 2: Initiate the containerization process

Here we will see if we get the ping output or not. Ping will connect to the other container and send/receive packets.

$ docker-compose up


Creating network "test_default" with the default driver
Creating busybox_container_2 ... done
Creating busybox_container_1 ... done
Attaching to busybox_container_2, busybox_container_1
busybox_container_1 | PING busybox2 ( 56 data bytes
busybox_container_1 | 64 bytes from seq=0 ttl=64 time=0.162 ms
busybox_container_1 | 64 bytes from seq=1 ttl=64 time=0.137 ms
busybox_container_1 | 64 bytes from seq=2 ttl=64 time=0.212 ms
busybox_container_1 | 64 bytes from seq=3 ttl=64 time=0.104 ms
busybox_container_1 | 64 bytes from seq=4 ttl=64 time=0.231 ms
busybox_container_1 | 64 bytes from seq=5 ttl=64 time=0.170 ms
busybox_container_1 | 64 bytes from seq=6 ttl=64 time=0.313 ms
busybox_container_1 | 64 bytes from seq=7 ttl=64 time=0.277 ms
^CGracefully stopping... (press Ctrl+C again to force)
Stopping busybox_container_1 ... done
Stopping busybox_container_2 ... done

Hence the pinging is working fine and the container is connected. The output of the ping command can also be seen in the above Docker Compose output.


We were successfully able to connect and communicate to the Docker container present on the local host. These methods are the most used and preferred in the industry. Once the connection is established we can do multiple tasks with the connected containers.