2024 - 两台CentOS服务器上的1000个Docker容器（每台500个）之间实现UDP通 ...

两台CentOS服务器上的1000个Docker容器（每台500个）之间实现UDP通信(C语言版本) 给女朋友对象写得，她不会，我就写了一个

• 为了帮助您在两台CentOS服务器上的1000个Docker容器（每台500个）之间实现UDP通信，我将详细地逐步引导您完成整个过程。我们将使用C语言编写UDP服务器和客户端程序，并使用Docker来管理容器和网络配置。
  
• 我会在每个步调中明白指出您必要修改的地方，以及必要特别留意的事项。由于您是初学者，我会只管以简单易懂的方式来表明。
  
• 请您一步一步来看 ，仔细阅读里面相关的留意事项哦~~
  

重点：

❤️：你拿到事后，你先仔细的全部浏览一遍，再去动手操纵哦~

---

目录

• 情况准备
  
  
  
  • 安装Docker
    
  • 检查网络连通性
    
  
  
• 编写UDP服务器程序
  
  
  
  • 代码示例
    
  • 详细注释
    
  
  
• 编写UDP客户端程序
  
  
  
  • 代码示例
    
  • 详细注释
    
  
  
• 创建Docker镜像
  
  
  
  • 编写Dockerfile
    
  • 构建镜像
    
  
  
• 运行服务器容器（服务器A）
  
  
  
  • 编写运行脚本
    
  • 表明脚本内容
    
  
  
• 运行客户端容器（服务器B）
  
  
  
  • 编写运行脚本
    
  • 表明脚本内容
    
  
  
• 网络和防火墙配置
  
  
  
  • 修改防火墙设置
    
  • 检查网络连接
    
  
  
• 验证通信
  
  
  
  • 检查服务器日志
    
  • 确认消息接收
    
  
  
• 留意事项和可能的题目
  
  
  
  • 体系资源限制
    
  • 防火墙和安全性
    
  • 日志和监控
    
  
  
• 总结
  

---

1. 情况准备

1.1 安装Docker （这个我们安装了，可以 跳过了！❤️）

在两台CentOS服务器上都必要安装Docker。如果还未安装，请按照以下步调进行：

1. # 更新包索引
2. sudo yum update -y
4. # 安装必要的包
5. sudo yum install -y yum-utils device-mapper-persistent-data lvm2
7. # 添加Docker仓库
8. sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
10. # 安装Docker CE
11. sudo yum install -y docker-ce docker-ce-cli containerd.io
13. # 启动Docker服务
14. sudo systemctl start docker
16. # 设置Docker开机自启
17. sudo systemctl enable docker

复制代码

留意：

• 权限题目：默认情况下，只有root用户或docker组的用户才能运行Docker命令。为了方便，您可以将当前用户添加到docker组：
  
  1. sudo usermod -aG docker $(whoami)

  复制代码
  然退却出并重新登录以使更改生效。
  

1.2 检查网络连通性（但是 我们必要 检测两台服务器是否可以走的通的！⚠️）（从这一步出发 ❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️❤️）

确保两台服务器之间可以互相访问。

• 测试连接：
  
  1. # 在服务器B上，尝试ping服务器A
  2. ping <服务器A的IP地址>

  复制代码
• 留意：如果ping不通，可能必要检查网络配置或联系网络管理员。
  

---

2. 编写UDP服务器程序 （下面是 重点了，请您仔细阅读，一步一步来，不要着急）

在服务器A上，创建一个目录来存放代码：

1. mkdir ~/udp_project
2. cd ~/udp_project

复制代码

2.1 代码示例

创建一个名为udp_server.c的文件，内容如下：

1. // udp_server.c
3. /*
4. * UDP服务器程序
5. * 监听指定的UDP端口并接收消息。
6. *
7. * 编译：
8. *   gcc -o udp_server udp_server.c
9. *
10. * 用法：
11. *   ./udp_server <端口号>
12. */
14. #include <stdio.h>
15. #include <stdlib.h>
16. #include <unistd.h>
17. #include <string.h>
18. #include <sys/types.h>
19. #include <sys/socket.h>
20. #include <arpa/inet.h>
22. #define BUFFER_SIZE 1024  // 接收消息的最大缓冲区大小
24. int main(int argc, char *argv[]) {
25.     int sockfd;                        // 套接字文件描述符
26.     int port;                          // 监听的端口号
27.     struct sockaddr_in server_addr;    // 服务器地址结构
28.     struct sockaddr_in client_addr;    // 客户端地址结构
29.     char buffer[BUFFER_SIZE];          // 接收消息的缓冲区
30.     socklen_t addr_len;                // 客户端地址结构的大小
31.     ssize_t recv_len;                  // 接收到的消息长度
33.     // 检查参数数量是否正确
34.     if (argc != 2) {
35.         fprintf(stderr, "用法: %s <端口号>\n", argv[0]);
36.         exit(1);
37.     }
39.     // 将端口号从字符串转换为整数
40.     port = atoi(argv[1]);
42.     // 创建UDP套接字
43.     if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
44.         perror("socket 创建失败");
45.         exit(1);
46.     }
48.     // 将服务器地址结构清零
49.     memset(&server_addr, 0, sizeof(server_addr));
51.     // 设置地址族为AF_INET（IPv4）
52.     server_addr.sin_family = AF_INET;
54.     // 监听所有可用的网络接口
55.     server_addr.sin_addr.s_addr = INADDR_ANY;
57.     // 设置端口号（将主机字节序转换为网络字节序）
58.     server_addr.sin_port = htons(port);
60.     // 将套接字绑定到指定的端口上
61.     if (bind(sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) {
62.         perror("绑定失败");
63.         close(sockfd);
64.         exit(1);
65.     }
67.     printf("UDP服务器正在监听端口 %d\n", port);
69.     // 无限循环，持续接收消息
70.     while (1) {
71.         addr_len = sizeof(client_addr);
72.         // 接收消息
73.         recv_len = recvfrom(sockfd, buffer, BUFFER_SIZE - 1, 0,
74.                             (struct sockaddr *)&client_addr, &addr_len);
75.         if (recv_len < 0) {
76.             perror("接收失败");
77.             continue;
78.         }
80.         // 在接收到的数据末尾添加字符串结束符
81.         buffer[recv_len] = '\0';
83.         // 打印客户端信息和消息内容
84.         printf("从 %s:%d 收到消息：%s\n",
85.                inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port), buffer);
86.     }
88.     // 关闭套接字（实际上不会到达这里）
89.     close(sockfd);
90.     return 0;
91. }

复制代码

2.2 详细注释

• 头文件包罗：包罗了网络编程和基本的C库函数所需的头文件。
  
• 宏定义：定义了缓冲区巨细BUFFER_SIZE。
  
• main函数参数检查：确保运行程序时传入了正确的参数（端口号）。
  
• 套接字创建：使用socket()函数创建一个UDP套接字。
  
• 地址布局初始化：使用memset()清零，然后设置地址族、IP地址和端口号。
  
• 绑定套接字：使用bind()函数将套接字绑定到指定的IP和端口上。
  
• 接收循环：使用recvfrom()函数接收来自客户端的消息，并打印出来。
  

---

3. 编写UDP客户端程序

在服务器B上，同样创建一个目录：

1. mkdir ~/udp_project
2. cd ~/udp_project

复制代码

3.1 代码示例

创建一个名为udp_client.c的文件，内容如下：

1. // udp_client.c
3. /*
4. * UDP客户端程序
5. * 向指定的IP地址和UDP端口发送消息。
6. *
7. * 编译：
8. *   gcc -o udp_client udp_client.c
9. *
10. * 用法：
11. *   ./udp_client <服务器IP> <服务器端口> <消息>
12. */
14. #include <stdio.h>
15. #include <stdlib.h>
16. #include <unistd.h>
17. #include <string.h>
18. #include <sys/types.h>
19. #include <sys/socket.h>
20. #include <arpa/inet.h>
22. #define BUFFER_SIZE 1024  // 消息的最大缓冲区大小
24. int main(int argc, char *argv[]) {
25.     int sockfd;                        // 套接字文件描述符
26.     char *server_ip;                   // 服务器IP地址
27.     int server_port;                   // 服务器端口号
28.     struct sockaddr_in server_addr;    // 服务器地址结构
29.     char *message;                     // 要发送的消息
30.     ssize_t sent_len;                  // 发送的消息长度
32.     // 检查参数数量是否正确
33.     if (argc != 4) {
34.         fprintf(stderr, "用法: %s <服务器IP> <服务器端口> <消息>\n", argv[0]);
35.         exit(1);
36.     }
38.     // 获取服务器IP、端口和消息
39.     server_ip = argv[1];
40.     server_port = atoi(argv[2]);
41.     message = argv[3];
43.     // 创建UDP套接字
44.     if ((sockfd = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
45.         perror("socket 创建失败");
46.         exit(1);
47.     }
49.     // 将服务器地址结构清零
50.     memset(&server_addr, 0, sizeof(server_addr));
52.     // 设置地址族为AF_INET（IPv4）
53.     server_addr.sin_family = AF_INET;
55.     // 将IP地址从文本转换为二进制形式
56.     if (inet_pton(AF_INET, server_ip, &server_addr.sin_addr) <= 0) {
57.         fprintf(stderr, "无效的IP地址：%s\n", server_ip);
58.         close(sockfd);
59.         exit(1);
60.     }
62.     // 设置端口号（网络字节序）
63.     server_addr.sin_port = htons(server_port);
65.     // 发送消息到服务器
66.     sent_len = sendto(sockfd, message, strlen(message), 0,
67.                       (struct sockaddr *)&server_addr, sizeof(server_addr));
68.     if (sent_len < 0) {
69.         perror("发送失败");
70.         close(sockfd);
71.         exit(1);
72.     }
74.     printf("已向 %s:%d 发送消息：%s\n", server_ip, server_port, message);
76.     // 关闭套接字
77.     close(sockfd);
78.     return 0;
79. }

复制代码

3.2 详细注释

• 参数检查：确保提供了服务器IP、端口和消息。
  
• 套接字创建：同样使用socket()函数创建UDP套接字。
  
• 地址布局设置：将服务器的IP和端口填入server_addr布局。
  
• 发送消息：使用sendto()函数发送消息到服务器。
  

---

4. 创建Docker镜像

4.1 编写Dockerfile

在两台服务器的udp_project目录下，创建一个名为Dockerfile的文件，内容如下：

1. # 使用官方的GCC镜像作为基础镜像
2. FROM gcc:latest
4. # 在容器内创建工作目录
5. WORKDIR /usr/src/app
7. # 将源代码复制到容器内
8. COPY udp_server.c udp_client.c ./
10. # 编译UDP服务器和客户端程序
11. RUN gcc -o udp_server udp_server.c
12. RUN gcc -o udp_client udp_client.c
14. # 暴露默认端口（可在运行时覆盖）
15. EXPOSE 5000/udp
17. # 设置默认命令（可在运行容器时覆盖）
18. CMD ["./udp_server", "5000"]

复制代码

表明：

• FROM：指定底子镜像为官方的gcc镜像，包罗了GCC编译器。
  
• WORKDIR：设置工作目录为/usr/src/app。
  
• COPY：将udp_server.c和udp_client.c复制到容器内的工作目录。
  
• RUN：编译服务器和客户端程序。
  
• EXPOSE：暴露5000端口的UDP协议（可在运行时指定其他端口）。
  
• CMD：设置容器启动时默认执行的命令。
  

4.2 构建镜像

在两个服务器的udp_project目录下，执行以下命令构建Docker镜像：

1. docker build -t udp_app .

复制代码

留意：

• 镜像名称：udp_app是镜像的名称，您可以根据必要更改。
  
• 构建过程：Docker会根据Dockerfile的指令一步步构建镜像。
  

---

5. 运行服务器容器（服务器A）

5.1 编写运行脚本

在服务器A的udp_project目录下，创建一个名为run_servers.sh的脚本，内容如下：

1. #!/bin/bash
3. # 要运行的服务器容器数量
4. NUM_CONTAINERS=500
6. # 服务器的基础端口号
7. BASE_PORT=5000
9. for (( i=1; i<=NUM_CONTAINERS; i++ ))
10. do
11.     CONTAINER_NAME="server_$i"
12.     HOST_PORT=$((BASE_PORT + i))
13.     CONTAINER_PORT=$((BASE_PORT + i))
15.     # 运行服务器容器
16.     docker run -d --name $CONTAINER_NAME -p $HOST_PORT:$CONTAINER_PORT/udp udp_app ./udp_server $CONTAINER_PORT
18.     echo "已在端口 $HOST_PORT 启动服务器容器 $CONTAINER_NAME"
19. done

复制代码

5.2 表明脚本内容

• 循环：从1到500，依次启动500个容器。
  
• 容器名称：server_1、server_2、…、server_500。
  
• 端口设置：
  
  
  
  • 主机端口：HOST_PORT，从5001到5500。
    
  • 容器端口：CONTAINER_PORT，与主机端口相同。
    
  
  
• 运行容器：
  
  
  
  • -d：配景运行容器。
    
  • --name：指定容器名称。
    
  • -p：将主机的UDP端口映射到容器的UDP端口。
    
  • udp_app：使用之前构建的镜像。
    
  • ./udp_server $CONTAINER_PORT：在容器内执行的命令，指定监听的端口。
    
  
  

必要您修改的地方：

• NUM_CONTAINERS：如果您想运行差别数量的容器，可以修改这个值。
  

---

6. 运行客户端容器（服务器B）

6.1 编写运行脚本

在服务器B的udp_project目录下，创建一个名为run_clients.sh的脚本，内容如下：

1. #!/bin/bash
3. # 要运行的客户端容器数量
4. NUM_CONTAINERS=500
6. # 客户端的基础端口号（用于区分消息）
7. BASE_PORT=5000
9. # 服务器A的IP地址
10. SERVER_A_IP="请替换为服务器A的实际IP地址"
12. for (( i=1; i<=NUM_CONTAINERS; i++ ))
13. do
14.     CONTAINER_NAME="client_$i"
15.     SERVER_PORT=$((BASE_PORT + i))
16.     MESSAGE="来自客户端 $i 的问候"
18.     # 运行客户端容器
19.     docker run -d --name $CONTAINER_NAME udp_app ./udp_client $SERVER_A_IP $SERVER_PORT "$MESSAGE"
21.     echo "已启动客户端容器 $CONTAINER_NAME，发送到 $SERVER_A_IP:$SERVER_PORT"
22. done

复制代码

6.2 表明脚本内容

• 服务器IP地址：必要将SERVER_A_IP替换为服务器A的实际IP地址。
  
• 循环：启动500个客户端容器。
  
• 容器名称：client_1、client_2、…、client_500。
  
• 服务器端口：与服务器容器的端口对应，从5001到5500。
  
• 消息内容：每个客户端发送一条包罗本身编号的消息。
  
• 运行容器：
  
  
  
  • -d：配景运行。
    
  • --name：容器名称。
    
  • udp_app：使用同样的镜像。
    
  • ./udp_client $SERVER_A_IP $SERVER_PORT "$MESSAGE"：在容器内执行的命令，指定服务器IP、端口和消息。
    
  
  

必要您修改的地方：

• SERVER_A_IP：❤️肯定要替换为服务器A的实际IP地址，否则客户端无法连接到服务器❤️。
  
• NUM_CONTAINERS：如果必要，可以修改客户端容器的数量❤️。
  

---

7. 网络和防火墙配置

7.1 修改防火墙设置（服务器A）

为了允许UDP流量通过指定的端口，必要修改防火墙设置。

1. # 添加端口范围的UDP规则
2. sudo firewall-cmd --zone=public --add-port=5001-5500/udp --permanent
4. # 重新加载防火墙
5. sudo firewall-cmd --reload

复制代码

留意：

• 防火墙软件：如果使用的是firewalld，上述命令实用。如果使用其他防火墙，必要使用相应的命令。
  
• 端口范围：确保与您在脚本中使用的端口范围同等。
  

7.2 检查网络连接

在服务器B上，测试是否可以连接到服务器A的指定端口。

1. # 使用nc（netcat）工具测试UDP端口
2. echo "测试" | nc -u -v <服务器A的IP地址> 5001

复制代码

如果连接乐成，说明网络连通性正常。

---

8. 验证通信

8.1 检查服务器日志

在服务器A上，检察某个服务器容器的日志，比方server_1：

1. docker logs server_1

复制代码

您应该看到类似以下的输出：

1. UDP服务器正在监听端口 5001
2. 从 <客户端IP>:<端口> 收到消息：来自客户端 1 的问候

复制代码

8.2 确认消息接收

• 多个容器日志：可以检查其他服务器容器的日志，确认是否收到了对应客户端的消息。
  
• 故障排查：如果没有收到消息，请检查以下内容：
  
  
  
  • 服务器A的防火墙设置：确保开放了必要的UDP端口。
    
  • 服务器IP地址是否正确：在run_clients.sh脚本中。
    
  • 网络连通性：使用ping或nc测试。
    
  
  

---

9. 留意事项和可能的题目

9.1 体系资源限制

• CPU和内存：运行大量容器会占用大量体系资源。请监控体系的CPU和内存使用情况。
  
• 文件形貌符限制：可能必要增加体系的文件形貌符限制。
  
  1. # 临时增加限制
  2. ulimit -n 65535

  复制代码

9.2 防火墙和安全性

• 安全策略：确保只允允许信任的流量。对于生产情况，发起使用VPN或设置访问控制。
  
• 端口范围：开放大量端口可能存在安全风险，务必确保网络的安全性。
  

9.3 日志和监控

• 日志收集：考虑使用日志收集工具，如ELK堆栈，来集中管理容器日志。
  
• 监控工具：使用监控工具，如Prometheus和Grafana，监控体系性能和容器状态。
  

---

10. 总结

通过以上步调，您已经乐成在两台CentOS服务器上的1000个Docker容器之间创建了UDP通信。我们使用C语言编写了简单的UDP服务器和客户端程序，并使用Docker来管理容器的部署。
您必要留意的关键点：

• IP地址和端口号：确保在脚本和代码中使用正确的IP地址和端口号。
  
• 防火墙配置：确保防火墙允许必要的UDP流量通过。
  
• 体系资源：监控体系的资源使用，防止过载。
  
• 代码编译：如果修改了C代码，必要重新构建Docker镜像。
  

---

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。