Ubuntu 24.04 安装开源WebRTC信令服务器

Ubuntu 24.04 安装开源WebRTC信令服务器

前言

本指南提供了在Ubuntu 24.04环境下安装和配置三种流行的开源WebRTC信令服务器的详细步骤：

1. 系统准备

更新系统包

sudo apt update
sudo apt upgrade -y

安装通用依赖

sudo apt install -y build-essential git curl wget gnupg2 dirmngr

2. 安装Node.js（用于MediaSoup和Simple-Peer-Server）

# 添加Node.js源
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash –

# 安装Node.js
sudo apt install -y nodejs

# 验证安装
node -v
npm -v

3. 安装Janus Gateway

安装依赖

sudo apt install -y libmicrohttpd-dev libjansson-dev \\
libssl-dev libsrtp-dev libsofia-sip-ua-dev libglib2.0-dev \\
libopus-dev libogg-dev libcurl4-openssl-dev liblua5.3-dev \\
libconfig-dev pkg-config gengetopt libtool automake libnice-dev

下载并编译Janus

# 克隆代码
cd ~
git clone https://github.com/meetecho/janus-gateway.git
cd janus-gateway

git checkout v1.0.7 # 使用稳定版本

# 编译安装
./autogen.sh
./configure –prefix=/opt/janus
make -j$(nproc)
sudo make install
sudo make configs

配置Janus

# 编辑配置文件
sudo nano /opt/janus/etc/janus/janus.jcfg

# 在nat_1_1_mapping字段添加服务器公网IP（如果是云服务器）
# nat_1_1_mapping = "your_server_public_ip"

# 启用HTTPS（可选但推荐）
sudo nano /opt/janus/etc/janus/janus.transport.http.jcfg
# 将secure = false 改为 secure = true
# 配置cert_pem和key_pem指向SSL证书文件

创建系统服务

sudo nano /etc/systemd/system/janus.service

添加以下内容：

[Unit]
Description=Janus WebRTC Server
After=network.target

[Service]
ExecStart=/opt/janus/bin/janus
Restart=on-failure
RestartSec=5
User=root

[Install]
WantedBy=multi-user.target

启用并启动服务：

sudo systemctl daemon-reload
sudo systemctl enable janus
sudo systemctl start janus

4. 安装MediaSoup

创建项目目录

mkdir -p ~/mediasoup-server
cd ~/mediasoup-server

初始化项目

npm init -y

安装MediaSoup及依赖

npm install mediasoup mediasoup-client express socket.io

创建基本服务器文件

创建server.js文件：

nano server.js

添加以下内容：

const express = require('express');
const https = require('https');
const fs = require('fs');
const { Server } = require('socket.io');
const mediasoup = require('mediasoup');

const app = express();

// 静态文件服务
app.use(express.static('public'));

// HTTPS服务器配置
const options = {
key: fs.readFileSync('/path/to/your/key.pem'),
cert: fs.readFileSync('/path/to/your/cert.pem')
};

const httpsServer = https.createServer(options, app);
const io = new Server(httpsServer);

// 房间管理
const rooms = new Map();

// MediaSoup配置
const mediaCodecs = [
{
kind: 'audio',
mimeType: 'audio/opus',
clockRate: 48000,
channels: 2
},
{
kind: 'video',
mimeType: 'video/VP8',
clockRate: 90000
}
];

io.on('connection', async (socket) => {
console.log('新客户端连接:', socket.id);

// 房间创建或加入
socket.on('createRoom', async (callback) => {
try {
const router = await mediasoup.createRouter({ mediaCodecs });
const roomId = Math.random().toString(36).substring(2, 15);

rooms.set(roomId, {
router,
peers: new Map()
});

callback({ roomId });
} catch (error) {
console.error('创建房间失败:', error);
callback({ error: error.message });
}
});

socket.on('joinRoom', async ({ roomId }, callback) => {
try {
const room = rooms.get(roomId);
if (!room) {
return callback({ error: '房间不存在' });
}

socket.join(roomId);
callback({ success: true });
} catch (error) {
console.error('加入房间失败:', error);
callback({ error: error.message });
}
});

// WebRTC信令处理
socket.on('getRtpCapabilities', ({ roomId }, callback) => {
const room = rooms.get(roomId);
if (!room) return callback({ error: '房间不存在' });

callback({ rtpCapabilities: room.router.rtpCapabilities });
});

socket.on('createWebRtcTransport', async ({ roomId }, callback) => {
try {
const room = rooms.get(roomId);
if (!room) return callback({ error: '房间不存在' });

const transport = await room.router.createWebRtcTransport({
listenIps: [{
ip: '0.0.0.0',
announcedIp: process.env.ANNOUNCED_IP || '127.0.0.1'
}],
enableUdp: true,
enableTcp: true,
preferUdp: true
});

callback({
id: transport.id,
iceParameters: transport.iceParameters,
iceCandidates: transport.iceCandidates,
dtlsParameters: transport.dtlsParameters
});

room.peers.set(socket.id, { transport });
} catch (error) {
console.error('创建WebRTC传输失败:', error);
callback({ error: error.message });
}
});

// 断开连接
socket.on('disconnect', () => {
console.log('客户端断开连接:', socket.id);
// 清理资源
});
});

// 启动服务器
const PORT = process.env.PORT || 3000;
httpsServer.listen(PORT, () => {
console.log(`MediaSoup服务器运行在 https://localhost:${PORT}`);
});

创建启动脚本

nano start.sh

添加以下内容：

#!/bin/bash

# 设置环境变量
export ANNOUNCED_IP=127.0.0.1 # 替换为你的服务器IP

# 启动服务器
node server.js

设置执行权限：

chmod +x start.sh

5. 安装Simple-Peer-Server（轻量级信令服务器）

创建项目目录

mkdir -p ~/simple-peer-server
cd ~/simple-peer-server

初始化项目

npm init -y

安装依赖

npm install ws uuid

创建服务器文件

nano server.js

添加以下内容：

const WebSocket = require('ws');
const { v4: uuidv4 } = require('uuid');
const https = require('https');
const fs = require('fs');

// 房间管理
const rooms = new Map();

// HTTPS配置
const options = {
key: fs.readFileSync('/path/to/your/key.pem'),
cert: fs.readFileSync('/path/to/your/cert.pem')
};

// 创建HTTPS服务器
const server = https.createServer(options);
const wss = new WebSocket.Server({ server });

// WebSocket连接处理
wss.on('connection', (ws, req) => {
// 为每个连接生成唯一ID
const userId = uuidv4();
console.log(`新用户连接: ${userId}`);

// 存储用户信息
ws.userId = userId;
ws.roomId = null;

// 消息处理
ws.on('message', (message) => {
try {
const data = JSON.parse(message);

switch (data.type) {
case 'join_room':
handleJoinRoom(ws, data.roomId, data.userName);
break;

case 'offer':
case 'answer':
case 'ice_candidate':
// 转发WebRTC信令
forwardSignaling(ws, data);
break;

case 'leave_room':
handleLeaveRoom(ws);
break;

default:
console.log(`未知消息类型: ${data.type}`);
}
} catch (error) {
console.error('消息处理错误:', error);
}
});

// 断开连接处理
ws.on('close', () => {
handleDisconnect(ws);
});

// 错误处理
ws.on('error', (error) => {
console.error(`WebSocket错误 (${userId}):`, error);
});
});

// 处理加入房间
function handleJoinRoom(ws, roomId, userName) {
// 离开当前房间（如果在其他房间中）
if (ws.roomId) {
handleLeaveRoom(ws);
}

// 加入新房间
if (!rooms.has(roomId)) {
rooms.set(roomId, new Map());
}

const room = rooms.get(roomId);
room.set(ws.userId, {
ws,
userName: userName || `用户${ws.userId.substring(0, 8)}`
});

ws.roomId = roomId;

// 通知房间内其他用户
const userList = [];
room.forEach((user, id) => {
if (id !== ws.userId) {
userList.push({ id, userName: user.userName });

// 通知其他用户新用户加入
user.ws.send(JSON.stringify({
type: 'user_joined',
user_id: ws.userId,
nickname: userName || `用户${ws.userId.substring(0, 8)}`
}));
}
});

// 发送房间内用户列表给新用户
ws.send(JSON.stringify({
type: 'room_joined',
room_id: roomId,
users: userList,
user_id: ws.userId
}));

console.log(`${userName || `用户${ws.userId.substring(0, 8)}`} 加入房间 ${roomId}`);
}

// 处理离开房间
function handleLeaveRoom(ws) {
if (!ws.roomId) return;

const room = rooms.get(ws.roomId);
if (!room) return;

const user = room.get(ws.userId);
room.delete(ws.userId);

// 如果房间为空，删除房间
if (room.size === 0) {
rooms.delete(ws.roomId);
} else {
// 通知其他用户
room.forEach((u) => {
u.ws.send(JSON.stringify({
type: 'user_left',
user_id: ws.userId,
nickname: user ? user.userName : `用户${ws.userId.substring(0, 8)}`
}));
});
}

console.log(`${user ? user.userName : `用户${ws.userId.substring(0, 8)}`} 离开房间 ${ws.roomId}`);
ws.roomId = null;
}

// 处理断开连接
function handleDisconnect(ws) {
console.log(`用户断开连接: ${ws.userId}`);
handleLeaveRoom(ws);
}

// 转发WebRTC信令
function forwardSignaling(ws, data) {
if (!ws.roomId) {
ws.send(JSON.stringify({
type: 'error',
message: '必须先加入房间'
}));
return;
}

const room = rooms.get(ws.roomId);
if (!room) return;

// 添加发送者信息
data.sender_id = ws.userId;
data.from_user_id = ws.userId;
data.sender_name = room.get(ws.userId)?.userName || `用户${ws.userId.substring(0, 8)}`;
data.from_user_name = data.sender_name;

// 支持两种目标用户ID字段名
const targetUserId = data.target_user_id || data.recipient_id;
if (!targetUserId) {
ws.send(JSON.stringify({
type: 'error',
message: '缺少目标用户ID'
}));
return;
}

const targetUser = room.get(targetUserId);
if (!targetUser) {
ws.send(JSON.stringify({
type: 'error',
message: '目标用户不在房间中'
}));
return;
}

// 转发消息给目标用户
targetUser.ws.send(JSON.stringify(data));
}

// 启动服务器
const PORT = process.env.PORT || 8443;
server.listen(PORT, () => {
console.log(`信令服务器运行在 https://0.0.0.0:${PORT}`);
});

创建启动脚本

nano start.sh

添加以下内容：

#!/bin/bash

# 启动服务器
node server.js

设置执行权限：

chmod +x start.sh

6. 与当前项目集成

修改前端连接配置

修改/home/lhz/meeting/static/js/app.js中的WebSocket连接URL：

// 替换initWebSocket函数中的连接URL
function initWebSocket() {
// 使用Simple-Peer-Server
const wsUrl = 'wss://your-server-ip:8443';
// 或使用Janus
// const wsUrl = 'wss://your-server-ip:8188';

state.socket = new WebSocket(wsUrl);

// 其余代码保持不变…
}

配置ICE服务器

确保ICE_SERVERS配置在server.py和前端代码中一致：

# 在server.py中
ICE_SERVERS = [
RTCIceServer(urls='stun:stun.l.google.com:19302'),
RTCIceServer(urls='stun:stun1.l.google.com:19302'),
# 添加自己的TURN服务器配置
RTCIceServer(
urls='turn:your-turn-server.com:443?transport=tcp',
username='your-username',
credential='your-credential'
)
]

7. 生成SSL证书

对于HTTPS/WSS连接，需要SSL证书：

# 生成自签名证书（开发环境）
openssl req -x509 -newkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -nodes

# 将证书复制到需要的位置
mkdir -p ~/ssl
cp key.pem cert.pem ~/ssl/

8. 防火墙配置

# 开放必要的端口
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp
sudo ufw allow 3478/udp # STUN/TURN端口
sudo ufw allow 49152:65535/udp # WebRTC媒体端口范围
sudo ufw reload

9. 监控和日志

Janus日志

# 查看Janus日志
sudo journalctl -u janus -f

MediaSoup/Simple-Peer-Server日志

可以使用pm2来管理Node.js进程并查看日志：

# 安装pm2
sudo npm install -g pm2

# 启动服务并设置开机自启
cd ~/simple-peer-server
pm2 start server.js –name signaling-server
pm2 startup
pm2 save

# 查看日志
pm2 logs signaling-server

10. 性能优化建议

11. 推荐方案总结

根据您的实际需求和服务器资源选择合适的方案。