Docker容器中UDP服务器与本地客户端连接失败问题求助

我是Docker与网络领域的新手，目前将一个具备两个UDP收发端口的服务器部署在Docker容器中，客户端运行在本地主机，目标是实现两者的标志位同步，但遇到两个问题：

• 使用命令docker run -p 5555:5550/udp -p 5556:5559/udp digitaltwin:latest启动容器时，服务器与客户端无法连接同步，各自独立运行
• 使用命令docker run -p 5555:5555/udp -p 5556:5556/udp digitaltwin:latest启动时，启动客户端提示地址已占用

现有代码 #

服务器代码（Physical.py） #

import socket
import random


class Physical:

    def __init__(self, remote_ip, remote_port, port, t):
        self.remote_ip = remote_ip
        self.remote_port = remote_port
        self.port = port
        self.t = t
        self.tick = 0
        self.ctrl_flag = 0
        self.ctrl_url = None
        self.sw_state = 0
        self.sw_package = None
        self.receive_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.receive_socket.bind(("0.0.0.0", self.port))

    def run(self):
        while True:
            # input here
            if random.randint(0, 20) <= 3:
                self.ctrl_flag = random.randint(0, 10)
                print("in ctrl_flag {} {}".format(self.ctrl_flag, self.tick))
            else:
                print("same ctrl_flag {} {}".format(self.ctrl_flag, self.tick))

            self.receive_sync()
            # intermediary states
            self.tick += 1
            self.send_sync()
            print("new ctrl_flag {}, {}\n".format(self.ctrl_flag, self.tick))

    def send_sync(self):
        self.send_socket.sendto("{}".format(self.ctrl_flag).encode(), (self.remote_ip, self.remote_port))

    def receive_sync(self):
        data, addr = self.receive_socket.recvfrom(256)
        self.ctrl_flag = int(data)


def main():
    phy = Physical("0.0.0.0", 5555, 5556, 0)
    phy.run()


if __name__ == "__main__":
    main()

客户端代码（Twin.py） #

import socket
import random
import asyncio

class Twin:

    def __init__(self, remote_ip, remote_port, port, t):
        self.remote_ip = remote_ip
        self.remote_port = remote_port
        self.port = port
        self.t = t
        self.tick = 0
        self.ctrl_flag = 0
        self.ctrl_url = None
        self.sw_state = 0
        self.sw_package = None
        self.receive_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        self.receive_socket.bind(("127.0.0.1", self.port))

    async def run(self):
        while True:
            await asyncio.sleep(self.t)
            # input here
            if random.randint(0, 20) <= 3:
                self.ctrl_flag = random.randint(0, 10)
                print("in ctrl_flag {}, ticket {}".format(self.ctrl_flag, self.tick))
            else:
                print("same ctrl_flag {}, ticket {}".format(self.ctrl_flag, self.tick))

            self.send_sync()
            # intermediary state
            self.tick += 1
            self.receive_sync()
            print("new ctrl_flag {}, ticket {}\n".format(self.ctrl_flag, self.tick))

    def send_sync(self):
        self.send_socket.sendto("{}".format(self.ctrl_flag).encode(), (self.remote_ip, self.remote_port))

    def receive_sync(self):
        data, addr = self.receive_socket.recvfrom(256)
        self.ctrl_flag = int(data)


def main():
    twin = Twin("127.0.0.1", 5556, 5555, 2)
    loop = asyncio.get_event_loop()
    task = loop.create_task(twin.run())
    try:
        loop.run_until_complete(task)
    except asyncio.CancelledError:
        pass


if __name__ == "__main__":
    main()

Dockerfile #

FROM python:3.9

WORKDIR /Physical

COPY . /Physical

EXPOSE 5555/udp

EXPOSE 5556/udp

ENV NAME digitaltwin

CMD ["python3", "-u", "Physical.py"]

问题根源分析 #

1. 端口映射不匹配：使用-p 5555:5550/udp -p 5556:5559/udp时，容器内端口与代码中服务器监听的5556、目标发送端口5555完全不对应，客户端发送的数据无法到达容器内的服务器。
2. 端口冲突：使用-p 5555:5555/udp -p 5556:5556/udp时，容器占用了本地的5555、5556端口，而客户端代码绑定的是本地127.0.0.1:5555，导致地址占用报错。

解决方案 #

核心思路：让容器与本地使用不重叠的端口，同时保证端口映射与代码中的目标地址一致。

1. 修改服务器代码的目标地址 #

容器内无法通过0.0.0.0访问本地主机，改用Docker内置的host.docker.internal域名指向本地主机，同时保持服务器监听端口为5556：

def main():
    # host.docker.internal 是Docker容器访问本地主机的专用域名
    phy = Physical("host.docker.internal", 5555, 5556, 0)
    phy.run()

2. 调整Docker端口映射 #

将容器内的服务器监听端口5556映射到本地未被占用的端口（比如5557），避免与客户端监听的5555冲突：

docker run -p 5557:5556/udp digitaltwin:latest

3. 修改客户端代码的目标地址 #

客户端需要将数据发送到本地映射后的端口5557，而非容器内的5556：

def main():
    # 服务器映射到本地的端口是5557，因此此处目标端口改为5557
    twin = Twin("127.0.0.1", 5557, 5555, 2)
    loop = asyncio.get_event_loop()
    task = loop.create_task(twin.run())
    try:
        loop.run_until_complete(task)
    except asyncio.CancelledError:
        pass

4. 可选优化：避免阻塞卡死 #

当前代码中receive_sync使用阻塞式recvfrom，若对方未发送数据会一直卡住。可给socket设置超时并捕获异常：
在服务器和客户端的__init__方法中添加：

self.receive_socket.settimeout(5)  # 设置5秒超时，可按需调整

修改receive_sync方法：

def receive_sync(self):
    try:
        data, addr = self.receive_socket.recvfrom(256)
        self.ctrl_flag = int(data)
    except socket.timeout:
        print("超时未收到同步数据，保持当前flag")

运行步骤 #

1. 重新构建镜像：

docker build -t digitaltwin:latest .

2. 启动容器：

docker run -p 5557:5556/udp digitaltwin:latest

3. 在本地运行客户端：

python3 Twin.py

内容的提问来源于stack exchange，提问作者Sahar Zamanian