Grundlegende Einführung von mediasoup und Bereitstellung von mediasoup in der Ubuntu/Docker-Umgebung

1. Grundlegende Einführung von mediasoup und Bereitstellung von mediasoup in einer Ubuntu/Docker-Umgebung

0. Verzeichnis

1. Grundlegende Einführung in mediasoup
2. Installation und Bereitstellung der Ubuntu-Umgebung mediasoup-demo
3. Installation und Bereitstellung der Docker-Umgebung mediasoup-demo

In Verbindung stehende Artikel:

1. Grundlegende Einführung von mediasoup und Bereitstellung von mediasoup in der Ubuntu/Docker-Umgebung
2. Analyse des Quellcodes des Mediasoup-Demoservers

1. Grundlegende Einführung in mediasoup

1. Laut der offiziellen Website von mediasoup ist mediasoup ein Open-Source-WebRTC-Medienserver, der auf der SFU-Netzwerkarchitektur basiert. Die untere Schicht ist in C++ implementiert, und die äußere Schicht ist in Node.js gekapselt. Die mediasoup-Serverseite wird als Node.js-Modul bereitgestellt.
   1. MediaSoup wird hauptsächlich zum Erstellen von Echtzeit-Kommunikationsanwendungen wie Videokonferenzen, Audio-Chat, Bildschirmfreigabe und Live-Streaming usw. verwendet.
   2. Informationen zur WebRTC-Netzwerkarchitektur finden Sie unter:
2. mediasoup-Funktionen:
   1. Basierend auf dem WebRTC-Standard: Mit der WebRTC-Technologie als Kern unterstützt es Audio- und Videokommunikation in Echtzeit.
   2. Skalierbarkeit: Die Skalierbarkeit des Medienservers kann einfach erweitert werden, um den Anforderungen verschiedener Anwendungen gerecht zu werden.
   3. Flexibilität: Umfangreiche APIs werden bereitgestellt, um verschiedene Medienverarbeitungs- und -übertragungsvorgänge anzupassen.
   4. Sicherheit: Unterstützt DTLS und SRTP, um die Sicherheit der Medienkommunikation zu schützen.
   5. Open Source: Vollständig Open Source, kostenlos zu verwenden und zu modifizieren.
3. Die Gesamtarchitektur von mediasoup:

2. Installation und Bereitstellung der Ubuntu-Umgebung Mediasoup-Demo

1. mediasoup-demo ist eine auf mediasoup basierende Beispielanwendung, die verwendet wird, um die Funktionen und die Verwendung von mediasoup zu demonstrieren.
2. Verwenden Sie als Nächstes die Ubuntu-Umgebung, um mediasoup-demo zu installieren.
   

1. Installieren Sie die nodejs-Umgebung

1. Node.js installieren: Vor der Installation von mediasoup-demo müssen Sie zuerst die Node.js-Betriebsumgebung installieren.

sudo apt-get update
sudo apt-get install nodejs
sudo apt-get install npm

//备注，直接安装的nodejs版本可以后续下载依赖会报错，我使用的是：node-v16.14.0-linux-x64
wge https://nodejs.org/dist/v16.14.0/node-v16.14.0-linux-x64.tar.gz
tar -zxvf node-v16.14.0-linux-x64.tar.xz
cd node-v16.14.0-linux-x64/
sudo ln -s ./bin/node /usr/local/bin/
sudo ln -s ./bin/npm /usr/local/bin/ 

2. Klonen Sie den mediasoup-Demo-Code

1. Klonen Sie den Code im mediasoup-demo-Repository:

git clone https://github.com/versatica/mediasoup-demo.git

3. Mediasoup-Demo-Abhängigkeiten installieren und konfigurieren

1. Installationsabhängigkeiten: Geben Sie das Projektverzeichnis mediasoup-demo ein und installieren Sie die für das Projekt erforderlichen Abhängigkeiten:
   1. Hinweis: npm install installiert abhängige Pakete, die über die Wand gehen müssen, andernfalls wird der Download fehlschlagen.

cd mediasoup-demo
git checkout v3
cd server
npm install

2. Nachdem die Installationsabhängigkeiten abgeschlossen sind, kopieren Sie die Konfigurationsdatei und konfigurieren Sie:
   1. Ändern Sie nach dem Kopieren einige Konfigurationselemente wie webRtcTransportOptions und plainRtpTransportOptions von config.js. Das Folgende ist die ursprüngliche Konfigurationsdatei von config.js

/**
 * IMPORTANT (PLEASE READ THIS):
 *
 * This is not the "configuration file" of mediasoup. This is the configuration
 * file of the mediasoup-demo app. mediasoup itself is a server-side library, it
 * does not read any "configuration file". Instead it exposes an API. This demo
 * application just reads settings from this file (once copied to config.js) and
 * calls the mediasoup API with those settings when appropriate.
 */

const os = require('os');

module.exports =
{
    
    
	// Listening hostname (just for `gulp live` task).
	domain : process.env.DOMAIN || 'localhost',
	// Signaling settings (protoo WebSocket server and HTTP API server).
	https  :
	{
    
    
		listenIp   : '0.0.0.0',
		// NOTE: Don't change listenPort (client app assumes 4443).
		listenPort : process.env.PROTOO_LISTEN_PORT || 4443,
		// NOTE: Set your own valid certificate files.
		tls        :
		{
    
    
			cert : process.env.HTTPS_CERT_FULLCHAIN || `${
    
    __dirname}/certs/fullchain.pem`,
			key  : process.env.HTTPS_CERT_PRIVKEY || `${
    
    __dirname}/certs/privkey.pem`
		}
	},
	// mediasoup settings.
	mediasoup :
	{
    
    
		// Number of mediasoup workers to launch.
		numWorkers     : Object.keys(os.cpus()).length,
		// mediasoup WorkerSettings.
		// See https://mediasoup.org/documentation/v3/mediasoup/api/#WorkerSettings
		workerSettings :
		{
    
    
			logLevel : 'warn',
			logTags  :
			[
				'info',
				'ice',
				'dtls',
				'rtp',
				'srtp',
				'rtcp',
				'rtx',
				'bwe',
				'score',
				'simulcast',
				'svc',
				'sctp'
			],
			rtcMinPort : process.env.MEDIASOUP_MIN_PORT || 40000,
			rtcMaxPort : process.env.MEDIASOUP_MAX_PORT || 49999
		},
		// mediasoup Router options.
		// See https://mediasoup.org/documentation/v3/mediasoup/api/#RouterOptions
		routerOptions :
		{
    
    
			mediaCodecs :
			[
				{
    
    
					kind      : 'audio',
					mimeType  : 'audio/opus',
					clockRate : 48000,
					channels  : 2
				},
				{
    
    
					kind       : 'video',
					mimeType   : 'video/VP8',
					clockRate  : 90000,
					parameters :
					{
    
    
						'x-google-start-bitrate' : 1000
					}
				},
				{
    
    
					kind       : 'video',
					mimeType   : 'video/VP9',
					clockRate  : 90000,
					parameters :
					{
    
    
						'profile-id'             : 2,
						'x-google-start-bitrate' : 1000
					}
				},
				{
    
    
					kind       : 'video',
					mimeType   : 'video/h264',
					clockRate  : 90000,
					parameters :
					{
    
    
						'packetization-mode'      : 1,
						'profile-level-id'        : '4d0032',
						'level-asymmetry-allowed' : 1,
						'x-google-start-bitrate'  : 1000
					}
				},
				{
    
    
					kind       : 'video',
					mimeType   : 'video/h264',
					clockRate  : 90000,
					parameters :
					{
    
    
						'packetization-mode'      : 1,
						'profile-level-id'        : '42e01f',
						'level-asymmetry-allowed' : 1,
						'x-google-start-bitrate'  : 1000
					}
				}
			]
		},
		// mediasoup WebRtcServer options for WebRTC endpoints (mediasoup-client,
		// libmediasoupclient).
		// See https://mediasoup.org/documentation/v3/mediasoup/api/#WebRtcServerOptions
		// NOTE: mediasoup-demo/server/lib/Room.js will increase this port for
		// each mediasoup Worker since each Worker is a separate process.
		webRtcServerOptions :
		{
    
    
			listenInfos :
			[
				{
    
    
					protocol    : 'udp',
					ip          : process.env.MEDIASOUP_LISTEN_IP || '0.0.0.0',
					announcedIp : process.env.MEDIASOUP_ANNOUNCED_IP,
					port        : 44444
				},
				{
    
    
					protocol    : 'tcp',
					ip          : process.env.MEDIASOUP_LISTEN_IP || '0.0.0.0',
					announcedIp : process.env.MEDIASOUP_ANNOUNCED_IP,
					port        : 44444
				}
			],
		},
		// mediasoup WebRtcTransport options for WebRTC endpoints (mediasoup-client,
		// libmediasoupclient).
		// See https://mediasoup.org/documentation/v3/mediasoup/api/#WebRtcTransportOptions
		webRtcTransportOptions :
		{
    
    
			// listenIps is not needed since webRtcServer is used.
			// However passing MEDIASOUP_USE_WEBRTC_SERVER=false will change it.
			listenIps :
			[
				{
    
    
					ip          : process.env.MEDIASOUP_LISTEN_IP || '0.0.0.0',
					announcedIp : process.env.MEDIASOUP_ANNOUNCED_IP
				}
			],
			initialAvailableOutgoingBitrate : 1000000,
			minimumAvailableOutgoingBitrate : 600000,
			maxSctpMessageSize              : 262144,
			// Additional options that are not part of WebRtcTransportOptions.
			maxIncomingBitrate              : 1500000
		},
		// mediasoup PlainTransport options for legacy RTP endpoints (FFmpeg,
		// GStreamer).
		// See https://mediasoup.org/documentation/v3/mediasoup/api/#PlainTransportOptions
		plainTransportOptions :
		{
    
    
			listenIp :
			{
    
    
				ip          : process.env.MEDIASOUP_LISTEN_IP || '0.0.0.0',
				announcedIp : process.env.MEDIASOUP_ANNOUNCED_IP
			},
			maxSctpMessageSize : 262144
		}
	}
};

3. Die Konfigurationsdatei config.js kann Parameter ändern, wie z. B.: Webport, maximale und minimale Mediasoup-Ports, Mediasoup-Listening-IP und andere Informationen.
   1. Legen Sie die Parameter im Terminal fest (Sie können sie auch direkt in config.js ändern), und diese Parameter werden abgerufen, wenn mediasoup-demo nach dem Festlegen des Terminals gestartet wird:

export WEBPORT="3000"
export MEDIASOUP_LISTEN_IP="公网ip"
export MEDIASOUP_MIN_PORT="44440"
export MEDIASOUP_MAX_PORT="44500"

//查看是否设置成功，例如：
echo $MEDIASOUP_LISTEN_IP

4. Geben Sie das App-Verzeichnis von mediasoup-demo ein:

cd mediasoup-demo/app
npm install //如果失败，可以执行：npm install --legacy-peer-deps
sudo npm install -g gulp-cli //全局安装gulp-cli

4. Führen Sie das Projekt mediasoup-demo aus

1. Öffnen Sie ein Terminal und führen Sie den Server aus:

cd mediasoup-demo/server
node server.js

2. Öffnen Sie ein anderes Terminal, um die Start-App zu öffnen:

cd mediasoup-demo/app
gulp live

3. Verwenden Sie einen Browser für Videokonferenzen und testen Sie den Link: https://public IP:3000/?roomId=imohqpdp , sodass beide Browser auf denselben Konferenzraum zugreifen.
   1. Wobei imohqpdp die Besprechungsraum-ID ist

4. Hinweis: Wenn Sie nach der Konfiguration nicht zugreifen können, überprüfen Sie bitte, ob der Server den entsprechenden Port geöffnet hat. Zum Beispiel verwende ich Tencent Cloud Server, und der Port muss geöffnet werden:
   1. TCP-Ports: 3000, 4443, 44440-44500
   2. UDP-Port: 44440-44500

3. Installation und Bereitstellung der Docker-Umgebung mediasoup-demo

1. Wenn Sie den Quellcode von mediasoup-demo kompilieren und Abhängigkeiten auf dem Server installieren, müssen Sie sich mit dem externen Netzwerk verbinden, um einige Abhängigkeiten herunterzuladen, sodass es leicht ist, in diesem Schritt hängen zu bleiben, und Sie können die Docker-Bereitstellung zum Testen verwenden.
   

1. Laden Sie das mediasoup-Demo-Image herunter

1. Laden Sie das mediasoup-Demo-Image herunter:

sudo docker pull lc0060305/mediasoup-demo:v5

2. Laden Sie das run.sh-Skript herunter

1. Laden Sie das run.sh-Skript herunter

wget https://cdn.avdancedu.com/image/article/docker/v1/run.sh

2. Inhalt des run.sh-Skripts:

#!/usr/bin/env bash

export DEBUG=${
    
    DEBUG:="mediasoup:INFO* *WARN* *ERROR*"}
export WEBPORT=${
    
    WEBPORT:="3000"}
export INTERACTIVE=${
    
    INTERACTIVE:="false"}
export PROTOO_LISTEN_PORT=${
    
    PROTOO_LISTEN_PORT:="4443"}
export HTTPS_CERT_FULLCHAIN=${
    
    HTTPS_CERT_FULLCHAIN:="/service/certs/fullchain.pem"}
export HTTPS_CERT_PRIVKEY=${
    
    HTTPS_CERT_PRIVKEY:="/service/certs/privkey.pem"}
export MEDIASOUP_LISTEN_IP=${
    
    MEDIASOUP_LISTEN_IP:="0.0.0.0"}
export MEDIASOUP_MIN_PORT=${
    
    MEDIASOUP_MIN_PORT:="44440"}
export MEDIASOUP_MAX_PORT=${
    
    MEDIASOUP_MAX_PORT:="44500"}

# Valgrind related options.
export MEDIASOUP_USE_VALGRIND=${
    
    MEDIASOUP_USE_VALGRIND:="false"}
export MEDIASOUP_VALGRIND_OPTIONS=${
    
    MEDIASOUP_VALGRIND_OPTIONS:="--leak-check=full --track-fds=yes --log-file=/storage/mediasoup_valgrind_%p.log"}

docker run \
	--name=mediasoup-demo \
	-p ${
    
    WEBPORT}:${
    
    WEBPORT}/tcp \
	-p ${
    
    PROTOO_LISTEN_PORT}:${
    
    PROTOO_LISTEN_PORT}/tcp \
	-p ${
    
    MEDIASOUP_MIN_PORT}-${
    
    MEDIASOUP_MAX_PORT}:${
    
    MEDIASOUP_MIN_PORT}-${
    
    MEDIASOUP_MAX_PORT}/udp \
	-p ${
    
    MEDIASOUP_MIN_PORT}-${
    
    MEDIASOUP_MAX_PORT}:${
    
    MEDIASOUP_MIN_PORT}-${
    
    MEDIASOUP_MAX_PORT}/tcp \
	-v ${
    
    PWD}:/storage \
	-v ${
    
    MEDIASOUP_SRC}:/mediasoup-src \
	--init \
	-e DEBUG \
	-e INTERACTIVE \
	-e DOMAIN \
	-e PROTOO_LISTEN_PORT \
	-e HTTPS_CERT_FULLCHAIN \
	-e HTTPS_CERT_PRIVKEY \
	-e MEDIASOUP_LISTEN_IP \
	-e MEDIASOUP_ANNOUNCED_IP \
	-e MEDIASOUP_MIN_PORT \
	-e MEDIASOUP_MAX_PORT \
	-e MEDIASOUP_USE_VALGRIND \
	-e MEDIASOUP_VALGRIND_OPTIONS \
	-e MEDIASOUP_WORKER_BIN \
	-dit \
	--rm \
	lc0060305/mediasoup-demo:v5

3. Docker starten

1. Sie müssen run.sh die Ausführungsberechtigung hinzufügen, um Docker zu starten:

chmod +x run.sh
sudo MEDIASOUP_ANNOUNCED_IP=公网IP ./run.sh

4. Führen Sie das Projekt mediasoup-demo aus

1. Nach dem erfolgreichen Start von Docker müssen Sie den mediasoup-Dienst starten.
2. Fragen Sie die Docker-ID des mediasoup-Dienstes ab:

sudo docker ps

3. Nachdem Sie die dockerID erhalten haben, geben Sie den Docker von mediasoup ein:

sudo docker attach containerID

4. Führen Sie das Skript startservice.sh im Verzeichnis /service aus:
   1. Nachdem der Dienst gestartet wurde, geben Sie Strg+P, Strg+Q ein, um Docker zu beenden

startservice.sh

5. Verwenden Sie einen Browser für Videokonferenzen und testen Sie den Link: https://public IP:3000/?roomId=imohqpdp , sodass beide Browser auf denselben Konferenzraum zugreifen.
   1. Wobei imohqpdp die Besprechungsraum-ID ist

6. Hinweis: Wenn Sie nach der Konfiguration nicht zugreifen können, überprüfen Sie bitte, ob der Server den entsprechenden Port geöffnet hat. Zum Beispiel verwende ich Tencent Cloud Server, und der Port muss geöffnet werden:
   1. TCP-Ports: 3000, 4443, 44440-44500
   2. UDP-Port: 44440-44500