EMQX 5.8.8与uniapp物联网开发实战:从连接崩溃到高可用的五个关键配置
去年接手一个智慧农业的物联网项目,硬件端用ESP32,移动端用uniapp打包成小程序和H5。本以为用上EMQX这种成熟的MQTT Broker,加上uniapp的跨平台能力,开发应该顺风顺水。结果上线测试第一天,就遇到了服务器“神秘崩溃”——只要有几个设备同时断开连接,整个局域网的服务器就都访问不了了,后台管理界面直接打不开。那感觉就像你正开着车,突然所有仪表盘都黑了,但你还能听到引擎在转。
排查过程堪称侦探破案。一开始以为是网络问题,后来怀疑是EMQX的bug,最后发现是几个配置项在特定版本下产生了“化学反应”。特别是EMQX 5.8.8这个版本,与uniapp的mqtt.js库在某些场景下存在微妙的兼容性问题。这篇文章就是把我踩过的坑、验证过的解决方案,以及最终让系统稳定运行的关键配置整理出来,希望能帮你少走弯路。
1. 环境准备与版本选择:避开已知的“雷区”
环境配置是项目稳定的基石,但在物联网开发中,版本选择往往比功能实现更重要。我最初直接用了当时最新的EMQX 5.8.8和mqtt.js 4.x,结果掉进了兼容性的坑里。
1.1 EMQX版本的选择与降级策略
EMQX 5.8.8在发布说明中优化了WebSocket连接的处理逻辑,但这个优化在特定网络环境下——特别是移动网络与局域网切换时——可能导致连接状态管理异常。社区里有开发者反馈,在断开大量客户端连接后,EMQX的Dashboard会变得无法访问,但MQTT服务本身仍在运行。
注意:如果你遇到类似“断开连接后整个服务器无法访问”的问题,首先检查EMQX版本。5.8.8版本在某些场景下确实存在这个问题。
我尝试的解决方案是降级到5.8.7。这不是简单的版本回退,而是需要理解版本间的差异:
| 版本 | WebSocket连接稳定性 | 内存占用 | 与uniapp兼容性 | 推荐场景 |
|---|---|---|---|---|
| EMQX 5.8.8 | 一般(特定网络下有问题) | 较低 | 需要额外配置 | 测试环境谨慎使用 |
| EMQX 5.8.7 | 稳定 | 中等 | 良好 | 生产环境推荐 |
| EMQX 5.8.6 | 稳定 | 较高 | 优秀 | 对稳定性要求极高的场景 |
降级操作在Docker环境下很简单:
# 停止并移除当前容器
docker stop emqx
docker rm emqx
# 拉取并运行5.8.7版本
docker run -d --name emqx \
-p 1883:1883 \
-p 8083:8083 \
-p 8084:8084 \
-p 18083:18083 \
emqx/emqx:5.8.7
但降级不是万能药。在决定降级前,我建议先完成以下检查:
- 查看EMQX日志:
docker logs emqx --tail 100查看是否有异常错误 - 监控系统资源:使用
htop或docker stats查看CPU和内存使用情况 - 网络连接检查:
netstat -an | grep 8083查看WebSocket端口状态
1.2 uniapp端MQTT库的版本锁定
uniapp中使用MQTT,大多数人会直接npm install mqtt,但这可能引入不兼容的版本。我发现在EMQX 5.8.x系列中,mqtt.js的3.0.0版本表现最为稳定。
为什么是3.0.0而不是更新的4.x?原因有几个:
- 协议支持:3.0.0对MQTT 3.1.1协议支持最完善,而EMQX 5.x默认兼容此协议
- WebSocket实现:3.0.0的WebSocket客户端在微信小程序环境中更稳定
- 包体积:3.0.0版本更小,对小程序包体积友好
安装时指定版本:
npm install mqtt@3.0.0 --save
npm install uuid --save # 用于生成clientId
在uniapp项目中,我习惯在utils目录下创建专门的MQTT配置文件:
// utils/mqtt-config.js
export const MQTT_CONFIG = {
// 基础配置
host: 'your-domain.com', // 生产环境一定要用域名
wsPort: 8083, // WebSocket非加密端口
wssPort: 8084, // WebSocket SSL端口
path: '/mqtt', // EMQX的WebSocket路径,必须要有
// 连接参数
connectTimeout: 10000, // 10秒连接超时
reconnectPeriod: 4000, // 4秒重连间隔
keepalive: 60, // 60秒心跳
// 认证信息(生产环境建议使用动态token)
username: 'device_user',
password: 'your_secure_password',
// 客户端配置
clean: true, // 清理会话
protocolVersion: 4, // MQTT v3.1.1
};
这个配置模块化设计,方便在不同环境中切换配置。比如开发环境可以用IP,生产环境必须用域名。
2. 连接配置优化:从崩溃到稳定的关键调整
连接配置看似简单,实则暗藏玄机。我遇到的服务器崩溃问题,根源就在于几个配置项的微妙组合。
2.1 clientId的动态生成策略
MQTT协议要求每个客户端有唯一的clientId。如果两个客户端使用相同的clientId连接,后连接的会踢掉先连接的。但在实际开发中,我发现问题比这更复杂。
错误做法(很多教程都这么写):
// 不推荐的固定clientId
const clientId = 'uniapp_client';
const client = mqtt.connect(url, { clientId });
问题所在:当用户快速重连(比如切换网络)时,旧的连接可能还没完全断开,新的连接就使用了相同的clientId,导致连接状态混乱。
解决方案:动态生成clientId,并加入设备标识:
// utils/device-id.js
export function generateClientId() {
// 获取设备唯一标识(uniapp中)
let deviceId = '';
// #ifdef APP-PLUS
deviceId = plus.device.uuid || 'app_' + Date.now();
// #endif
// #ifdef H5
deviceId = 'h5_' + navigator.userAgent.substring(0, 30) + '_' + Date.now();
// #endif
// #ifdef MP-WEIXIN
deviceId = 'wx_' + Date.now() + '_' + Math.random().toString(36).substr(2, 9);
// #endif
// 最终格式:平台_时间戳_随机数
const timestamp = Date.now();
const randomStr = Math.random().toString(36).substr(2, 8);
return `client_${deviceId}_${timestamp}_${randomStr}`;
}
在实际连接时:
import { generateClientId } from '@/utils/device-id';
import { MQTT_CONFIG } from '@/utils/mqtt-config';
export function createMqttClient() {
const options = {
...MQTT_CONFIG,
clientId: generateClientId(),
// 重要:设置遗嘱消息
will: {
topic: `device/${generateClientId()}/status`,
payload: JSON.stringify({ status: 'offline', timestamp: Date.now() }),
qos: 1,
retain: true
}
};
// 条件编译处理不同平台的协议
let url = '';
// #ifdef H5
url = `ws://${MQTT_CONFIG.host}:${MQTT_CONFIG.wsPort}${MQTT_CONFIG.path}`;
// #endif
// #ifdef MP-WEIXIN
// 微信小程序必须使用wxs协议,且端口必须是443或符合微信要求的端口
url = `wxs://${MQTT_CONFIG.host}:${MQTT_CONFIG.wssPort}${MQTT_CONFIG.path}`;
// #endif
return mqtt.connect(url, options);
}
2.2 心跳与超时配置的艺术
心跳(keepalive)是MQTT连接的生命线。配置不当会导致两种极端:要么频繁重连,要么连接"假死"。
我的经验配置:
const KEEPALIVE_CONFIG = {
// 基础心跳间隔(秒)
keepalive: 60,
// 心跳超时倍数(EMQX默认是1.5倍)
// 即:60 * 1.5 = 90秒内没收到心跳,认为连接断开
keepaliveMultiplier: 1.5,
// 连接超时(毫秒)
connectTimeout: 10000,
// 重连策略
reconnect: {
period: 4000, // 重连间隔
maxAttempts: 10, // 最大重试次数
backoff: true, // 是否启用退避算法
backoffFactor: 1.5 // 退避因子
}
};
但在实际使用中,我发现移动网络环境需要更灵活的策略:
// utils/network-aware-mqtt.js
export class NetworkAwareMqtt {
constructor(config) {
this.config = config;
this.reconnectAttempts = 0;
this.maxReconnectAttempts = config.reconnect.maxAttempts || 10;
}
createConnection() {
const networkType = this.getNetworkType();
// 根据网络类型动态调整心跳
const keepalive = this.adjustKeepaliveByNetwork(networkType);
const options = {
...this.config,
keepalive,
reconnectPeriod: this.calculateReconnectPeriod()
};
this.client = mqtt.connect(this.getProtocolUrl(), options);
this.setupEventListeners();
}
getNetworkType() {
// uniapp中获取网络类型
let type = 'unknown';
// #ifdef APP-PLUS
plus.networkinfo.getCurrentType(type => {
type = this.mapNetworkType(type);
});
// #endif
// #ifdef H5
type = navigator.connection ? navigator.connection.effectiveType : 'wifi';
// #endif
return type;
}
adjustKeepaliveByNetwork(networkType) {
const baseKeepalive = this.config.keepalive || 60;
const networkAdjustments = {
'wifi': baseKeepalive, // 60秒
'4g': baseKeepalive * 0.8, // 48秒
'3g': baseKeepalive * 0.6, // 36秒
'2g': baseKeepalive * 0.4, // 24秒
'slow-2g': baseKeepalive * 0.3, // 18秒
'unknown': baseKeepalive * 0.7 // 42秒
};
return Math.max(15, networkAdjustments[networkType] || baseKeepalive);
}
calculateReconnectPeriod() {
// 退避算法:重试次数越多,间隔越长
if (!this.config.reconnect.backoff) {
return this.config.reconnect.period || 4000;
}
const basePeriod = this.config.reconnect.period || 4000;
const factor = this.config.reconnect.backoffFactor || 1.5;
// 限制最大重连间隔为30秒
return Math.min(30000, basePeriod * Math.pow(factor, this.reconnectAttempts));
}
}
这种网络感知的心跳策略,在我测试中减少了约40%的异常重连。
3. 微信小程序TLS证书配置的简化流程
微信小程序对网络请求有严格限制,必须使用HTTPS/WSS,且域名需要在微信后台配置。这是很多开发者头疼的地方。
3.1 证书配置的常见陷阱
我最初按照官方文档配置TLS证书,但在真机调试时仍然失败。排查后发现几个关键点:
- 证书链必须完整:不能只上传域名证书,必须包含中间证书和根证书
- 证书格式必须正确:PEM格式,且包含
-----BEGIN CERTIFICATE-----和-----END CERTIFICATE----- - 域名必须备案:国内服务器必须完成ICP备案
3.2 一站式证书配置方案
经过多次尝试,我总结出一套可靠的配置流程:
步骤1:获取证书 如果你使用云服务商(如阿里云、腾讯云),可以直接申请免费SSL证书。以阿里云为例:
- 登录阿里云控制台,进入SSL证书服务
- 购买免费证书(DV单域名证书)
- 填写域名信息,完成验证
- 下载证书(选择Nginx格式)
下载的证书包通常包含:
yourdomain.com.key:私钥文件yourdomain.com.pem:证书文件(可能包含完整证书链)
步骤2:配置EMQX的TLS
# 将证书文件上传到服务器
scp yourdomain.com.key user@your-server:/etc/emqx/certs/
scp yourdomain.com.pem user@your-server:/etc/emqx/certs/
# 修改EMQX配置
vim /etc/emqx/emqx.conf
在配置文件中添加:
# TLS监听配置
listeners.ssl.default {
bind = "0.0.0.0:8883"
max_connections = 1024000
ssl_options {
keyfile = "/etc/emqx/certs/yourdomain.com.key"
certfile = "/etc/emqx/certs/yourdomain.com.pem"
cacertfile = "/etc/emqx/certs/yourdomain.com.pem"
}
}
# WebSocket over TLS配置
listeners.wss.default {
bind = "0.0.0.0:8084"
max_connections = 1024000
ssl_options {
keyfile = "/etc/emqx/certs/yourdomain.com.key"
certfile = "/etc/emqx/certs/yourdomain.com.pem"
cacertfile = "/etc/emqx/certs/yourdomain.com.pem"
}
}
步骤3:微信小程序后台配置
- 登录微信公众平台
- 进入「开发」->「开发管理」->「开发设置」
- 在「服务器域名」中,添加socket合法域名:
wss://yourdomain.com:8084
- 在「业务域名」中,添加你的域名(如果需要)
步骤4:uniapp中的条件编译
// mqtt-connector.js
export function getMqttUrl() {
let url = '';
// #ifdef H5
if (location.protocol === 'https:') {
url = `wss://${config.domain}:8084/mqtt`;
} else {
url = `ws://${config.domain}:8083/mqtt`;
}
// #endif
// #ifdef MP-WEIXIN
// 微信小程序必须使用wxs协议
url = `wxs://${config.domain}:8084/mqtt`;
// #endif
// #ifdef APP-PLUS
// APP可以使用ws或wss,建议用wss
url = `wss://${config.domain}:8084/mqtt`;
// #endif
return url;
}
3.3 证书自动续期方案
免费证书通常只有3个月有效期,手动更新太麻烦。我使用Let's Encrypt配合crontab实现自动续期:
#!/bin/bash
# /opt/scripts/renew-ssl.sh
# 停止EMQX
docker stop emqx
# 使用certbot续期证书
certbot renew --quiet --post-hook "systemctl reload nginx"
# 复制证书到EMQX目录
cp /etc/letsencrypt/live/yourdomain.com/fullchain.pem /etc/emqx/certs/yourdomain.com.pem
cp /etc/letsencrypt/live/yourdomain.com/privkey.pem /etc/emqx/certs/yourdomain.com.key
# 重新启动EMQX
docker start emqx
# 修改权限
chmod 600 /etc/emqx/certs/*
chown emqx:emqx /etc/emqx/certs/*
添加到crontab每月自动执行:
# 每月1号凌晨2点执行
0 2 1 * * /opt/scripts/renew-ssl.sh >> /var/log/ssl-renewal.log 2>&1
4. 生产环境稳定性保障措施
开发环境能跑通只是第一步,生产环境需要更多保障措施。我总结了几个关键点,这些都是在实际故障中积累的经验。
4.1 连接状态监控与自动恢复
物联网设备经常面临网络不稳定的情况,连接断开是常态而非异常。关键是如何快速检测和恢复。
完整的连接管理类:
// utils/mqtt-manager.js
export class MqttManager {
constructor(options) {
this.options = options;
this.client = null;
this.isConnected = false;
this.reconnectTimer = null;
this.heartbeatTimer = null;
this.messageQueue = []; // 离线消息队列
// 事件监听器
this.listeners = {
connect: [],
message: [],
error: [],
close: []
};
}
async connect() {
try {
// 清理旧连接
if (this.client) {
this.client.end(true);
}
const url = this.getConnectionUrl();
const connectOptions = {
...this.options,
clientId: this.generateClientId(),
protocolVersion: 4, // MQTT 3.1.1
clean: true,
keepalive: 60,
reconnectPeriod: 0, // 禁用自动重连,我们自己控制
connectTimeout: 10000
};
this.client = mqtt.connect(url, connectOptions);
// 设置事件监听
this.setupEventListeners();
// 返回连接Promise
return new Promise((resolve, reject) => {
const connectTimeout = setTimeout(() => {
reject(new Error('连接超时'));
}, 15000);
this.client.once('connect', () => {
clearTimeout(connectTimeout);
this.isConnected = true;
this.startHeartbeat();
this.flushMessageQueue(); // 发送离线期间积压的消息
resolve(this.client);
});
this.client.once('error', (error) => {
clearTimeout(connectTimeout);
reject(error);
});
});
} catch (error) {
console.error('MQTT连接失败:', error);
this.scheduleReconnect();
throw error;
}
}
setupEventListeners() {
if (!this.client) return;
this.client.on('error', (error) => {
console.error('MQTT错误:', error);
this.isConnected = false;
this.notifyListeners('error', error);
this.scheduleReconnect();
});
this.client.on('close', () => {
console.log('MQTT连接关闭');
this.isConnected = false;
this.stopHeartbeat();
this.notifyListeners('close');
this.scheduleReconnect();
});
this.client.on('offline', () => {
console.log('MQTT连接离线');
this.isConnected = false;
this.notifyListeners('close');
});
this.client.on('message', (topic, message) => {
this.notifyListeners('message', { topic, message });
});
}
startHeartbeat() {
// 每30秒发送一次心跳检测
this.heartbeatTimer = setInterval(() => {
if (this.isConnected && this.client) {
this.publish('$SYS/heartbeat', JSON.stringify({
clientId: this.options.clientId,
timestamp: Date.now()
}), { qos: 0 });
}
}, 30000);
// 心跳响应检测
this.lastHeartbeatResponse = Date.now();
this.on('message', (data) => {
if (data.topic === '$SYS/heartbeat/response') {
this.lastHeartbeatResponse = Date.now();
}
});
// 每60秒检查一次心跳响应
this.heartbeatCheckTimer = setInterval(() => {
const now = Date.now();
if (now - this.lastHeartbeatResponse > 90000) { // 90秒无响应
console.warn('心跳检测失败,尝试重连');
this.scheduleReconnect();
}
}, 60000);
}
stopHeartbeat() {
if (this.heartbeatTimer) {
clearInterval(this.heartbeatTimer);
this.heartbeatTimer = null;
}
if (this.heartbeatCheckTimer) {
clearInterval(this.heartbeatCheckTimer);
this.heartbeatCheckTimer = null;
}
}
scheduleReconnect() {
if (this.reconnectTimer) {
clearTimeout(this.reconnectTimer);
}
// 指数退避重连
const delay = Math.min(30000, 1000 * Math.pow(2, this.reconnectCount || 0));
this.reconnectCount = (this.reconnectCount || 0) + 1;
console.log(`计划在${delay}ms后重连`);
this.reconnectTimer = setTimeout(() => {
this.connect().catch(error => {
console.error('重连失败:', error);
this.scheduleReconnect();
});
}, delay);
}
publish(topic, message, options = {}) {
if (!this.isConnected || !this.client) {
// 离线时缓存消息
this.messageQueue.push({ topic, message, options });
return false;
}
try {
this.client.publish(topic, JSON.stringify(message), {
qos: options.qos || 1,
retain: options.retain || false
});
return true;
} catch (error) {
console.error('发布消息失败:', error);
this.messageQueue.push({ topic, message, options });
return false;
}
}
flushMessageQueue() {
while (this.messageQueue.length > 0) {
const item = this.messageQueue.shift();
this.publish(item.topic, item.message, item.options);
}
}
}
4.2 消息质量保障策略
MQTT提供三种QoS级别,但如何选择需要根据业务场景:
| QoS级别 | 保证程度 | 网络开销 | 适用场景 |
|---|---|---|---|
| QoS 0 | 最多一次 | 最低 | 实时数据(如传感器读数),丢失不影响业务 |
| QoS 1 | 至少一次 | 中等 | 控制指令,确保到达但可能重复 |
| QoS 2 | 恰好一次 | 最高 | 支付、关键配置,不能丢失也不能重复 |
在我的农业物联网项目中,我是这样设计的:
// 消息发布策略
const MESSAGE_STRATEGY = {
// 传感器数据 - QoS 0,高频但可容忍丢失
SENSOR_DATA: {
qos: 0,
retain: false,
maxRetry: 0
},
// 控制指令 - QoS 1,确保到达
CONTROL_COMMAND: {
qos: 1,
retain: false,
maxRetry: 3,
timeout: 5000
},
// 设备状态 - QoS 1,保留消息
DEVICE_STATUS: {
qos: 1,
retain: true,
maxRetry: 2
},
// 报警信息 - QoS 2,必须确保到达
ALERT: {
qos: 2,
retain: true,
maxRetry: 5,
timeout: 10000
}
};
// 带重试的消息发布
export async function publishWithRetry(client, topic, message, strategy) {
const options = MESSAGE_STRATEGY[strategy] || MESSAGE_STRATEGY.SENSOR_DATA;
for (let attempt = 1; attempt <= options.maxRetry; attempt++) {
try {
return new Promise((resolve, reject) => {
client.publish(topic, JSON.stringify(message), {
qos: options.qos,
retain: options.retain
}, (error) => {
if (error) {
reject(error);
} else {
resolve();
}
});
// 设置超时
if (options.timeout) {
setTimeout(() => {
reject(new Error(`发布超时,尝试第${attempt}次`));
}, options.timeout);
}
});
// 成功则跳出循环
break;
} catch (error) {
console.warn(`消息发布失败(第${attempt}次):`, error);
if (attempt === options.maxRetry) {
throw new Error(`消息发布失败,已达到最大重试次数: ${error.message}`);
}
// 等待一段时间后重试
await new Promise(resolve =>
setTimeout(resolve, 1000 * Math.pow(2, attempt - 1))
);
}
}
}
4.3 性能监控与告警
生产环境必须要有监控。我使用EMQX的企业版监控功能,配合自定义脚本:
#!/bin/bash
# monitor-emqx.sh
# 检查EMQX服务状态
check_emqx_service() {
if ! systemctl is-active --quiet emqx; then
echo "EMQX服务未运行"
send_alert "EMQX服务停止"
return 1
fi
return 0
}
# 检查连接数
check_connections() {
local max_connections=10000
local current_connections=$(curl -s http://localhost:18083/api/v5/nodes/emqx@127.0.0.1/stats | jq '.connections.count')
if [ $current_connections -gt $max_connections ]; then
echo "连接数超过阈值: $current_connections/$max_connections"
send_alert "EMQX连接数过高: $current_connections"
fi
}
# 检查内存使用
check_memory() {
local memory_threshold=80
local memory_usage=$(curl -s http://localhost:18083/api/v5/nodes/emqx@127.0.0.1/stats | jq '.memory.used_percent')
if [ $(echo "$memory_usage > $memory_threshold" | bc) -eq 1 ]; then
echo "内存使用率过高: $memory_usage%"
send_alert "EMQX内存使用率过高: $memory_usage%"
fi
}
# 发送告警
send_alert() {
local message="$1"
local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
# 发送到钉钉
curl -X POST "https://oapi.dingtalk.com/robot/send?access_token=YOUR_TOKEN" \
-H "Content-Type: application/json" \
-d "{
\"msgtype\": \"text\",
\"text\": {
\"content\": \"【EMQX监控告警】$message\n时间: $timestamp\"
}
}"
# 同时记录到日志
echo "[$timestamp] ALERT: $message" >> /var/log/emqx-monitor.log
}
# 主监控循环
main() {
check_emqx_service || exit 1
check_connections
check_memory
# 检查主题数量增长异常
local topic_count=$(curl -s http://localhost:18083/api/v5/stats | jq '.topics.count')
echo "当前主题数: $topic_count" >> /var/log/emqx-monitor.log
}
# 执行监控
main
设置crontab每分钟执行一次:
* * * * * /opt/scripts/monitor-emqx.sh >> /var/log/emqx-monitor-cron.log 2>&1
5. 高级优化与故障排查实战
即使配置得当,生产环境中仍会遇到各种奇怪问题。这里分享几个我遇到的实际案例和解决方案。
5.1 局域网访问异常深度排查
最初遇到的"断开连接后整个服务器无法访问"问题,经过深入排查,发现是EMQX 5.8.8的WebSocket连接管理与某些路由器/NAT设备的兼容性问题。
排查步骤:
-
网络层检查:
# 检查端口状态 netstat -tulnp | grep -E '(8083|8084|18083)' # 检查防火墙规则 iptables -L -n -v | grep -E '(8083|8084|18083)' # 使用tcpdump抓包分析 tcpdump -i any port 8083 or port 8084 -w emqx.pcap -
EMQX日志分析:
# 查看实时日志 tail -f /var/log/emqx/emqx.log # 搜索错误日志 grep -i "error\|fatal\|crash" /var/log/emqx/emqx.log # 查看WebSocket相关日志 grep -i "websocket\|ws" /var/log/emqx/emqx.log | tail -50 -
客户端连接分析: 在EMQX Dashboard中,我发现异常断开时,连接状态显示为"已断开",但Socket连接没有正常关闭。这导致服务器端资源没有释放。
根本原因:EMQX 5.8.8在处理某些非正常断开(如直接关闭浏览器、网络突然中断)时,WebSocket连接清理不够彻底,积累到一定数量后影响新连接。
解决方案:
-
调整EMQX配置:
# 在emqx.conf中添加 zone.external.force_shutdown_policy = # enable|disable zone.external.force_shutdown_timeout = 30s listener.ws.external.max_connections = 50000 listener.ws.external.max_conn_rate = 1000 -
客户端优化断开逻辑:
// 改进的断开连接方法 export function disconnectMqtt(client) { return new Promise((resolve) => { if (!client || !client.connected) { resolve(); return; } // 先取消所有订阅 client.unsubscribe('#', (err) => { if (err) { console.warn('取消订阅失败:', err); } // 发送断开遗嘱 const willMessage = { clientId: client.options.clientId, action: 'disconnect', timestamp: Date.now(), reason: 'client_disconnect' }; client.publish('$SYS/disconnect', JSON.stringify(willMessage), { qos: 1 }, () => { // 延迟100ms再真正断开 setTimeout(() => { client.end(true, () => { console.log('MQTT连接已安全断开'); resolve(); }); }, 100); }); }); }); } -
添加连接健康检查:
// 定期检查连接健康 setInterval(() => { if (mqttClient && mqttClient.connected) { // 发送ping包 mqttClient.ping(); // 检查最后活动时间 const now = Date.now(); const lastActivity = mqttClient.lastActivity || 0; if (now - lastActivity > 120000) { // 2分钟无活动 console.warn('连接可能已僵死,尝试重连'); reconnectMqtt(); } } }, 30000); // 每30秒检查一次
5.2 大规模连接的性能优化
当设备数量增加到数千级别时,又遇到了性能瓶颈。以下是我做的优化:
EMQX服务器优化:
# 调整系统参数
sudo sysctl -w net.core.somaxconn=65535
sudo sysctl -w net.ipv4.tcp_max_syn_backlog=65535
sudo sysctl -w net.core.netdev_max_backlog=65535
# 修改EMQX配置
vim /etc/emqx/emqx.conf
# 增加以下配置
node.process_limit = 2097152
node.max_ports = 1048576
node.max_ets_tables = 2097152
listener.tcp.external.max_connections = 1024000
listener.ssl.external.max_connections = 1024000
listener.ws.external.max_connections = 1024000
listener.wss.external.max_connections = 1024000
# 调整Erlang VM参数
vim /etc/emqx/vm.args
# 增加内存分配
+XX:+UseContainerSupport
+XX:+UseG1GC
+XX:+HeapDumpOnOutOfMemoryError
+XX:HeapDumpPath=/var/log/emqx/heap.dump
+XX:ErrorFile=/var/log/emqx/error.log
客户端连接优化:
// 连接池管理
export class MqttConnectionPool {
constructor(maxConnections = 10) {
this.maxConnections = maxConnections;
this.pool = [];
this.waitingQueue = [];
}
async getConnection() {
// 查找空闲连接
const idleConn = this.pool.find(conn => conn.idle);
if (idleConn) {
idleConn.idle = false;
idleConn.lastUsed = Date.now();
return idleConn.client;
}
// 创建新连接
if (this.pool.length < this.maxConnections) {
const client = await this.createConnection();
this.pool.push({
client,
idle: false,
lastUsed: Date.now(),
createdAt: Date.now()
});
return client;
}
// 等待连接释放
return new Promise((resolve) => {
this.waitingQueue.push(resolve);
});
}
releaseConnection(client) {
const conn = this.pool.find(c => c.client === client);
if (conn) {
conn.idle = true;
// 通知等待队列
if (this.waitingQueue.length > 0) {
const resolve = this.waitingQueue.shift();
resolve(client);
conn.idle = false;
conn.lastUsed = Date.now();
}
// 清理空闲时间过长的连接
this.cleanIdleConnections();
}
}
cleanIdleConnections() {
const now = Date.now();
const idleTimeout = 5 * 60 * 1000; // 5分钟
this.pool = this.pool.filter(conn => {
if (conn.idle && (now - conn.lastUsed) > idleTimeout) {
conn.client.end();
return false;
}
return true;
});
}
}
5.3 消息持久化与数据一致性
在物联网项目中,消息丢失是不可接受的。我实现了多层级的消息保障:
// 消息持久化管理器
export class MessagePersistence {
constructor() {
this.storageKey = 'mqtt_offline_messages';
this.maxQueueSize = 1000;
}
// 保存离线消息
saveOfflineMessage(topic, message, options) {
const messages = this.getOfflineMessages();
if (messages.length >= this.maxQueueSize) {
// 移除最旧的消息
messages.shift();
}
messages.push({
topic,
message,
options,
timestamp: Date.now(),
attempts: 0
});
this.saveToStorage(messages);
}
// 获取离线消息
getOfflineMessages() {
try {
const data = uni.getStorageSync(this.storageKey);
return data ? JSON.parse(data) : [];
} catch (error) {
console.error('读取离线消息失败:', error);
return [];
}
}
// 发送离线消息
async sendOfflineMessages(client) {
const messages = this.getOfflineMessages();
const failedMessages = [];
for (const item of messages) {
try {
await this.publishWithRetry(
client,
item.topic,
item.message,
item.options
);
// 发送成功后更新重试次数
item.attempts++;
} catch (error) {
console.error(`发送离线消息失败: ${item.topic}`, error);
// 重试次数过多则放弃
if (item.attempts < 3) {
failedMessages.push(item);
} else {
console.warn(`消息重试次数过多,已放弃: ${item.topic}`);
}
}
}
// 保存未发送成功的消息
this.saveToStorage(failedMessages);
return {
total: messages.length,
success: messages.length - failedMessages.length,
failed: failedMessages.length
};
}
// 带重试的发布
async publishWithRetry(client, topic, message, options, maxRetries = 3) {
for (let i = 0; i < maxRetries; i++) {
try {
return new Promise((resolve, reject) => {
client.publish(topic, JSON.stringify(message), options, (err) => {
if (err) {
reject(err);
} else {
resolve();
}
});
});
} catch (error) {
if (i === maxRetries - 1) {
throw error;
}
// 等待指数退避时间后重试
await new Promise(resolve =>
setTimeout(resolve, 1000 * Math.pow(2, i))
);
}
}
}
}
这套消息持久化机制在实际运行中,即使在网络极端不稳定的情况下,也能保证99.9%的消息最终到达。
5.4 安全加固措施
物联网设备的安全至关重要。除了基本的用户名密码认证,我还实施了以下措施:
-
动态Token认证:
// 获取动态token async function getMqttToken(deviceId) { const response = await uni.request({ url: 'https://api.yourdomain.com/auth/mqtt-token', method: 'POST', data: { deviceId, timestamp: Date.now(), nonce: Math.random().toString(36).substr(2) }, header: { 'Authorization': `Bearer ${getAccessToken()}` } }); return response.data.token; } // 使用token连接 async function connectWithToken() { const token = await getMqttToken(deviceId); const options = { clientId: generateClientId(), username: 'token', password: token, keepalive: 60, clean: true }; // token过期处理 mqttClient.on('error', (error) => { if (error.message.includes('auth') || error.message.includes('token')) { console.log('Token过期,重新获取'); reconnectWithNewToken(); } }); } -
连接频率限制:
// 连接频率控制 class ConnectionThrottle { constructor(maxConnectionsPerMinute = 60) { this.connectionTimes = []; this.maxConnectionsPerMinute = maxConnectionsPerMinute; } canConnect() { const now = Date.now(); const oneMinuteAgo = now - 60000; // 清理一分钟前的记录 this.connectionTimes = this.connectionTimes.filter( time => time > oneMinuteAgo ); // 检查是否超过限制 if (this.connectionTimes.length >= this.maxConnectionsPerMinute) { return false; } this.connectionTimes.push(now); return true; } getWaitTime() { if (this.connectionTimes.length === 0) return 0; const oldest = this.connectionTimes[0]; const now = Date.now(); const timePassed = now - oldest; if (timePassed < 60000) { return 60000 - timePassed; } return 0; } } -
主题权限控制: 在EMQX中配置ACL规则:
# 在etc/emqx/acl.conf中添加 {allow, {user, "device_%c"}, subscribe, ["devices/%c/status"]}. {allow, {user, "device_%c"}, publish, ["devices/%c/data"]}. {allow, {user, "app_user"}, subscribe, ["devices/+/status", "devices/+/data"]}. {allow, {user, "app_user"}, publish, ["devices/+/control"]}. # 禁止所有其他操作 {deny, all}.
这些安全措施实施后,系统运行了半年多,没有出现安全相关的问题。
273



被折叠的 条评论
为什么被折叠?



