Skip to main content

Docker Networking

🔗 10. What are Docker network drivers, and what are their types?​

Docker-āĻ network driver āĻšāϞ⧋ āĻāĻ•āϟāĻŋ pluggable system āϝāĻž āύāĻŋāĻ°ā§āϧāĻžāϰāĻŖ āĻ•āϰ⧇ containers āϕ⧀āĻ­āĻžāĻŦ⧇ āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āϏāĻžāĻĨ⧇ āĻāĻŦāĻ‚ āĻŦāĻžāχāϰ⧇āϰ world-āĻāϰ āϏāĻžāĻĨ⧇ communicate āĻ•āϰāĻŦ⧇āĨ¤ Docker-āĻāϰ Container Network Model (CNM) āĻāϰ āωāĻĒāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ āĻ•āϰ⧇ āĻāχ driver-āϗ⧁āϞ⧋ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

āĻĒā§āϰāϤāĻŋāϟāĻŋ network-āĻāϰ āϤāĻŋāύāϟāĻŋ āĻŽā§‚āϞ component āφāϛ⧇ — Sandbox (container-āĻāϰ network stack), Endpoint (virtual network interface), āĻāĻŦāĻ‚ Network (driver-managed connectivity layer)āĨ¤

Docker network drivers overview

1. bridge (Default Driver)​

āĻāϟāĻŋ Docker-āĻāϰ default network driverāĨ¤ āϝāĻ–āύ āϕ⧋āύ⧋ network specify āύāĻž āĻ•āϰ⧇ container run āĻ•āϰāĻž āĻšāϝāĻŧ, āϤāĻ–āύ automatically bridge āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇: Docker āĻāĻ•āϟāĻŋ virtual bridge interface (docker0) āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ container āĻāĻ•āϟāĻŋ veth pair āĻĻāĻŋāϝāĻŧ⧇ āĻāχ bridge-āĻ connect āĻšāϝāĻŧāĨ¤ Container-āϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ communicate āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ host āĻāĻŦāĻ‚ āĻŦāĻžāχāϰ⧇āϰ network āĻĨ⧇āϕ⧇ isolated āĻĨāĻžāϕ⧇āĨ¤

# Default bridge-āĻ run āĻ•āϰāĻž
docker run -d nginx

# Custom bridge network āϤ⧈āϰāĻŋ
docker network create --driver bridge my-network
docker run -d --network my-network nginx

āĻ•āĻ–āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇: Single host-āĻ multiple container-āĻāϰ āĻŽāĻ§ā§āϝ⧇ communication āĻĻāϰāĻ•āĻžāϰ āĻšāϞ⧇āĨ¤


2. host​

Container-āϟāĻŋ host machine-āĻāϰ network stack āϏāϰāĻžāϏāϰāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ — āϕ⧋āύ⧋ network isolation āύ⧇āχāĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇: Container-āĻāϰ āύāĻŋāϜāĻ¸ā§āĻŦ āϕ⧋āύ⧋ IP address āĻĨāĻžāϕ⧇ āύāĻžāĨ¤ Host-āĻāϰ IP āĻāĻŦāĻ‚ port āϏāϰāĻžāϏāϰāĻŋ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧāĨ¤

docker run -d --network host nginx
# āĻāĻ–āύ nginx host-āĻāϰ port 80-āϤ⧇ āϏāϰāĻžāϏāϰāĻŋ accessible

āĻ•āĻ–āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇: High-performance networking āĻĻāϰāĻ•āĻžāϰ āĻšāϞ⧇, āϝ⧇āĻŽāύ network monitoring tools āĻŦāĻž performance-critical applicationsāĨ¤

āϏāϤāĻ°ā§āĻ•āϤāĻž: Port conflicts āĻšāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ Linux-only (Mac/Windows-āĻ āĻ•āĻžāϜ āĻ•āϰ⧇ āύāĻž properly)āĨ¤


3. none​

Container-āĻāϰ āϕ⧋āύ⧋ network interface āĻĨāĻžāϕ⧇ āύāĻž — āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ isolatedāĨ¤

docker run -d --network none alpine
# āĻāχ container āχāĻ¨ā§āϟāĻžāϰāύ⧇āĻŸā§‡āĻ“ āϝ⧇āϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āύāĻž, āĻ…āĻ¨ā§āϝ container-āĻāĻ“ āύāĻž

āĻ•āĻ–āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇: Batch processing jobs āĻŦāĻž maximum security sandbox āĻĻāϰāĻ•āĻžāϰ āĻšāϞ⧇āĨ¤


4. overlay​

Multi-host networking āĻāϰ āϜāĻ¨ā§āϝāĨ¤ Docker Swarm āĻŦāĻž Kubernetes cluster-āĻ āĻŦāĻŋāĻ­āĻŋāĻ¨ā§āύ host-āĻ āĻĨāĻžāĻ•āĻž container-āϗ⧁āϞ⧋āϕ⧇ āĻāĻ•āχ network-āĻ āφāύ⧇āĨ¤

āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇: VXLAN tunneling āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ physically āφāϞāĻžāĻĻāĻž host-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϟāĻŋ virtual network āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤

# Swarm mode-āĻ overlay network
docker network create --driver overlay my-overlay
docker service create --network my-overlay nginx

āĻ•āĻ–āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇: Docker Swarm cluster, distributed applications, microservices architectureāĨ¤


5. macvlan​

āĻĒā§āϰāϤāĻŋāϟāĻŋ container āĻāĻ•āϟāĻŋ āφāϞāĻžāĻĻāĻž MAC address āĻĒāĻžāϝāĻŧ āĻāĻŦāĻ‚ physical network-āĻ directly appear āĻ•āϰ⧇ — āϝ⧇āύ āĻāϟāĻŋ āĻāĻ•āϟāĻŋ āφāϞāĻžāĻĻāĻž physical deviceāĨ¤

docker network create \
--driver macvlan \
--subnet=192.168.1.0/24 \
--gateway=192.168.1.1 \
-o parent=eth0 \
my-macvlan

āĻ•āĻ–āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇: Legacy applications āϝ⧇āϗ⧁āϞ⧋ directly physical network-āĻ āĻĨāĻžāĻ•āĻž āĻĻāϰāĻ•āĻžāϰ, āĻ…āĻĨāĻŦāĻž network monitoringāĨ¤

āϏāĻŽāĻ¸ā§āϝāĻž: Host āĻāĻŦāĻ‚ container-āĻāϰ āĻŽāĻ§ā§āϝ⧇ direct communication āĻ•āϰāĻž āĻ•āĻ āĻŋāύāĨ¤


6. ipvlan​

macvlan-āĻāϰ āĻŽāϤ⧋āχ, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏāĻŦ container āĻāĻ•āχ MAC address share āĻ•āϰ⧇, āĻļ⧁āϧ⧁ āφāϞāĻžāĻĻāĻž IP āĻĒāĻžāϝāĻŧāĨ¤

docker network create \
--driver ipvlan \
--subnet=192.168.1.0/24 \
-o parent=eth0 \
my-ipvlan

āĻ•āĻ–āύ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰāĻŦ⧇: Wireless environments āĻ…āĻĨāĻŦāĻž āϝ⧇āĻ–āĻžāύ⧇ MAC address restriction āφāϛ⧇ (āϝ⧇āĻŽāύ cloud providers)āĨ¤


bridge, host, none, āĻāĻŦāĻ‚ overlay — āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āĻ“ āĻŦā§āϝāĻŦāĻšāĻžāĻ°â€‹

āϚāĻžāϰāϟāĻŋ network-āĻāϰ āĻŽā§‚āϞ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝāϟāĻž āĻŦā§‹āĻāĻžāϰ āϏāĻŦāĻšā§‡āϝāĻŧ⧇ āĻ­āĻžāϞ⧋ āωāĻĒāĻžāϝāĻŧ āĻšāϞ⧋ āĻĻ⧇āĻ–āĻž — āĻĒā§āϰāϤāĻŋāϟāĻŋāϤ⧇ container, host machine, āĻāĻŦāĻ‚ āĻŦāĻžāχāϰ⧇āϰ internet-āĻāϰ āĻŽāĻ§ā§āϝ⧇ relation āϕ⧇āĻŽāύāĨ¤ āύāĻŋāĻšā§‡ āϏ⧇āϟāĻž diagram āφāĻ•āĻžāϰ⧇ āĻĻ⧇āĻ–āĻžāύ⧋ āĻšāϞ⧋, āϤāĻžāϰāĻĒāϰ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ āĻŦā§āϝāĻžāĻ–ā§āϝāĻžāĨ¤

Docker network modes comparison

āĻāĻŦāĻžāϰ āĻĒā§āϰāϤāĻŋāϟāĻŋ network mode-āĻāϰ āĻŽā§‚āϞ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝāϗ⧁āϞ⧋ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ āĻĻ⧇āĻ–āĻŋāĨ¤


bridge — āφāĻ‚āĻļāĻŋāĻ• isolation, port mapping āĻĻāϰāĻ•āĻžāĻ°â€‹

bridge āĻšāϞ⧋ Docker-āĻāϰ default network modeāĨ¤ Docker āĻāĻ•āϟāĻŋ virtual switch (docker0) āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āĻāĻŦāĻ‚ āĻĒā§āϰāϤāĻŋāϟāĻŋ container-āϕ⧇ āĻāĻ•āϟāĻŋ veth pair āĻĻāĻŋāϝāĻŧ⧇ āϏ⧇āχ switch-āĻ connect āĻ•āϰ⧇āĨ¤

Container-āϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āĻ•āĻĨāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻŦāĻžāχāϰ⧇āϰ world āĻĨ⧇āϕ⧇ access āĻ•āϰāϤ⧇ āĻšāϞ⧇ NAT (Network Address Translation) āĻāĻŦāĻ‚ explicit port mapping āĻĻāϰāĻ•āĻžāϰāĨ¤

# container-āĻāϰ port 80 āϕ⧇ host-āĻāϰ port 8080-āĻ map āĻ•āϰāĻž
docker run -d -p 8080:80 nginx

Host machine-āĻāϰ āĻŦāĻžāχāϰ⧇ āĻĨ⧇āϕ⧇ http://host-ip:8080 āĻĻāĻŋāϝāĻŧ⧇ access āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ — āϏāϰāĻžāϏāϰāĻŋ container-āĻāϰ IP āĻĻāĻŋāϝāĻŧ⧇ āύāĻžāĨ¤


host — āϕ⧋āύ⧋ isolation āύ⧇āχ, āϏāĻ°ā§āĻŦā§‹āĻšā§āϚ performance​

host mode-āĻ container-āϟāĻŋ host-āĻāϰ network stack āϏāϰāĻžāϏāϰāĻŋ share āĻ•āϰ⧇ — āφāϞāĻžāĻĻāĻž āϕ⧋āύ⧋ virtual network interface āύ⧇āχ, āφāϞāĻžāĻĻāĻž IP āύ⧇āχāĨ¤

Container āϝāĻĻāĻŋ port 80 listen āĻ•āϰ⧇, āϏ⧇āϟāĻž āϏāϰāĻžāϏāϰāĻŋ host-āĻāϰ port 80 — āϕ⧋āύ⧋ NAT āĻŦāĻž port mapping āĻ›āĻžāĻĄāĻŧāĻžāχāĨ¤

docker run -d --network host nginx
# āĻāĻ–āύ host-āĻāϰ port 80-āĻ āϏāϰāĻžāϏāϰāĻŋ accessible, -p flag āϞāĻžāĻ—āĻŦ⧇ āύāĻž

āĻĻ⧁āĻŸā§‹ āĻŦāĻĄāĻŧ āϏ⧀āĻŽāĻžāĻŦāĻĻā§āϧāϤāĻž āφāϛ⧇:

  • Host-āĻ āϝāĻĻāĻŋ port 80 already āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāĻšā§āϛ⧇, port conflict āĻšāĻŦ⧇
  • Linux-only — Docker Desktop (Mac/Windows)-āĻ āĻ āĻŋāĻ•āĻŽāϤ⧋ āĻ•āĻžāϜ āĻ•āϰ⧇ āύāĻž

none — āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖ isolation​

none mode-āĻ container-āĻāϰ āϕ⧋āύ⧋ network interface āĻĨāĻžāϕ⧇ āύāĻž — āĻļ⧁āϧ⧁ loopback (lo) āĻĨāĻžāϕ⧇āĨ¤ Internet āύ⧇āχ, āĻ…āĻ¨ā§āϝ container-āĻāĻ“ āϝ⧋āĻ—āĻžāϝ⧋āĻ— āύ⧇āχāĨ¤

docker run -d --network none alpine sleep 3600

# container-āĻāϰ āϭ⧇āϤāϰ⧇ āĻ—āĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–āϞ⧇:
# ip addr → āĻļ⧁āϧ⧁ lo: 127.0.0.1 āĻĻ⧇āĻ–āĻžāĻŦ⧇

āĻāχ mode-āϟāĻŋ security sandbox āĻšāĻŋāϏ⧇āĻŦ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻšāϝāĻŧ — āϝ⧇āĻŽāύ untrusted code āϚāĻžāϞāĻžāύ⧋ āĻŦāĻž cryptographic key processing āϝ⧇āĻ–āĻžāύ⧇ network access āĻĻ⧇āĻ“āϝāĻŧāĻž āĻŦāĻŋāĻĒāĻœā§āϜāύāĻ•āĨ¤


overlay — multi-host networking​

overlay network-āĻ physically āφāϞāĻžāĻĻāĻž āφāϞāĻžāĻĻāĻž host-āĻ āĻĨāĻžāĻ•āĻž container-āϗ⧁āϞ⧋ āĻāĻ•āχ virtual network-āĻ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ VXLAN tunneling āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇ āĻĻ⧁āϟāĻŋ host-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϟāĻŋ encrypted tunnel āϤ⧈āϰāĻŋ āĻšāϝāĻŧāĨ¤

āĻāχ mode āϟāĻŋ primarily Docker Swarm āĻŦāĻž Kubernetes-āĻāϰ āϜāĻ¨ā§āϝāĨ¤

# Swarm mode initialize āĻ•āϰāϤ⧇ āĻšāĻŦ⧇ āφāϗ⧇
docker swarm init

# āϤāĻžāϰāĻĒāϰ overlay network āϤ⧈āϰāĻŋ
docker network create --driver overlay my-cluster-net

# service deploy āĻ•āϰāĻž
docker service create --network my-cluster-net --replicas 3 nginx

bridge-āĻāϰ āĻŽāϤ⧋āχ āĻĻ⧇āĻ–āϤ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āĻšāϞ⧋ — container āϗ⧁āϞ⧋ āĻ­āĻŋāĻ¨ā§āύ physical machine-āĻ āĻĨāĻžāĻ•āϞ⧇āĻ“ āĻāϕ⧇ āĻ…āĻĒāϰāϕ⧇ directly ping āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤


When would you use the host` network mode?​

host mode āĻŦā§āϝāĻŦāĻšāĻžāϰ⧇āϰ āϏāĻŋāĻĻā§āϧāĻžāĻ¨ā§āϤ āύ⧇āĻ“āϝāĻŧāĻžāϰ āφāϗ⧇ āĻŽā§‚āϞ āĻĒā§āϰāĻļā§āύ āĻšāϞ⧋ — NAT-āĻāϰ overhead āĻ•āĻŋ āϏāĻ¤ā§āϝāĻŋāχ āϏāĻŽāĻ¸ā§āϝāĻž āĻ•āϰāϛ⧇?

āϤāĻŋāύāϟāĻŋ concrete scenario-āϤ⧇ host mode āϝ⧁āĻ•ā§āϤāĻŋāϏāĻ‚āĻ—āϤ:

ā§§. High-throughput networking āĻĻāϰāĻ•āĻžāϰ: āϝ⧇āĻŽāύ āĻĒā§āϰāϤāĻŋ āϏ⧇āϕ⧇āĻ¨ā§āĻĄā§‡ āϞāĻ•ā§āώāĻžāϧāĻŋāĻ• packet process āĻ•āϰāĻž network monitoring tool, IDS (Intrusion Detection System), āĻŦāĻž packet snifferāĨ¤ NAT-āĻāϰ extra hop āĻāĻ–āĻžāύ⧇ measurable latency āϝ⧋āĻ— āĻ•āϰ⧇āĨ¤

⧍. Raw socket āĻŦāĻž āĻĒā§āϰāϚ⧁āϰ dynamic port āĻĻāϰāĻ•āĻžāϰ: āϝ⧇āĻŽāύ tcpdump, Wireshark, āĻŦāĻž WebRTC-based application āϝ⧇āϗ⧁āϞ⧋ āĻ…āύ⧇āĻ•āϗ⧁āϞ⧋ ephemeral port āĻ–ā§‹āϞ⧇ — -p flag āĻĻāĻŋāϝāĻŧ⧇ āϏāĻŦāϗ⧁āϞ⧋ map āĻ•āϰāĻž practical āύāĻžāĨ¤

ā§Š. Host-āĻāϰ network interface āϏāϰāĻžāϏāϰāĻŋ āĻĻ⧇āĻ–āĻž āĻĻāϰāĻ•āĻžāϰ: āϝ⧇āĻŽāύ DHCP server, VPN gateway, āĻŦāĻž network configuration tool āϝ⧇āϗ⧁āϞ⧋ host-āĻāϰ actual NIC-āĻāϰ āϏāĻžāĻĨ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

āϏāĻžāϧāĻžāϰāĻŖ web application āĻŦāĻž microservice-āĻāϰ āϜāĻ¨ā§āϝ host mode āĻĻāϰāĻ•āĻžāϰ āύ⧇āχ — bridgeāχ āϝāĻĨ⧇āĻˇā§āϟ āĻāĻŦāĻ‚ āĻŦ⧇āĻļāĻŋ secureāĨ¤

What is the default network mode for a Docker container?​

Docker container-āĻāϰ default network mode āĻšāϞ⧋ bridgeāĨ¤ āϝāĻ–āύ āϤ⧁āĻŽāĻŋ āϕ⧋āύ⧋ --network flag āĻ›āĻžāĻĄāĻŧāĻž container run āĻ•āϰ⧋, Docker automatically āϏ⧇āϟāĻžāϕ⧇ docker0 āύāĻžāĻŽā§‡āϰ default bridge network-āĻ āϝ⧁āĻ•ā§āϤ āĻ•āϰ⧇āĨ¤

# āĻāχ āĻĻ⧁āĻŸā§‹ command āĻāĻ•āχ āĻ•āĻžāϜ āĻ•āϰ⧇
docker run nginx
docker run --network bridge nginx
# verify āĻ•āϰāϤ⧇
docker inspect <container_id> | grep NetworkMode
# output: "NetworkMode": "bridge"

āϤāĻŦ⧇ default bridge āφāϰ user-defined bridge-āĻāϰ āĻŽāĻ§ā§āϝ⧇ āĻāĻ•āϟāĻž āϗ⧁āϰ⧁āĻ¤ā§āĻŦāĻĒā§‚āĻ°ā§āĻŖ āĻĒāĻžāĻ°ā§āĻĨāĻ•ā§āϝ āφāϛ⧇ — āϏ⧇āϟāĻž āĻšāϞ⧋ DNS resolution, āϝ⧇āϟāĻž āĻĻā§āĻŦāĻŋāϤ⧀āϝāĻŧ āĻĒā§āϰāĻļā§āύ⧇ āĻŦāĻŋāĻ¸ā§āϤāĻžāϰāĻŋāϤ āφāϞ⧋āϚāύāĻž āĻ•āϰāĻž āĻšāϝāĻŧ⧇āϛ⧇āĨ¤


How does DNS resolution work between containers on the same bridge network?​

āĻāĻ–āĻžāύ⧇ default bridge āφāϰ user-defined bridge āφāϞāĻžāĻĻāĻžāĻ­āĻžāĻŦ⧇ āφāϚāϰāĻŖ āĻ•āϰ⧇āĨ¤

Docker DNS resolution on bridge networks

Default Bridge-āĻ DNS āĻ•āĻžāϜ āĻ•āϰ⧇ āύāĻž — āϕ⧇āύ?

Default bridge network (docker0) āĻĒ⧁āϰāύ⧋ design-āĻāϰāĨ¤ āĻāĻ–āĻžāύ⧇ Docker āϕ⧋āύ⧋ embedded DNS server āϚāĻžāϞāĻžāϝāĻŧ āύāĻžāĨ¤ Container āϗ⧁āϞ⧋ āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ IP address āĻĻāĻŋāϝāĻŧ⧇ āĻāϕ⧇ āĻ…āĻĒāϰāϕ⧇ āĻšā§‡āύ⧇āĨ¤

# default bridge-āĻ run āĻ•āϰāϞ⧇
docker run -d --name web nginx
docker run -d --name db postgres

# web āĻĨ⧇āϕ⧇ db-āϤ⧇ name āĻĻāĻŋāϝāĻŧ⧇ ping āĻ•āϰāϞ⧇ FAIL āĻšāĻŦ⧇
docker exec web ping db
# ping: db: Name or service not known ❌

āĻāĻ•āĻŽāĻžāĻ¤ā§āϰ āωāĻĒāĻžāϝāĻŧ āĻ›āĻŋāϞ --link flag, āĻ•āĻŋāĻ¨ā§āϤ⧁ āϏ⧇āϟāĻž āĻāĻ–āύ deprecatedāĨ¤


User-defined Bridge-āĻ DNS āϕ⧀āĻ­āĻžāĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇?

User-defined bridge network āϤ⧈āϰāĻŋ āĻ•āϰāϞ⧇ Docker automatically āĻāĻ•āϟāĻŋ embedded DNS server āϚāĻžāϞāĻžāϝāĻŧ — 127.0.0.11:53āĨ¤ āĻĒā§āϰāϤāĻŋāϟāĻŋ container-āĻāϰ /etc/resolv.conf-āĻ āĻāχ address āĻĨāĻžāϕ⧇āĨ¤

# network āϤ⧈āϰāĻŋ āĻ•āϰ⧋
docker network create my-net

# container run āĻ•āϰ⧋
docker run -d --name web --network my-net nginx
docker run -d --name db --network my-net postgres

# āĻāĻ–āύ name āĻĻāĻŋāϝāĻŧ⧇āχ communicate āĻ•āϰāĻž āϝāĻžāĻŦ⧇
docker exec web ping db # ✅ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇
docker exec web curl http://db # ✅ āĻ•āĻžāϜ āĻ•āϰāĻŦ⧇

Container-āĻāϰ āϭ⧇āϤāϰ⧇ āĻ—āĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ–āϞ⧇ —

docker exec web cat /etc/resolv.conf
# nameserver 127.0.0.11
# options ndots:0

DNS Resolution-āĻāϰ āϧāĻžāĻĒāϗ⧁āϞ⧋

web container āĻĨ⧇āϕ⧇ db-āϕ⧇ call āĻ•āϰāϞ⧇ āϝāĻž āĻšāϝāĻŧ:

web container
└── "db" āύāĻžāĻŽāϟāĻž resolve āĻ•āϰāϤ⧇ āĻšāĻŦ⧇
└── /etc/resolv.conf → nameserver 127.0.0.11
└── Docker embedded DNS server
└── "db" → 172.18.0.3
└── packet āϚāϞ⧇ āϝāĻžāϝāĻŧ db container-āĻ ✅

Container restart āĻšāϞ⧇āĻ“ db āύāĻžāĻŽāϟāĻž same āĻĨāĻžāϕ⧇ — āĻļ⧁āϧ⧁ IP āĻĒ⧇āĻ›āύ⧇ internally update āĻšāϝāĻŧāĨ¤ āϤ⧋āĻŽāĻžāϰ code-āĻ āϕ⧋āύ⧋ āĻĒāϰāĻŋāĻŦāĻ°ā§āϤāύ āϞāĻžāϗ⧇ āύāĻžāĨ¤


Default vs User-defined Bridge — āĻāĻ•āϟ⧁ āϤ⧁āϞāύāĻž

āĻŦāĻŋāώāϝāĻŧdefault bridgeuser-defined bridge
DNS by container name✗ āύ⧇āĻ‡âœ… āφāϛ⧇
CommunicationIP āĻĻāĻŋāϝāĻŧ⧇Name āĻĻāĻŋāϝāĻŧ⧇
--link āĻĻāϰāĻ•āĻžāϰāĻšā§āϝāĻžāρ (deprecated)āύāĻž
IsolationāϏāĻŦ container āĻāĻ•āϏāĻžāĻĨ⧇Network āĻ…āύ⧁āϝāĻžāϝāĻŧā§€ āφāϞāĻžāĻĻāĻž
Production readyāύāĻžāĻšā§āϝāĻžāρ

Best practice: Production āĻŦāĻž Docker Compose-āĻ āϏāĻŦāϏāĻŽāϝāĻŧ user-defined bridge āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧋āĨ¤ Docker Compose āĻāϟāĻž automatically āĻ•āϰ⧇ — āĻĒā§āϰāϤāĻŋāϟāĻŋ docker-compose.yml āĻāĻ•āϟāĻŋ āφāϞāĻžāĻĻāĻž network āϤ⧈āϰāĻŋ āĻ•āϰ⧇ āϝ⧇āĻ–āĻžāύ⧇ service name-āχ hostname āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇āĨ¤

đŸ›Ąī¸ 11. How does Docker container networking work internally?​

Linux Networking Primitives — Docker-āĻāϰ āĻ­āĻŋāĻ¤ā§āϤāĻŋ​

Docker āύāĻŋāĻœā§‡ āϕ⧋āύ⧋ āύāϤ⧁āύ networking system āϤ⧈āϰāĻŋ āĻ•āϰ⧇āύāĻŋāĨ¤ āĻāϟāĻŋ Linux kernel-āĻāϰ āϤāĻŋāύāϟāĻŋ existing feature āĻāĻ•āϏāĻžāĻĨ⧇ āĻŦā§āϝāĻŦāĻšāĻžāϰ āĻ•āϰ⧇:

Network Namespace — āĻĒā§āϰāϤāĻŋāϟāĻŋ container āĻāĻ•āϟāĻŋ āφāϞāĻžāĻĻāĻž isolated network stack āĻĒāĻžāϝāĻŧ (āύāĻŋāϜāĻ¸ā§āĻŦ routing table, iptables rules, interfaces)āĨ¤

veth pair — āĻĻ⧁āϟāĻŋ virtual NIC āϝ⧇āϗ⧁āϞ⧋ āĻāĻ•āϟāĻŋ "wire" āĻĻāĻŋāϝāĻŧ⧇ āϏāĻ‚āϝ⧁āĻ•ā§āϤ — āĻāĻ•āϟāĻŋāϤ⧇ āϝāĻž āĻĸā§‹āϕ⧇ āĻ…āĻ¨ā§āϝāϟāĻŋ āĻĨ⧇āϕ⧇ āĻŦ⧇āϰ āĻšāϝāĻŧāĨ¤

Linux bridge (docker0) — āĻāĻ•āϟāĻŋ software-based Layer 2 switch āϝ⧇āϟāĻŋ veth pair-āϗ⧁āϞ⧋āϕ⧇ āĻāĻ•āϏāĻžāĻĨ⧇ connect āĻ•āϰ⧇āĨ¤

Docker networking internals

What is a veth pair and how does Docker use it?​

veth āĻŽāĻžāύ⧇ virtual ethernetāĨ¤ āĻāϟāĻž āϏāĻŦāϏāĻŽāϝāĻŧ āĻœā§‹āĻĄāĻŧāĻžāϝāĻŧ āφāϏ⧇ — āĻāĻ•āϟāĻž end container-āĻāϰ āϭ⧇āϤāϰ⧇ (eth0), āĻ…āĻ¨ā§āϝāϟāĻž host-āĻ (vethXXXXXX)āĨ¤ āĻāĻ•āϟāĻžāϝāĻŧ āĻ•āĻŋāϛ⧁ āĻĸ⧁āĻ•āϞ⧇ āĻ…āĻ¨ā§āϝāϟāĻžāϝāĻŧ āĻŦ⧇āϰ⧋āϝāĻŧ — āĻ āĻŋāĻ• āĻāĻ•āϟāĻž physical cable-āĻāϰ āĻŽāϤ⧋, āĻ•āĻŋāĻ¨ā§āϤ⧁ software-āĻāĨ¤Docker āĻĒā§āϰāϤāĻŋāϟāĻŋ container āϤ⧈āϰāĻŋāϰ āϏāĻŽāϝāĻŧ automatically āĻāχ āĻ•āĻžāϜāϗ⧁āϞ⧋ āĻ•āϰ⧇:

# Docker āϝāĻž āĻ•āϰ⧇ (internally):
ip link add veth3f2a1b type veth peer name eth0 # pair āϤ⧈āϰāĻŋ
ip link set eth0 netns <container-pid> # eth0 āϕ⧇ container-āĻ āĻĻāĻŋāϝāĻŧ⧇ āĻĻ⧇āĻ“āϝāĻŧāĻž
ip addr add 172.17.0.2/16 dev eth0 # container-āĻ IP assign
ip link set veth3f2a1b up # host-side āϚāĻžāϞ⧁ āĻ•āϰāĻž

# verify āĻ•āϰāϤ⧇:
ip link show type veth # āϏāĻŦ veth pair āĻĻ⧇āĻ–āĻž āϝāĻžāĻŦ⧇

What is the docker0 bridge interface?​

Docker bridge network internals

docker0 āĻšāϞ⧋ Linux-āĻāϰ bridge module āĻĻāĻŋāϝāĻŧ⧇ āϤ⧈āϰāĻŋ āĻāĻ•āϟāĻŋ virtual network switchāĨ¤ āĻāϟāĻŋ Layer 2-āĻ āĻ•āĻžāϜ āĻ•āϰ⧇ — MAC address āĻĻ⧇āϖ⧇ packet forward āĻ•āϰ⧇, āĻ āĻŋāĻ• physical switch-āĻāϰ āĻŽāϤ⧋āĨ¤

veth-āĻāϰ host-side end āϗ⧁āϞ⧋ āϕ⧋āĻĨāĻžāĻ“ connect āĻšāϤ⧇ āĻšāĻŦ⧇āĨ¤ docker0 āĻšāϞ⧋ āϏ⧇āχ virtual switch (Linux bridge) — āϏāĻŦ container-āĻāϰ vethXXXX āϗ⧁āϞ⧋ āĻāχ bridge-āĻ plug in āĻšāϝāĻŧāĨ¤

# docker0 āĻĻ⧇āĻ–āĻž:
ip addr show docker0
# → inet 172.17.0.1/16 — āĻāϟāĻžāχ āϏāĻŦ container-āĻāϰ default gateway

# bridge-āĻ āϕ⧋āύ āϕ⧋āύ veth attached āφāϛ⧇ āĻĻ⧇āĻ–āĻž:
bridge link show
# → veth3f2a1b master docker0 state forwarding

# container-āĻāϰ routing table:
docker exec mycontainer ip route
# → default via 172.17.0.1 dev eth0 ← docker0-āϕ⧇āχ gateway āĻšāĻŋāϏ⧇āĻŦ⧇ āĻĻ⧇āϖ⧇

docker0 āĻāĻ•āϟāĻŋ Layer 2 switch āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰ⧇ — same network-āĻ āĻĨāĻžāĻ•āĻž container-āϗ⧁āϞ⧋āϰ āĻŽāĻ§ā§āϝ⧇ frame forward āĻ•āϰ⧇āĨ¤ Internet-āĻ āϝ⧇āϤ⧇ āĻšāϞ⧇ packet docker0 → host eth0 → NAT → internet āĻĒāĻĨ⧇ āϝāĻžāϝāĻŧāĨ¤


How does Docker implement inter-container communication (ICC)?​

āĻĻ⧁āϟāĻŋ container āϝāĻ–āύ same bridge network-āĻ āĻĨāĻžāϕ⧇, āϤāĻ–āύ āϤāĻžāϰāĻž docker0-āĻāϰ āĻŽāĻžāĻ§ā§āϝāĻŽā§‡ āϏāϰāĻžāϏāϰāĻŋ āĻ•āĻĨāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ Kernel-āĻ āĻāϟāĻŋ implement āĻšāϝāĻŧ iptables FORWARD chain āĻĻāĻŋāϝāĻŧ⧇āĨ¤

Container A (172.17.0.2) → vethA → docker0 → vethB → Container B (172.17.0.3)

Inter-container communication packet flow

Docker daemon āĻĻ⧁āϟāĻŋ mode support āĻ•āϰ⧇:

# ICC enable (default) — FORWARD chain-āĻ ACCEPT rule
dockerd --icc=true

# ICC disable — FORWARD chain-āĻ DROP rule, explicit --link āĻ›āĻžāĻĄāĻŧāĻž āĻ•āĻĨāĻž āĻšāĻŦ⧇ āύāĻž
dockerd --icc=false

iptables-āĻ āĻāϟāĻŋ āĻāĻ­āĻžāĻŦ⧇ āĻĻ⧇āĻ–āĻž āϝāĻžāϝāĻŧ:

iptables -L FORWARD -n
# Chain FORWARD (policy DROP)
# DOCKER-USER all -- 0.0.0.0/0 0.0.0.0/0
# DOCKER-ISOLATION-STAGE-1 all -- ...
# ACCEPT all -- 0.0.0.0/0 0.0.0.0/0 ctstate RELATED,ESTABLISHED
# DOCKER all -- 0.0.0.0/0 0.0.0.0/0
# ACCEPT all -- 0.0.0.0/0 0.0.0.0/0 (icc=true āĻšāϞ⧇)

āφāϞāĻžāĻĻāĻž network-āĻ āĻĨāĻžāĻ•āĻž container-āϗ⧁āϞ⧋ by default āĻāϕ⧇ āĻ…āĻĒāϰ⧇āϰ āϏāĻžāĻĨ⧇ āĻ•āĻĨāĻž āĻŦāϞāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž — āϤāĻžāĻĻ⧇āϰ āĻŽāĻ§ā§āϝ⧇ āϕ⧋āύ⧋ bridge connection āύ⧇āχāĨ¤


How does port mapping (-p) work at the kernel level?​

-p 8080:80 āĻĻāĻŋāϞ⧇ āĻŽāύ⧇ āĻšāϝāĻŧ Docker āĻ•āĻŋāϛ⧁ magic āĻ•āϰāϛ⧇ — āφāϏāϞ⧇ āĻāϟāĻŋ āϏāĻŽā§āĻĒā§‚āĻ°ā§āĻŖāĻ­āĻžāĻŦ⧇ iptables NAT rules āĻĻāĻŋāϝāĻŧ⧇ implement āĻ•āϰāĻžāĨ¤

docker run -d -p 8080:80 nginx

Port mapping NAT flow

āĻāχ command-āϟāĻŋ āϚāĻžāϞāĻžāϞ⧇ Docker āĻĒāĻ°ā§āĻĻāĻžāϰ āφāĻĄāĻŧāĻžāϞ⧇ āĻĻ⧁āϟāĻŋ iptables rule āϝ⧋āĻ— āĻ•āϰ⧇:

# Rule ā§§ — Inbound: DNAT (Destination NAT)
# āĻŦāĻžāχāϰ⧇ āĻĨ⧇āϕ⧇ host:8080 āφāϏāĻž packet-āĻāϰ destination āĻŦāĻĻāϞ⧇ āĻĻāĻžāĻ“ → container:80
iptables -t nat -A DOCKER \
-p tcp --dport 8080 \
-j DNAT --to-destination 172.17.0.2:80

# Rule ⧍ — Outbound: MASQUERADE
# container āĻĨ⧇āϕ⧇ āĻŦāĻžāχāϰ⧇ āϝāĻžāĻ“āϝāĻŧāĻž packet-āĻāϰ source IP āĻŦāĻĻāϞ⧇ host-āĻāϰ IP āĻĻāĻžāĻ“
iptables -t nat -A POSTROUTING \
-s 172.17.0.2/32 \
-d 172.17.0.2/32 \
-p tcp --dport 80 \
-j MASQUERADE

Packet journey āϟāĻž step-by-step:

Client → host:8080
↓ iptables PREROUTING (DNAT)
↓ destination āĻŦāĻĻāϞ⧇ → 172.17.0.2:80
↓ kernel routing → docker0 bridge
↓ veth pair → container-āĻāϰ eth0
↓ nginx process port 80-āĻ receive āĻ•āϰ⧇

āϤ⧁āĻŽāĻŋ āύāĻŋāĻœā§‡ āĻāχ rules āĻĻ⧇āĻ–āϤ⧇ āĻĒāĻžāϰāĻŦ⧇:

iptables -t nat -L -n --line-numbers
# Chain DOCKER (2 references)
# num target prot opt source destination
# 1 DNAT tcp -- 0.0.0.0/0 0.0.0.0/0 tcp dpt:8080 to:172.17.0.2:80

āĻŽā§‚āϞ āĻ•āĻĨāĻž āĻšāϞ⧋ — Docker networking āĻŽā§‚āϞāϤ āϤāĻŋāύāϟāĻŋ Linux kernel feature-āĻāϰ orchestration: network namespace āĻĻāĻŋāϝāĻŧ⧇ isolation, veth pair āĻĻāĻŋāϝāĻŧ⧇ connectivity, āĻāĻŦāĻ‚ iptables āĻĻāĻŋāϝāĻŧ⧇ NAT āĻ“ access controlāĨ¤ Docker daemon āĻļ⧁āϧ⧁ āĻāχ tools-āϗ⧁āϞ⧋ āϏāĻ āĻŋāĻ• āϏāĻŽāϝāĻŧ⧇ āϏāĻ āĻŋāĻ•āĻ­āĻžāĻŦ⧇ configure āĻ•āϰ⧇āĨ¤

🌍 12. How do containers communicate with each other and with the outside world?​

docker_container_communications Path A — Container ↔ Container (same network): āĻāĻ•āχ bridge network-āĻ āĻĨāĻžāĻ•āϞ⧇ traffic āϏāϰāĻžāϏāϰāĻŋ docker0 bridge āĻĻāĻŋāϝāĻŧ⧇ āϝāĻžāϝāĻŧāĨ¤ NAT āϞāĻžāϗ⧇ āύāĻž, internet-āĻ āϝāĻžāϝāĻŧ āύāĻžāĨ¤ User-defined network-āĻ container name āĻĻāĻŋāϝāĻŧ⧇āχ reach āĻ•āϰāĻž āϝāĻžāϝāĻŧāĨ¤

Path B — Container → Internet (outbound): Container-āĻāϰ packet docker0 → eth0 āĻĒāĻĨ⧇ āϝāĻžāϝāĻŧāĨ¤ iptables POSTROUTING chain-āĻ MASQUERADE rule container-āĻāϰ private IP (172.17.x.x) āϕ⧇ host-āĻāϰ public IP-āϤ⧇ āĻŦāĻĻāϞ⧇ āĻĻ⧇āϝāĻŧāĨ¤

Path C — Internet → Container (inbound): -p 8080:80 āĻĻāĻŋāϞ⧇ iptables PREROUTING-āĻ DNAT rule āϤ⧈āϰāĻŋ āĻšāϝāĻŧāĨ¤ Host-āĻāϰ 8080-āĻ āφāϏāĻž packet-āĻāϰ destination 172.17.0.2:80-āĻ rewrite āĻšāϝāĻŧāĨ¤


What is the difference between exposing a port (EXPOSE) and publishing a port (-p)?​

āĻāϟāĻž āĻļ⧁āϧ⧁āĻŽāĻžāĻ¤ā§āϰ documentation — container āϕ⧋āύ port-āĻ listen āĻ•āϰāĻžāϰ āχāĻšā§āĻ›āĻž āϰāĻžāϖ⧇ āϏ⧇āϟāĻž āϜāĻžāύāĻžāϝāĻŧāĨ¤ āϕ⧋āύ⧋ actual binding āĻšāϝāĻŧ āύāĻž, host-āĻ āϕ⧋āύ⧋ port āĻ–ā§‹āϞ⧇ āύāĻžāĨ¤ Same network-āĻāϰ āĻ…āĻ¨ā§āϝ container āĻāχ port reach āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āĻŦāĻžāχāϰ⧇āϰ world āĻĒāĻžāϰ⧇ āύāĻžāĨ¤

# Dockerfile
EXPOSE 80 # āĻļ⧁āϧ⧁ āĻŦāϞāϛ⧇ — "āφāĻŽāĻŋ 80-āĻ listen āĻ•āϰāĻŦ"
EXPOSE 80/tcp
EXPOSE 53/udp

-p (docker run): āĻāϟāĻž actual action — host-āĻ port bind āĻ•āϰ⧇ āĻāĻŦāĻ‚ iptables-āĻ DNAT rule āϤ⧈āϰāĻŋ āĻ•āϰ⧇āĨ¤ āĻāĻ›āĻžāĻĄāĻŧāĻž docker-proxy process-āĻ“ start āĻšāϝāĻŧāĨ¤

# Syntax
docker run -p [host_ip:]<host_port>:<container_port>[/protocol]

docker run -p 8080:80 nginx # 0.0.0.0:8080 → container:80
docker run -p 127.0.0.1:8080:80 nginx # āĻļ⧁āϧ⧁ localhost āĻĨ⧇āϕ⧇
docker run -p 80 nginx # random host port → container:80
docker run -P nginx # āϏāĻŦ EXPOSE āĻ•āϰāĻž port publish āĻ•āϰ⧋

How does Docker handle container-to-container communication across hosts?​

Single host-āĻ docker0 bridge āĻ•āĻžāϜ āĻ•āϰ⧇, āĻ•āĻŋāĻ¨ā§āϤ⧁ āφāϞāĻžāĻĻāĻž host-āĻ āĻĨāĻžāĻ•āĻž container āϗ⧁āϞ⧋ āύāĻŋāĻœā§‡āϰāĻž āύāĻŋāĻœā§‡āϰāĻž reach āĻ•āϰāϤ⧇ āĻĒāĻžāϰ⧇ āύāĻž — āĻ•āĻžāϰāĻŖ 172.17.x.x address āϗ⧁āϞ⧋ private āĻāĻŦāĻ‚ host-āĻāϰ āĻŦāĻžāχāϰ⧇ routable āύāĻžāĨ¤

āϏāĻŽāĻžāϧāĻžāύ⧇āϰ āωāĻĒāĻžāϝāĻŧ:

ā§§. Overlay Network    → Docker Swarm / Kubernetes (āϏāĻŦāĻšā§‡āϝāĻŧ⧇ native)
⧍. Host Network → container-āĻāϰ port directly expose āĻ•āϰ⧋, IP āĻĻāĻŋāϝāĻŧ⧇ reach āĻ•āϰ⧋
ā§Š. External Load Balancer → HAProxy, Nginx, Traefik
ā§Ē. Service Mesh → Consul, Istio (advanced)

Overlay network āĻ›āĻžāĻĄāĻŧāĻž manually āĻ•āϰāϤ⧇ āĻšāϞ⧇:

# Host A-āϤ⧇ container run āĻ•āϰ⧋, port publish āĻ•āϰ⧋
docker run -p 5432:5432 postgres

# Host B-āϤ⧇ container āĻĨ⧇āϕ⧇ Host A-āϕ⧇ IP āĻĻāĻŋāϝāĻŧ⧇ reach āĻ•āϰ⧋
docker run -e DB_HOST=192.168.1.10 -e DB_PORT=5432 my-app

āĻāϟāĻž brittle — overlay network-āχ āϏāĻ āĻŋāĻ• āϏāĻŽāĻžāϧāĻžāύāĨ¤


How do you connect a container to multiple networks?​

āĻāĻ•āϟāĻŋ container āĻāĻ•āϏāĻžāĻĨ⧇ āĻāĻ•āĻžāϧāĻŋāĻ• network-āĻ āĻĨāĻžāĻ•āϤ⧇ āĻĒāĻžāϰ⧇āĨ¤ āĻāϟāĻž āĻĻāϰāĻ•āĻžāϰ āĻšāϝāĻŧ āϝāĻ–āύ container-āϕ⧇ bridge āĻšāĻŋāϏ⧇āĻŦ⧇ āĻ•āĻžāϜ āĻ•āϰāϤ⧇ āĻšāϝāĻŧ — āϝ⧇āĻŽāύ āĻāĻ•āϟāĻŋ api container āϝ⧇āϟāĻž frontend-net āĻĨ⧇āϕ⧇āĻ“ accessible, āφāĻŦāĻžāϰ backend-net-āĻāĻ“ āφāϛ⧇āĨ¤

Docker Compose-āĻ:

services:
nginx:
image: nginx
networks:
- frontend-net # āĻļ⧁āϧ⧁ frontend-āĻ

api:
image: my-api
networks:
- frontend-net # nginx āĻĨ⧇āϕ⧇ reach āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇
- backend-net # db-āϕ⧇āĻ“ reach āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇

db:
image: postgres
networks:
- backend-net # āĻļ⧁āϧ⧁ backend-āĻ (nginx reach āĻ•āϰāϤ⧇ āĻĒāĻžāϰāĻŦ⧇ āύāĻž)

networks:
frontend-net:
backend-net:

āĻŽā§‚āϞ takeaway: EXPOSE āĻšāϞ⧋ blueprint, -p āĻšāϞ⧋ actual wiringāĨ¤ Overlay network-āχ multi-host communication-āĻāϰ āϏāĻ āĻŋāĻ• āϏāĻŽāĻžāϧāĻžāύāĨ¤ āφāϰ multiple network āĻĻāĻŋāϝāĻŧ⧇ fine-grained isolation āϤ⧈āϰāĻŋ āĻ•āϰāĻž āϝāĻžāϝāĻŧ — āϝ⧇āϟāĻž production architecture-āĻāϰ best practiceāĨ¤

13. How do you disable inter-container communication on a custom bridge network?​

docker_icc_control