Conference Integration Guide¶

1. Overview¶

This guide provides detailed instructions to deploy the Meet Altegon Conference Platform in a Dockerized environment, integrating:

Frontend (Meet Altegon)
API Server (altegon-meet-api) for business logic and security (via X_API_KEY)
Recording Socket (for recording)
Video Engine (handling real-time video/audio streams and rooms)

The architecture uses Docker for deployment and is secured with HTTPS via Nginx.

2. Network and Firewall Requirements¶

Ensure the following ports are open:

Port	Protocol	Purpose	Service
80	TCP	HTTP (Redirect to HTTPS)	Nginx
443	TCP	HTTPS Frontend & API	Nginx → altegon-meet-api (8000)
8000 or /api	TCP	API Backend (`/api`, `/socket.io.backend/`)	Nginx → localhost:8000
/nuve	TCP	Nuve API Proxy	Nginx → 3010 (Docker)
/nuve2	TCP	Video Engine	Nginx → 3011 (Docker)
/socket.io.nuve	TCP	WebSocket Signaling Proxy	Nginx → 8081 (Docker)
/recording-socket	TCP	Recording Socket (`/recording-socket/` & `/recording-socket/socket.io/`)	Nginx → localhost:3006 (Docker)

3. Prerequisites & System Requirements¶

Required Utilities¶

bash, curl, wget, tar, xz-utils

Required Packages¶

Docker Engine – For containerization
Docker Compose – For managing multi-container applications
Node.js & npm – For running the API services
Nginx – Reverse proxy & HTTPS configuration
Certbot – For SSL certificate generation & renewal
MongoDB & Redis – Required for Recording Socket service
FFmpeg – For video/audio processing
Redis - Used for session management, signaling, and as a message broker between services

Redis Configuration¶

Ensure Redis is configured as master and accessible.

Edit redis.conf:

# Allow external access
bind 0.0.0.0

# Require authentication
requirepass securedpassword

# Always master (don’t accept replication)
replica-serve-stale-data no
replica-read-only no

FFmpeg Setup¶

Install FFmpeg and ensure consistent version across systems.

cd /usr/local/bin
wget https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz
tar -xf ffmpeg-master-latest-linux64-gpl.tar.xz
cp ffmpeg-master-latest-linux64-gpl/bin/ffmpeg /usr/local/bin/
cp ffmpeg-master-latest-linux64-gpl/bin/ffprobe /usr/local/bin/

Verify:

ffmpeg -version
ffmpeg -filters | grep drawtext

4. Setup Instructions¶

Backend Server Setup¶

Purpose:¶

Provides X-API-Key based authentication
Implements business logic
Manages client-specific features
Adds a secure layer between clients and core video engine

Steps:¶

Clone the Repository¶

git clone git@github.com:Altegon/altegon-meet-apis.git
cd altegon-meet-apis
git checkout dev

Create the Dockerfile¶

FROM node:18
WORKDIR /usr/src/app
RUN apt-get update && apt-get install -y nano curl bash && rm -rf /var/lib/apt/lists/*
COPY package*.json ./
RUN npm install --production --legacy-peer-deps
COPY . .
EXPOSE 8000
CMD ["node", "app.js"]

Build the Docker Image¶

sudo docker build -t altegon/altegon-meet-apis:latest .

Run the Docker Container¶

- Ensure /opt/altegon-meet-apis/.env exists with MongoDB, Redis, and JWT credentials.

bash sudo docker run -d --restart always \ -v /opt/altegon-meet-apis/.env:/usr/src/app/.env \ -v /opt/altegon-meet-apis/public:/usr/src/app/public \ -p 8000:8000 \ --name altegon-meet-apis \ altegon/altegon-meet-apis:latest

Video Engine Setup (Docker)¶

Purpose:¶

Handles rooms, streams, and signaling.

Steps:¶

Create working directory¶

mkdir /opt/video-engine
cd /opt/video-engine

Create docker-compose.yml:¶

version: '3'
services:
  rtc-engine:
    image: altegon/rtc-video-engine:v2
    container_name: altegonengine
    ports:
      - "3010:3000"
      - "3011:3001"
      - "8081:8080"
      - "30000-30050:30000-30050/udp"
    volumes:
      - ./docker-volume/opt:/opt
    environment:
      PUBLIC_IP=your-domain-name
      MIN_PORT=30000
      MAX_PORT=30050
      SSL=true
    restart: always

  mongodb:
    image: mongo:latest
    container_name: mongodb
    ports:
      - "27017:27017"
    volumes:
      - ./mongo-data:/data/db
    environment:
      MONGO_INITDB_ROOT_USERNAME=Username
      MONGO_INITDB_ROOT_PASSWORD=YourDBPassword
    restart: always

volumes:
  mongo-data:

Start services:¶

docker compose up -d

Pull updated image:¶

docker pull altegon/rtc-video-engine:v2

SSL Certificate Setup (Certbot)¶

Setup:¶

sudo apt install certbot python3-certbot-nginx
sudo certbot certonly --nginx -d domain-name

Auto-renew SSL:¶

sudo crontab -e
0 0 * * * certbot renew --quiet

5. Post-Setup Configuration¶

MongoDB “services” Collection¶

{
  "name": "superService",
  "key": "any5DigitKey",
  "rooms": []
}

Update Nuve Config¶

config.nuve.dataBaseURL = "YourMongoDbConnectionString";
config.nuve.dataBaseName = "DBName";
config.nuve.superserviceID = "serviceID";
config.nuve.superserviceKey = "ServiceKey";

WebRTC ICE Servers¶

config.erizoController.iceServers = [
  { url: 'stun:stun.l.google.com:19302' },
  { url: 'turn:yourDomain:3478?transport=tcp', username: 'coturn_user', credential: 'yourPassword' },
  { url: 'turn:yourDomain:3478?transport=udp', username: 'coturn_user', credential: 'yourPassword' },
  { url: 'turns:relay.sawt.app:5349?transport=tcp', username: 'coturn_user', credential: 'yourPassword' }
];

Example Nginx Configuration¶

# Redirect HTTP to HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name yourDomainNameHere;
    return 301 https://$host$request_uri;
}

server {
    listen 443 ssl http2;
    listen [::]:443 ssl http2;
    server_name yourDomainNameHere;

    ssl_certificate /etc/ssl/altegon/yourDomainNameHere.pem;
    ssl_certificate_key /etc/ssl/altegon/yourDomainNameHere.key.pem;

    # Altegon Meet API service
    location /api/ {
        proxy_pass http://localhost:8000;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }

    # WebSocket handling
    location /socket.io/ {
        proxy_pass http://localhost:8000/socket.io/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection 'upgrade';
    }

    # Video Engine Controller (Nuve)
    location /nuve/ {
        proxy_pass http://localhost:3010/;
        proxy_http_version 1.1;
    }

    # Secondary Video Engine
    location /nuve2/ {
        proxy_pass http://localhost:3011/;
        add_header 'Access-Control-Allow-Origin' '*';
    }

    # WebSocket for Video Engine
    location /socket.io.nuve/ {
        proxy_pass http://localhost:8081/socket.io/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        proxy_read_timeout 86400;
    }

    # Recording Socket Service
    location /recording-socket/ {
        proxy_pass http://localhost:3006/;
        add_header 'Access-Control-Allow-Origin' '*';
    }

    location /recording-socket/socket.io/ {
        proxy_pass http://localhost:3006/socket.io/;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }

    access_log /var/log/nginx/access_prod.altegon.com.log;
    error_log /var/log/nginx/error_prod.altegon.com.log;
}

6. Recording Server Setup¶

Clone the Project¶

git clone git@github.com:Altegon/recording-socket.git
cd recording-socket
git checkout live

Create Host Folders¶

sudo mkdir -p /opt/altegon-meet-apis/public
sudo chmod -R 777 /opt/altegon-meet-apis/public

Create .env File¶

/opt/recording-socket/.env

PORT=3006
RECORDING_DIR_PATH=/opt/altegon-meet-apis/public
SERVER_URL=https://demo.altegon.com
X_API_KEY=YourXApiKey

Dockerfile¶

FROM node:20-slim
WORKDIR /app
RUN apt-get update && apt-get install -y wget xz-utils ca-certificates && rm -rf /var/lib/apt/lists/*
RUN cd /usr/local/bin && \
    wget https://github.com/BtbN/FFmpeg-Builds/releases/download/latest/ffmpeg-master-latest-linux64-gpl.tar.xz && \
    tar -xf ffmpeg-master-latest-linux64-gpl.tar.xz && \
    cp ffmpeg-master-latest-linux64-gpl/bin/ffmpeg /usr/local/bin/ && \
    cp ffmpeg-master-latest-linux64-gpl/bin/ffprobe /usr/local/bin/ && \
    rm -rf ffmpeg-master-latest-linux64-gpl*
COPY package*.json ./
RUN npm install --legacy-peer-deps
COPY . .
EXPOSE 3006
CMD ["node", "index.js"]

Build and Run¶

sudo docker build -t altegon/recording-socket:latest .
sudo docker run -d \
  --restart always \
  -v /opt/recording-socket/.env:/app/.env \
  -v /opt/altegon-meet-apis/public:/app/public \
  -p 3006:3006 \
  --name recording-socket \
  altegon/recording-socket:latest

7. Dockerized Altegon Frontend¶

Overview¶

Frontend Repo: git@github.com:Altegon/meet.git (branch: qa/live) RTC Library: git@github.com:Altegon/rtc-lib.git (branch: meet-altegon)

Directory Structure¶

/opt/
 └── meet/
      ├── rtc-lib/
      │    ├── dist/rtc-lib/
      │    └── package.json
      ├── src/
      ├── package.json
      ├── Dockerfile
      ├── nginx.conf
      └── angular.json

Build RTC Library¶

cd /opt/meet/rtc-lib
npm install --legacy-peer-deps
npm run build

Dockerfile¶

FROM node:18 AS build
WORKDIR /app
COPY package.json package-lock.json ./
RUN npm install --legacy-peer-deps
COPY . .
WORKDIR /app/rtc-lib/dist/rtc-lib
RUN npm link
WORKDIR /app
RUN npm link rtc-lib
RUN npm run build --prod

FROM nginx:alpine
COPY --from=build /app/dist/my-app /usr/share/nginx/html
COPY nginx.conf /etc/nginx/conf.d/default.conf
EXPOSE 80
CMD ["nginx", "-g", "daemon off;"]

.dockerignore¶

node_modules
dist
rtc-lib/node_modules
rtc-lib/dist
.git
.gitignore
Dockerfile
.dockerignore
tmp
.env
*.log

nginx.conf¶

server {
    listen 80;
    server_name localhost;

    root /usr/share/nginx/html;
    index index.html;

    location / {
        try_files $uri $uri/ /index.html;
    }

    location = /robots.txt {}
    location = /favicon.ico {}
}

Build and Run¶

docker build -t altegon-meet .
docker run -d --name altegon-meet -p 4200:80 altegon-meet

Access:

http://<your-server-ip>:4200

Check logs:

docker logs altegon-meet