8.3. Port publishing

-p [адрес_host:][порт_host:]порт_container[/протокол]

docker run -p 127.0.0.1:5432:5432 postgres:17-alpine

sudo iptables -I DOCKER-USER -i eth0 -p tcp --dport 5432 -j DROP

Error response from daemon: driver failed programming external connectivity on
endpoint web: Bind for 0.0.0.0:8080 failed: port is already allocated

docker ps --format '{{.Names}}\t{{.Ports}}' | grep 8080
sudo ss -tlnp | grep ':8080 '

docker run -d -p 8000 myimage
docker port <container> 8000

sudo iptables -t nat -S DOCKER

-A DOCKER -i docker0 -j RETURN
-A DOCKER ! -i docker0 -p tcp -m tcp --dport 8080 -j DNAT --to-destination 172.17.0.2:8000

{
  "userland-proxy": false
}

mkdir -p /tmp/bindtest && cd /tmp/bindtest

cat > app.py <<'PY'
"""Один и тот же сервер, привязка задаётся переменной окружения."""
import os
from http.server import HTTPServer, BaseHTTPRequestHandler


class H(BaseHTTPRequestHandler):
    def do_GET(self):
        self.send_response(200)
        self.end_headers()
        self.wfile.write(b"ok\n")

    def log_message(self, *args):
        pass


host = os.environ.get("BIND", "127.0.0.1")
print(f"слушаю {host}:8000", flush=True)
HTTPServer((host, 8000), H).serve_forever()
PY

cat > Dockerfile <<'EOF'
FROM python:3.13-slim
ENV PYTHONUNBUFFERED=1
WORKDIR /app
COPY app.py .
EXPOSE 8000
CMD ["python", "app.py"]
EOF

docker build -q -t bindtest . > /dev/null

echo "═══ привязка к 127.0.0.1 ═══"
docker run -d --name bad -p 18001:8000 -e BIND=127.0.0.1 bindtest > /dev/null
sleep 3
printf '  статус container:  %s\n' "$(docker inspect bad --format '{{.State.Status}}')"
printf '  логи:              %s\n' "$(docker logs bad 2>&1 | head -1)"
printf '  docker port:       %s\n' "$(docker port bad)"
printf '  curl с host:       '
curl -s -m 3 -o /dev/null -w '%{http_code}\n' http://localhost:18001/ || echo "нет ответа"
printf '  curl внутри:       '
docker exec bad python -c "
import urllib.request
print(urllib.request.urlopen('http://127.0.0.1:8000/', timeout=2).status)
"

echo
echo "═══ привязка к 0.0.0.0 ═══"
docker run -d --name good -p 18002:8000 -e BIND=0.0.0.0 bindtest > /dev/null
sleep 3
printf '  логи:              %s\n' "$(docker logs good 2>&1 | head -1)"
printf '  curl с host:       %s\n' \
    "$(curl -s -m 3 -o /dev/null -w '%{http_code}' http://localhost:18002/)"

═══ привязка к 127.0.0.1 ═══
  статус container:  running
  логи:              слушаю 127.0.0.1:8000
  docker port:       8000/tcp -> 0.0.0.0:18001
  curl с host:       000
нет ответа
  curl внутри:       200

═══ привязка к 0.0.0.0 ═══
  логи:              слушаю 0.0.0.0:8000
  curl с host:       200

docker rm -f bad good > /dev/null

docker run -d --name probe -p 18003:8000 -e BIND=127.0.0.1 bindtest > /dev/null
sleep 3

echo "═══ ss внутри namespace (через nsenter, без установки утилит) ═══"
pid="$(docker inspect -f '{{.State.Pid}}' probe)"
sudo nsenter -t "$pid" -n ss -tlnp 2>/dev/null | sed 's/^/  /'

echo "═══ то же без nsenter — через /proc/net/tcp ═══"
docker exec probe python -c "
with open('/proc/net/tcp') as f:
    next(f)
    for line in f:
        p = line.split()
        if p[3] != '0A':      # 0A = LISTEN
            continue
        addr_hex, port_hex = p[1].split(':')
        addr = '.'.join(str(int(addr_hex[i:i+2], 16)) for i in (6, 4, 2, 0))
        print(f'  слушает {addr}:{int(port_hex, 16)}')
"

docker rm -f probe > /dev/null

═══ ss внутри namespace (через nsenter, без установки утилит) ═══
  State   Recv-Q  Send-Q  Local Address:Port   Peer Address:Port
  LISTEN  0       5       127.0.0.1:8000       0.0.0.0:*
═══ то же без nsenter — через /proc/net/tcp ═══
  слушает 127.0.0.1:8000

docker run -d --name dnat -p 18004:8000 -e BIND=0.0.0.0 bindtest > /dev/null
sleep 2
ip_c="$(docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' dnat)"

echo "═══ правило, созданное публикацией ═══"
sudo iptables -t nat -S DOCKER 2>/dev/null | grep 18004 | sed 's/^/  /'

echo "═══ адрес container'а ═══"
echo "  $ip_c"

echo "═══ разрешающее правило в filter ═══"
sudo iptables -S DOCKER 2>/dev/null | grep -F "$ip_c" | sed 's/^/  /'

echo "═══ счётчик пакетов до и после запроса ═══"
before="$(sudo iptables -t nat -L DOCKER -n -v 2>/dev/null | awk '/18004/ {print $1; exit}')"
curl -s -o /dev/null http://localhost:18004/
after="$(sudo iptables -t nat -L DOCKER -n -v 2>/dev/null | awk '/18004/ {print $1; exit}')"
printf '  пакетов через правило: %s → %s\n' "${before:-0}" "${after:-0}"

═══ правило, созданное публикацией ═══
  -A DOCKER ! -i docker0 -p tcp -m tcp --dport 18004 -j DNAT --to-destination 172.17.0.2:8000
═══ адрес container'а ═══
  172.17.0.2
═══ разрешающее правило в filter ═══
  -A DOCKER -d 172.17.0.2/32 ! -i docker0 -o docker0 -p tcp -m tcp --dport 8000 -j ACCEPT
═══ счётчик пакетов до и после запроса ═══
  пакетов через правило: 0 → 1

echo "═══ кто слушает 18004 на host ═══"
sudo ss -tlnp 2>/dev/null | grep ':18004 ' | sed 's/^/  /'

echo "═══ процессы docker-proxy ═══"
ps -eo pid,args 2>/dev/null | grep '[d]ocker-proxy' | head -3 | sed 's/^/  /'

echo "═══ режим userland-proxy ═══"
docker info --format '  userland-proxy отключён: {{index .SecurityOptions}}' > /dev/null 2>&1
grep -q '"userland-proxy": *false' /etc/docker/daemon.json 2>/dev/null \
    && echo "  userland-proxy отключён в daemon.json" \
    || echo "  userland-proxy включён (умолчание)"

docker rm -f dnat > /dev/null

═══ кто слушает 18004 на host ═══
  LISTEN 0  4096  0.0.0.0:18004  0.0.0.0:*  users:(("docker-proxy",pid=48213,fd=7))
═══ процессы docker-proxy ═══
  48213 /usr/bin/docker-proxy -proto tcp -host-ip 0.0.0.0 -host-port 18004 -container-ip 172.17.0.2 -container-port 8000
═══ режим userland-proxy ═══
  userland-proxy включён (умолчание)

echo "═══ публикация на всех интерфейсах ═══"
docker run -d --name open -p 18005:8000 -e BIND=0.0.0.0 bindtest > /dev/null
sleep 3
docker port open | sed 's/^/  /'
host_ip="$(ip route get 1.1.1.1 2>/dev/null | awk '{print $7; exit}')"
printf '  через localhost:   %s\n' "$(curl -s -m 3 -o /dev/null -w '%{http_code}' http://localhost:18005/)"
printf '  через %s: %s\n' "$host_ip" "$(curl -s -m 3 -o /dev/null -w '%{http_code}' "http://$host_ip:18005/")"

echo
echo "═══ публикация только на localhost ═══"
docker run -d --name closed -p 127.0.0.1:18006:8000 -e BIND=0.0.0.0 bindtest > /dev/null
sleep 3
docker port closed | sed 's/^/  /'
printf '  через localhost:   %s\n' "$(curl -s -m 3 -o /dev/null -w '%{http_code}' http://localhost:18006/)"
printf '  через %s: %s\n' "$host_ip" \
    "$(curl -s -m 3 -o /dev/null -w '%{http_code}' "http://$host_ip:18006/" 2>/dev/null || echo 'недоступен')"

docker rm -f open closed > /dev/null

═══ публикация на всех интерфейсах ═══
  8000/tcp -> 0.0.0.0:18005
  через localhost:   200
  через 192.168.1.42: 200
═══ публикация только на localhost ═══
  8000/tcp -> 127.0.0.1:18006
  через localhost:   200
  через 192.168.1.42: 000

echo "═══ образ объявляет EXPOSE 8000 ═══"
docker image inspect bindtest --format '  ExposedPorts: {{json .Config.ExposedPorts}}'

echo "═══ запуск БЕЗ -p ═══"
docker run -d --name noexp -e BIND=0.0.0.0 bindtest > /dev/null
sleep 3
printf '  docker port:  %s\n' "$(docker port noexp || echo 'пусто')"
printf '  curl с host:  %s\n' "$(curl -s -m 3 -o /dev/null -w '%{http_code}' http://localhost:8000/ 2>/dev/null || echo '000')"

echo "═══ запуск с -P (публикует объявленные порты) ═══"
docker run -d --name withP -P -e BIND=0.0.0.0 bindtest > /dev/null
sleep 3
mapping="$(docker port withP 8000)"
printf '  docker port:  %s\n' "$mapping"
port="${mapping##*:}"
printf '  curl:         %s\n' "$(curl -s -m 3 -o /dev/null -w '%{http_code}' "http://localhost:$port/")"

docker rm -f noexp withP > /dev/null

═══ образ объявляет EXPOSE 8000 ═══
  ExposedPorts: {"8000/tcp":{}}
═══ запуск БЕЗ -p ═══
  docker port:  пусто
  curl с host:  000
═══ запуск с -P (публикует объявленные порты) ═══
  docker port:  0.0.0.0:32768
  curl:         200

docker run -d --name first -p 18007:8000 -e BIND=0.0.0.0 bindtest > /dev/null
sleep 2
echo "═══ вторая публикация того же порта ═══"
docker run -d --name second -p 18007:8000 -e BIND=0.0.0.0 bindtest 2>&1 | tail -2 | sed 's/^/  /'

echo "═══ кто занял ═══"
docker ps --format '  {{.Names}}\t{{.Ports}}' | grep 18007

docker rm -f first second > /dev/null 2>&1
docker rmi -f bindtest > /dev/null
cd /tmp && rm -rf /tmp/bindtest

═══ вторая публикация того же порта ═══
  docker: Error response from daemon: driver failed programming external
  connectivity on endpoint second: Bind for 0.0.0.0:18007 failed: port is already allocated
═══ кто занял ═══
  first	0.0.0.0:18007->8000/tcp

cat > /tmp/fwcheck.sh <<'SH'
#!/usr/bin/env bash
# Проверяет, закрывает ли ваш брандмауэр опубликованный порт.
# Выполняется локально; для полной проверки нужен второй хост.
set -uo pipefail

echo "═══ версия Docker и backend iptables ═══"
docker version --format '  Docker Engine: {{.Server.Version}}'
iptables -V 2>/dev/null | sed 's/^/  /' || sudo iptables -V | sed 's/^/  /'

echo
echo "═══ состояние брандмауэра ═══"
if command -v ufw > /dev/null 2>&1; then
    sudo ufw status | head -5 | sed 's/^/  /'
elif command -v firewall-cmd > /dev/null 2>&1; then
    sudo firewall-cmd --state 2>/dev/null | sed 's/^/  /'
else
    echo "  ufw и firewalld не установлены"
fi

echo
echo "═══ цепочка DOCKER-USER (место для ваших правил) ═══"
sudo iptables -S DOCKER-USER 2>/dev/null | sed 's/^/  /' || echo "  цепочка не найдена"

echo
echo "═══ порядок обработки ═══"
echo "  PREROUTING (nat, DNAT) → FORWARD (filter: DOCKER-USER, DOCKER) → container"
echo "  Правила для INPUT опубликованных портов НЕ касаются."
echo
echo "  Достоверная проверка доступности извне выполняется с другой машины:"
echo "    curl -m 5 http://<адрес-этого-host>:<порт>/"
SH
chmod +x /tmp/fwcheck.sh
/tmp/fwcheck.sh
rm -f /tmp/fwcheck.sh

═══ версия Docker и backend iptables ═══
  Docker Engine: 29.0.1
  iptables v1.8.10 (nf_tables)
═══ состояние брандмауэра ═══
  Status: active
  To                         Action      From
  --                         ------      ----
  22/tcp                     ALLOW       Anywhere
═══ цепочка DOCKER-USER (место для ваших правил) ═══
  -N DOCKER-USER
  -A DOCKER-USER -j RETURN
═══ порядок обработки ═══
  PREROUTING (nat, DNAT) → FORWARD (filter: DOCKER-USER, DOCKER) → container
  Правила для INPUT опубликованных портов НЕ касаются.

  Достоверная проверка доступности извне выполняется с другой машины:
    curl -m 5 http://<адрес-этого-host>:<порт>/

docker run -d --name pcheck -p 127.0.0.1:18888:8000 python:3.13-slim \
    python -m http.server 8000 --bind 0.0.0.0 > /dev/null
sleep 3
docker port pcheck
curl -s -o /dev/null -w 'localhost: %{http_code}\n' http://localhost:18888/
sudo iptables -t nat -S DOCKER | grep 18888
docker rm -f pcheck > /dev/null