RabbitMQ 集群通信机制

一、概述

RabbitMQ 集群基于 Erlang 分布式系统构建，节点间的通信是实现集群功能的核心。理解集群通信机制对于排查网络问题、优化集群性能和确保集群稳定性至关重要。

通信架构总览

mermaid

graph TB
    subgraph "RabbitMQ 集群通信"
        N1[节点1<br/>rabbit@node1]
        N2[节点2<br/>rabbit@node2]
        N3[节点3<br/>rabbit@node3]
        
        EPMD1[EPMD<br/>:4369]
        EPMD2[EPMD<br/>:4369]
        EPMD3[EPMD<br/>:4369]
        
        N1 --- EPMD1
        N2 --- EPMD2
        N3 --- EPMD3
        
        N1 <-->|25672| N2
        N2 <-->|25672| N3
        N1 <-->|25672| N3
    end
    
    subgraph "客户端通信"
        C1[生产者/消费者]
        LB[负载均衡]
    end
    
    C1 --> LB
    LB -->|5672| N1
    LB -->|5672| N2
    LB -->|5672| N3

二、核心知识点

2.1 EPMD（Erlang Port Mapper Daemon）

什么是 EPMD

EPMD 是 Erlang 分布式系统的端口映射守护进程，负责：

节点注册: 每个 Erlang 节点启动时向本地 EPMD 注册
端口映射: 维护节点名称到端口的映射关系
节点发现: 帮助节点之间相互发现和连接

EPMD 工作流程

mermaid

sequenceDiagram
    participant N1 as 节点1
    participant EPMD1 as EPMD@node1
    participant EPMD2 as EPMD@node2
    participant N2 as 节点2
    
    N1->>EPMD1: 注册节点 rabbit@node1:25672
    EPMD1-->>N1: 注册成功
    
    N2->>EPMD2: 注册节点 rabbit@node2:25672
    EPMD2-->>N2: 注册成功
    
    N1->>EPMD2: 查询 rabbit@node2 端口
    EPMD2-->>N1: 返回端口 25672
    
    N1->>N2: 建立连接
    N2-->>N1: 连接确认
    
    Note over N1,N2: 建立双向通信通道

EPMD 命令

bash

# 查看本地注册的节点
epmd -names

# 输出示例
epmd: up and running on port 4369 with data:
name rabbit at port 25672

# 停止 EPMD（会停止所有 Erlang 节点）
epmd -kill

# 指定 EPMD 端口
ERL_EPMD_PORT=4369 epmd -daemon

2.2 节点间通信端口

端口列表

端口	服务	协议	说明
4369	EPMD	TCP	Erlang 端口映射服务
25672	Node Communication	TCP	集群节点间数据交换
5672	AMQP	TCP	客户端连接（非 TLS）
5671	AMQPS	TCP	客户端连接（TLS）
15672	Management	HTTP	Web 管理界面和 API
15692	Prometheus	HTTP	监控指标导出
61613	STOMP	TCP	STOMP 协议插件
61614	STOMPS	TCP	STOMP over TLS
1883	MQTT	TCP	MQTT 协议插件
8883	MQTTS	TCP	MQTT over TLS

端口配置

ini

# /etc/rabbitmq/rabbitmq.conf

# EPMD 端口（通常不需要修改）
# ERL_EPMD_PORT=4369

# 节点间通信端口范围
distribution.listener.port_range.min = 25672
distribution.listener.port_range.max = 25672

# 或者使用动态端口范围
# distribution.listener.port_range.min = 25670
# distribution.listener.port_range.max = 25675

# AMQP 端口
listeners.tcp.default = 5672

# 管理界面端口
management.tcp.port = 15672

# Prometheus 端口
prometheus.tcp.port = 15692

2.3 Erlang 分布式协议

通信协议栈

mermaid

graph TB
    subgraph "Erlang 分布式协议栈"
        A[应用层<br/>RabbitMQ]
        B[分布式 Erlang]
        C[TCP/IP]
        D[网络层]
    end
    
    A --> B
    B --> C
    C --> D
    
    subgraph "数据封装"
        M1[消息数据]
        M2[Erlang 消息格式]
        M3[TCP 数据包]
    end
    
    M1 --> M2 --> M3

连接建立过程

mermaid

sequenceDiagram
    participant A as 节点A
    participant B as 节点B
    
    Note over A: 1. 准备连接
    A->>B: 2. TCP SYN (目标: 25672)
    B->>A: 3. TCP SYN-ACK
    A->>B: 4. TCP ACK
    
    Note over A,B: TCP 连接建立
    
    A->>B: 5. 发送节点名称
    B->>A: 6. 验证 Cookie
    A->>B: 7. 验证 Cookie
    
    Note over A,B: Erlang 握手完成
    
    A->>B: 8. 同步集群状态
    B->>A: 9. 确认同步
    
    Note over A,B: 节点加入集群

2.4 心跳机制（Net Tick）

什么是 Net Tick

Net Tick 是 Erlang 节点间的心跳检测机制，用于检测节点是否存活。

工作原理

mermaid

graph LR
    subgraph "Net Tick 机制"
        A[节点A] -->|心跳| B[节点B]
        B -->|心跳| A
        
        A -->|tick 1| T1[时间窗口]
        A -->|tick 2| T1
        A -->|tick 3| T1
        A -->|tick 4| T1
        
        T1 -->|超时| D[判定节点故障]
    end

配置参数

ini

# /etc/rabbitmq/rabbitmq.conf

# 心跳间隔（秒），默认 60
# 4 个 tick 周期未收到响应则判定节点故障
# 即 net_ticktime * 4 = 240 秒（默认）
net_ticktime = 60

# 生产环境建议
# net_ticktime = 120  # 更宽松的超时

心跳超时计算

超时时间 = net_ticktime * 4
默认超时 = 60 * 4 = 240 秒

如果 240 秒内没有收到对方节点的心跳响应，
则认为对方节点已经故障，触发网络分区处理。

2.5 数据同步机制

元数据同步

mermaid

sequenceDiagram
    participant N1 as 节点1
    participant N2 as 节点2
    participant N3 as 节点3
    
    Note over N1: 创建交换器 exchange_x
    
    N1->>N2: 广播交换器创建事件
    N1->>N3: 广播交换器创建事件
    
    Note over N2: 更新本地元数据
    Note over N3: 更新本地元数据
    
    N2-->>N1: 确认
    N3-->>N1: 确认

消息路由

mermaid

graph TB
    subgraph "消息路由流程"
        P[生产者]
        N1[节点1<br/>连接入口]
        N2[节点2<br/>队列主节点]
        Q[队列]
        C[消费者]
    end
    
    P -->|1. 发布消息| N1
    N1 -->|2. 路由到队列节点| N2
    N2 -->|3. 存入队列| Q
    Q -->|4. 投递消息| C

2.6 网络分区检测

分区检测机制

mermaid

stateDiagram-v2
    [*] --> Normal: 正常运行
    Normal --> PartitionDetected: 心跳超时
    PartitionDetected --> PartitionHandling: 触发分区处理
    PartitionHandling --> Normal: 分区恢复
    PartitionHandling --> [*]: 节点停止

分区检测配置

ini

# /etc/rabbitmq/rabbitmq.conf

# 网络分区处理策略
# ignore: 忽略分区（不推荐）
# pause_minority: 暂停少数派节点
# autoheal: 自动恢复（推荐）
cluster_partition_handling = autoheal

# 自动恢复的时间间隔（毫秒）
cluster_partition_handling.autoheal.heal_time = 60000

三、配置示例

3.1 防火墙配置

iptables

bash

# 允许 EPMD 端口
iptables -A INPUT -p tcp --dport 4369 -j ACCEPT

# 允许节点间通信端口
iptables -A INPUT -p tcp --dport 25672 -j ACCEPT

# 允许 AMQP 客户端连接
iptables -A INPUT -p tcp --dport 5672 -j ACCEPT

# 允许管理界面
iptables -A INPUT -p tcp --dport 15672 -j ACCEPT

# 保存规则
service iptables save

firewalld

bash

# 开放必要端口
firewall-cmd --permanent --add-port=4369/tcp
firewall-cmd --permanent --add-port=25672/tcp
firewall-cmd --permanent --add-port=5672/tcp
firewall-cmd --permanent --add-port=15672/tcp

# 重载防火墙
firewall-cmd --reload

# 查看开放的端口
firewall-cmd --list-ports

云安全组（AWS/阿里云）

json

{
  "SecurityGroupRules": [
    {
      "PortRange": "4369",
      "Protocol": "tcp",
      "Source": "10.0.0.0/8",
      "Description": "EPMD - 集群内部"
    },
    {
      "PortRange": "25672",
      "Protocol": "tcp",
      "Source": "10.0.0.0/8",
      "Description": "节点通信 - 集群内部"
    },
    {
      "PortRange": "5672",
      "Protocol": "tcp",
      "Source": "10.0.0.0/8",
      "Description": "AMQP - 内部应用"
    },
    {
      "PortRange": "15672",
      "Protocol": "tcp",
      "Source": "10.0.0.0/8",
      "Description": "管理界面 - 内部管理"
    }
  ]
}

3.2 内核参数优化

bash

# /etc/sysctl.conf

# TCP 连接优化
net.core.somaxconn = 65535
net.core.netdev_max_backlog = 65535
net.ipv4.tcp_max_syn_backlog = 65535
net.ipv4.tcp_syncookies = 1
net.ipv4.tcp_tw_reuse = 1
net.ipv4.tcp_fin_timeout = 30

# TCP 缓冲区
net.core.rmem_max = 16777216
net.core.wmem_max = 16777216
net.ipv4.tcp_rmem = 4096 87380 16777216
net.ipv4.tcp_wmem = 4096 65536 16777216

# 文件描述符
fs.file-max = 1000000

# 应用配置
sysctl -p

3.3 RabbitMQ 通信配置

ini

# /etc/rabbitmq/rabbitmq.conf

# 节点间通信配置
distribution.listener.port_range.min = 25672
distribution.listener.port_range.max = 25672

# TCP 缓冲区大小
tcp_listen_options.backlog = 4096
tcp_listen_options.nodelay = true
tcp_listen_options.sndbuf = 196608
tcp_listen_options.recbuf = 196608

# 心跳配置
net_ticktime = 60

# 连接超时
connection_max = 10000
channel_max = 2047

3.4 Docker 网络配置

yaml

version: '3.8'

services:
  rabbitmq-node1:
    image: rabbitmq:3.12-management
    hostname: rabbitmq-node1
    environment:
      RABBITMQ_ERLANG_COOKIE: 'secret_cookie'
      RABBITMQ_NODENAME: 'rabbit@rabbitmq-node1'
    ports:
      - "5672:5672"
      - "15672:15672"
    networks:
      - rabbitmq-cluster

  rabbitmq-node2:
    image: rabbitmq:3.12-management
    hostname: rabbitmq-node2
    environment:
      RABBITMQ_ERLANG_COOKIE: 'secret_cookie'
      RABBITMQ_NODENAME: 'rabbit@rabbitmq-node2'
    ports:
      - "5673:5672"
      - "15673:15672"
    networks:
      - rabbitmq-cluster

  rabbitmq-node3:
    image: rabbitmq:3.12-management
    hostname: rabbitmq-node3
    environment:
      RABBITMQ_ERLANG_COOKIE: 'secret_cookie'
      RABBITMQ_NODENAME: 'rabbit@rabbitmq-node3'
    ports:
      - "5674:5672"
      - "15674:15672"
    networks:
      - rabbitmq-cluster

networks:
  rabbitmq-cluster:
    driver: bridge
    ipam:
      config:
        - subnet: 172.28.0.0/16

四、PHP 代码示例

4.1 网络连通性检测

php

<?php

class ClusterConnectivityChecker
{
    private array $nodes;
    
    public function __construct(array $nodes)
    {
        $this->nodes = $nodes;
    }
    
    public function checkPort(string $host, int $port, int $timeout = 5): array
    {
        $startTime = microtime(true);
        $socket = @fsockopen($host, $port, $errno, $errstr, $timeout);
        $latency = round((microtime(true) - $startTime) * 1000, 2);
        
        if ($socket) {
            fclose($socket);
            return [
                'host' => $host,
                'port' => $port,
                'status' => 'open',
                'latency_ms' => $latency,
            ];
        }
        
        return [
            'host' => $host,
            'port' => $port,
            'status' => 'closed',
            'error' => $errstr,
            'error_code' => $errno,
        ];
    }
    
    public function checkNodeConnectivity(string $nodeHost): array
    {
        $ports = [
            4369 => 'EPMD',
            25672 => 'Node Communication',
            5672 => 'AMQP',
            15672 => 'Management',
        ];
        
        $results = [];
        foreach ($ports as $port => $service) {
            $result = $this->checkPort($nodeHost, $port);
            $result['service'] = $service;
            $results[$port] = $result;
        }
        
        return [
            'node' => $nodeHost,
            'timestamp' => date('Y-m-d H:i:s'),
            'results' => $results,
            'all_open' => !in_array('closed', array_column($results, 'status')),
        ];
    }
    
    public function checkClusterConnectivity(): array
    {
        $results = [];
        
        foreach ($this->nodes as $node) {
            $results[$node] = $this->checkNodeConnectivity($node);
        }
        
        return [
            'timestamp' => date('Y-m-d H:i:s'),
            'nodes' => $results,
            'summary' => $this->generateSummary($results),
        ];
    }
    
    private function generateSummary(array $results): array
    {
        $healthyNodes = 0;
        $issues = [];
        
        foreach ($results as $node => $check) {
            if ($check['all_open']) {
                $healthyNodes++;
            } else {
                $closedPorts = array_filter($check['results'], function ($r) {
                    return $r['status'] === 'closed';
                });
                $issues[$node] = array_keys($closedPorts);
            }
        }
        
        return [
            'total_nodes' => count($results),
            'healthy_nodes' => $healthyNodes,
            'issues' => $issues,
        ];
    }
    
    public function checkInterNodeLatency(): array
    {
        $latencies = [];
        
        foreach ($this->nodes as $node1) {
            $latencies[$node1] = [];
            foreach ($this->nodes as $node2) {
                if ($node1 !== $node2) {
                    $result = $this->checkPort($node2, 25672);
                    $latencies[$node1][$node2] = $result['latency_ms'] ?? null;
                }
            }
        }
        
        return $latencies;
    }
}

$checker = new ClusterConnectivityChecker(['node1', 'node2', 'node3']);

echo "=== 节点连通性检查 ===\n";
$connectivity = $checker->checkClusterConnectivity();
echo json_encode($connectivity, JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE) . "\n";

echo "\n=== 节点间延迟 ===\n";
$latencies = $checker->checkInterNodeLatency();
foreach ($latencies as $from => $targets) {
    echo "From {$from}:\n";
    foreach ($targets as $to => $latency) {
        echo "  -> {$to}: {$latency} ms\n";
    }
}

4.2 通信监控脚本

php

<?php

class ClusterCommunicationMonitor
{
    private string $apiHost;
    private int $apiPort;
    private string $user;
    private string $password;
    
    public function __construct(
        string $apiHost = 'localhost',
        int $apiPort = 15672,
        string $user = 'guest',
        string $password = 'guest'
    ) {
        $this->apiHost = $apiHost;
        $this->apiPort = $apiPort;
        $this->user = $user;
        $this->password = $password;
    }
    
    private function request(string $endpoint): array
    {
        $url = "http://{$this->apiHost}:{$this->apiPort}/api/{$endpoint}";
        
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_USERPWD => "{$this->user}:{$this->password}",
            CURLOPT_HTTPHEADER => ['Content-Type: application/json'],
            CURLOPT_TIMEOUT => 10,
        ]);
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);
        
        return [
            'status' => $httpCode,
            'data' => json_decode($response, true)
        ];
    }
    
    public function getNetworkTraffic(): array
    {
        $result = $this->request('nodes');
        
        if ($result['status'] !== 200) {
            return ['error' => 'Failed to get node data'];
        }
        
        $traffic = [];
        foreach ($result['data'] as $node) {
            $traffic[$node['name']] = [
                'recv_bytes' => $node['recv_bytes'] ?? 0,
                'recv_cnt' => $node['recv_cnt'] ?? 0,
                'send_bytes' => $node['send_bytes'] ?? 0,
                'send_cnt' => $node['send_cnt'] ?? 0,
                'send_pend' => $node['send_pend'] ?? 0,
            ];
        }
        
        return $traffic;
    }
    
    public function getClusterLinks(): array
    {
        $result = $this->request('overview');
        
        if ($result['status'] !== 200) {
            return ['error' => 'Failed to get overview'];
        }
        
        $nodes = $this->request('nodes');
        
        if ($nodes['status'] !== 200) {
            return ['error' => 'Failed to get nodes'];
        }
        
        $links = [];
        foreach ($nodes['data'] as $node) {
            $links[$node['name']] = [
                'cluster_links' => $node['cluster_links'] ?? [],
                'partitions' => $node['partitions'] ?? [],
            ];
        }
        
        return $links;
    }
    
    public function analyzeCommunicationHealth(): array
    {
        $traffic = $this->getNetworkTraffic();
        $links = $this->getClusterLinks();
        
        if (isset($traffic['error']) || isset($links['error'])) {
            return ['error' => 'Failed to analyze communication'];
        }
        
        $analysis = [
            'timestamp' => date('Y-m-d H:i:s'),
            'nodes' => [],
            'issues' => [],
        ];
        
        foreach ($traffic as $nodeName => $nodeTraffic) {
            $nodeLinks = $links[$nodeName] ?? [];
            
            $analysis['nodes'][$nodeName] = [
                'traffic' => $nodeTraffic,
                'link_count' => count($nodeLinks['cluster_links'] ?? []),
                'has_partitions' => !empty($nodeLinks['partitions']),
            ];
            
            if (!empty($nodeLinks['partitions'])) {
                $analysis['issues'][] = "Node {$nodeName} has network partitions";
            }
            
            if ($nodeTraffic['send_pend'] > 1000) {
                $analysis['issues'][] = "Node {$nodeName} has high pending sends: {$nodeTraffic['send_pend']}";
            }
        }
        
        return $analysis;
    }
    
    public function generateCommunicationReport(): string
    {
        $analysis = $this->analyzeCommunicationHealth();
        
        $report = "=== RabbitMQ 集群通信报告 ===\n";
        $report .= "时间: {$analysis['timestamp']}\n\n";
        
        $report .= "节点通信状态:\n";
        foreach ($analysis['nodes'] as $node => $info) {
            $report .= "\n节点: {$node}\n";
            $report .= "  - 接收: {$info['traffic']['recv_cnt']} 条, " . 
                       round($info['traffic']['recv_bytes'] / 1024 / 1024, 2) . " MB\n";
            $report .= "  - 发送: {$info['traffic']['send_cnt']} 条, " . 
                       round($info['traffic']['send_bytes'] / 1024 / 1024, 2) . " MB\n";
            $report .= "  - 待发送: {$info['traffic']['send_pend']}\n";
            $report .= "  - 集群链接数: {$info['link_count']}\n";
        }
        
        if (!empty($analysis['issues'])) {
            $report .= "\n问题:\n";
            foreach ($analysis['issues'] as $issue) {
                $report .= "  - {$issue}\n";
            }
        } else {
            $report .= "\n状态: 正常\n";
        }
        
        return $report;
    }
}

$monitor = new ClusterCommunicationMonitor('localhost', 15672, 'admin', 'admin123');

echo $monitor->generateCommunicationReport();

五、实际应用场景

5.1 跨机房集群通信

mermaid

graph TB
    subgraph "数据中心 A"
        A1[节点 A1]
        A2[节点 A2]
        A1 <--> A2
    end
    
    subgraph "数据中心 B"
        B1[节点 B1]
        B2[节点 B2]
        B1 <--> B2
    end
    
    subgraph "网络层"
        VPN[VPN/专线]
        FW1[防火墙]
        FW2[防火墙]
    end
    
    A1 --> FW1
    A2 --> FW1
    FW1 --> VPN
    VPN --> FW2
    FW2 --> B1
    FW2 --> B2

5.2 客户端连接优化

mermaid

graph LR
    subgraph "客户端"
        P[生产者]
        C[消费者]
    end
    
    subgraph "接入层"
        LB[负载均衡]
    end
    
    subgraph "RabbitMQ 集群"
        N1[节点1]
        N2[节点2]
        N3[节点3]
    end
    
    P -->|AMQP| LB
    C -->|AMQP| LB
    LB --> N1
    LB --> N2
    LB --> N3

六、常见问题与解决方案

6.1 节点无法通信

问题: 节点之间无法建立连接

排查步骤:

bash

# 1. 检查网络连通性
ping node2
traceroute node2

# 2. 检查端口
telnet node2 4369
telnet node2 25672

# 3. 检查 EPMD
epmd -names

# 4. 检查防火墙
iptables -L -n
firewall-cmd --list-all

# 5. 检查日志
tail -f /var/log/rabbitmq/rabbit@node1.log

解决方案:

bash

# 开放防火墙端口
firewall-cmd --permanent --add-port=4369/tcp
firewall-cmd --permanent --add-port=25672/tcp
firewall-cmd --reload

# 检查 SELinux
getenforce
setenforce 0  # 临时关闭

6.2 通信延迟高

问题: 节点间通信延迟过高

排查方向:

bash

# 检查网络延迟
ping -c 100 node2

# 检查带宽
iperf3 -c node2

# 检查系统负载
top
iostat -x 1

# 检查 RabbitMQ 状态
rabbitmqctl status

优化建议:

ini

# 增大 TCP 缓冲区
tcp_listen_options.sndbuf = 196608
tcp_listen_options.recbuf = 196608

# 启用 TCP_NODELAY
tcp_listen_options.nodelay = true

6.3 连接数耗尽

问题: 无法建立新连接

排查:

bash

# 检查当前连接数
rabbitmqctl list_connections | wc -l

# 检查系统文件描述符
lsof -p $(pgrep -f rabbitmq) | wc -l

# 检查限制
rabbitmqctl status | grep -A 5 "File Descriptors"

解决方案:

bash

# 增加系统限制
ulimit -n 65535

# 配置 RabbitMQ
# /etc/rabbitmq/rabbitmq.conf
connection_max = 50000

七、最佳实践建议

7.1 网络规划

专用网络: 集群节点部署在同一局域网
低延迟: 节点间延迟应低于 1ms
高带宽: 至少 1Gbps 网络带宽
网络隔离: 使用 VLAN 或安全组隔离

7.2 端口管理

最小化开放: 只开放必要端口
内部隔离: 集群端口仅对内网开放
监控告警: 监控端口状态和连接数

7.3 性能优化

ini

# 通信优化配置
tcp_listen_options.backlog = 4096
tcp_listen_options.nodelay = true
tcp_listen_options.sndbuf = 196608
tcp_listen_options.recbuf = 196608

# 心跳优化
net_ticktime = 60

# 连接优化
connection_max = 10000
channel_max = 2047

RabbitMQ 集群通信机制 ​

一、概述 ​

通信架构总览 ​

二、核心知识点 ​

2.1 EPMD（Erlang Port Mapper Daemon） ​

什么是 EPMD ​

EPMD 工作流程 ​

EPMD 命令 ​

2.2 节点间通信端口 ​

端口列表 ​

端口配置 ​

2.3 Erlang 分布式协议 ​

通信协议栈 ​

连接建立过程 ​

2.4 心跳机制（Net Tick） ​

什么是 Net Tick ​

工作原理 ​

配置参数 ​

心跳超时计算 ​

2.5 数据同步机制 ​

元数据同步 ​

消息路由 ​

2.6 网络分区检测 ​

分区检测机制 ​

分区检测配置 ​

三、配置示例 ​

3.1 防火墙配置 ​

iptables ​

firewalld ​

云安全组（AWS/阿里云） ​

3.2 内核参数优化 ​

3.3 RabbitMQ 通信配置 ​

3.4 Docker 网络配置 ​

四、PHP 代码示例 ​

4.1 网络连通性检测 ​

4.2 通信监控脚本 ​

五、实际应用场景 ​

5.1 跨机房集群通信 ​

5.2 客户端连接优化 ​

六、常见问题与解决方案 ​

6.1 节点无法通信 ​

6.2 通信延迟高 ​

6.3 连接数耗尽 ​

七、最佳实践建议 ​

7.1 网络规划 ​

7.2 端口管理 ​

7.3 性能优化 ​

八、相关链接 ​

RabbitMQ 集群通信机制

一、概述

通信架构总览

二、核心知识点

2.1 EPMD（Erlang Port Mapper Daemon）

什么是 EPMD

EPMD 工作流程

EPMD 命令

2.2 节点间通信端口

端口列表

端口配置

2.3 Erlang 分布式协议

通信协议栈

连接建立过程

2.4 心跳机制（Net Tick）

什么是 Net Tick

工作原理

配置参数

心跳超时计算

2.5 数据同步机制

元数据同步

消息路由

2.6 网络分区检测

分区检测机制

分区检测配置

三、配置示例

3.1 防火墙配置

iptables

firewalld

云安全组（AWS/阿里云）

3.2 内核参数优化

3.3 RabbitMQ 通信配置

3.4 Docker 网络配置

四、PHP 代码示例

4.1 网络连通性检测

4.2 通信监控脚本

五、实际应用场景

5.1 跨机房集群通信

5.2 客户端连接优化

六、常见问题与解决方案

6.1 节点无法通信

6.2 通信延迟高

6.3 连接数耗尽

七、最佳实践建议

7.1 网络规划

7.2 端口管理

7.3 性能优化

八、相关链接