Deploying OpenMeetings

Introduction

Apache OpenMeetings is an open-source video conferencing, instant messaging, and collaboration platform. Part of the Apache Software Foundation, OpenMeetings provides a comprehensive solution for web conferences, webinars, online training, and team collaboration with features rivaling commercial alternatives.

OpenMeetings supports video and audio conferencing, screen sharing, document collaboration, whiteboard, and recording. The platform uses WebRTC for browser-based communication, eliminating the need for plugins while providing high-quality real-time video.

Key highlights of OpenMeetings:

Video Conferencing: HD video meetings with multiple participants
Screen Sharing: Share your screen or specific applications
Whiteboard: Interactive drawing and annotation tools
Document Sharing: Upload and collaboratively view documents
Recording: Record meetings for later playback
Chat: Instant messaging during and outside meetings
Calendar Integration: Schedule meetings with built-in calendar
User Management: Roles, groups, and permissions
Room Types: Conference rooms, webinar, and interview modes
LDAP/OAuth: Integration with existing identity systems
REST API: Programmatic access for integration

This guide walks through deploying OpenMeetings on Klutch.sh using Docker, configuring video settings, and setting up your conferencing platform for production use.

Why Deploy OpenMeetings on Klutch.sh

Deploying OpenMeetings on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically builds and deploys your conferencing platform. Push to GitHub, and your meeting server deploys without manual intervention.

Persistent Storage: Attach persistent volumes for recordings, documents, and database. Your meeting data survives container restarts.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, essential for WebRTC security and browser permissions.

Scalable Resources: Video conferencing is resource-intensive. Allocate CPU and memory based on expected participant count.

Always-On Availability: Your meeting platform runs 24/7, ready for scheduled and ad-hoc meetings.

Custom Domains: Use your organization’s domain for professional meeting URLs.

Data Privacy: Keep all meeting data and recordings on infrastructure you control.

Prerequisites

Before deploying OpenMeetings on Klutch.sh, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your OpenMeetings configuration
Basic familiarity with Docker and containerization concepts
Custom domain with valid SSL (required for WebRTC)
(Optional) LDAP server for directory integration

Understanding OpenMeetings Architecture

OpenMeetings consists of several components:

Application Server: Java-based backend handling business logic, user management, and room coordination.

Kurento Media Server: Processes WebRTC streams for video routing, recording, and transcoding.

Database: Stores user accounts, room configurations, and meeting metadata. Supports MySQL, PostgreSQL, and others.

File Storage: Documents, recordings, and uploaded files stored on the filesystem.

Redis: Optional caching layer for improved performance in clustered setups.

Preparing Your Repository

Create a GitHub repository containing your Dockerfile and configuration.

Repository Structure

openmeetings-deploy/
├── Dockerfile
├── docker-compose.yml
├── .dockerignore
└── README.md

Creating the Dockerfile

Create a Dockerfile for OpenMeetings:

FROM apache/openmeetings:latest

# Environment configuration
ENV OM_DB_TYPE=mysql
ENV OM_DB_HOST=mysql
ENV OM_DB_PORT=3306
ENV OM_DB_NAME=openmeetings
ENV OM_DB_USER=om_user
ENV OM_DB_PASS=om_password

# Kurento Media Server settings
ENV KMS_URL=ws://kurento:8888/kurento

# Create directories for persistent data
RUN mkdir -p /opt/openmeetings/data
RUN mkdir -p /opt/openmeetings/upload

# Expose ports
EXPOSE 5443

# Use default entrypoint

Environment Variables Reference

Variable	Default	Description
`OM_DB_TYPE`	-	Database type (mysql, postgresql, h2)
`OM_DB_HOST`	-	Database server hostname
`OM_DB_PORT`	-	Database server port
`OM_DB_NAME`	-	Database name
`OM_DB_USER`	-	Database username
`OM_DB_PASS`	-	Database password
`KMS_URL`	-	Kurento Media Server WebSocket URL
`OM_WEBAPP_URL`	-	External URL for the application

Deploying OpenMeetings on Klutch.sh

Follow these steps to deploy your OpenMeetings server:

Deploy Required Services

OpenMeetings requires additional services:

MySQL/PostgreSQL Database: Deploy a database instance first
Kurento Media Server: Required for WebRTC processing

Note the connection details for configuration.

Push Your Repository to GitHub

Initialize and push your repository:

git init
git add Dockerfile .dockerignore README.md
git commit -m "Initial OpenMeetings configuration"
git remote add origin https://github.com/yourusername/openmeetings-deploy.git
git push -u origin main

Create a New Project on Klutch.sh

Navigate to the Klutch.sh dashboard and create a new project named “openmeetings” or “conferencing”.

Create a New App

Within your project, create a new app. Connect your GitHub account and select the repository containing your OpenMeetings Dockerfile.

Configure HTTP Traffic

In the deployment settings:

Select HTTP as the traffic type
Set the internal port to 5443

Set Environment Variables

Configure your OpenMeetings instance:

Variable	Value
`OM_DB_TYPE`	`mysql`
`OM_DB_HOST`	Your database host
`OM_DB_PORT`	`3306`
`OM_DB_NAME`	`openmeetings`
`OM_DB_USER`	Your database user
`OM_DB_PASS`	Your database password
`KMS_URL`	Your Kurento WebSocket URL
`OM_WEBAPP_URL`	`https://your-app-name.klutch.sh`

Attach Persistent Volumes

Add persistent storage:

Mount Path	Recommended Size	Purpose
`/opt/openmeetings/data`	50 GB	Application data and configuration
`/opt/openmeetings/upload`	100 GB	Uploaded documents and recordings

Deploy Your Application

Click Deploy to start the build process.

Complete Initial Setup

Access OpenMeetings at https://your-app-name.klutch.sh:

Run the installation wizard
Configure database connection
Create admin account
Set default timezone and language
Configure email settings

Initial Configuration

Creating Rooms

Set up meeting rooms:

Log in as administrator
Navigate to Administration > Conference Rooms
Click “Add Room”
Configure room settings:
- Name and description
- Room type (conference, webinar, interview)
- Maximum participants
- Moderation settings

Room Types

OpenMeetings offers different room types:

Conference: All participants can speak and share
Webinar: Presenter-focused with audience controls
Interview: Two-way video with interviewer/interviewee roles

User Management

Create and manage users:

Navigate to Administration > Users
Add users manually or import from LDAP
Assign users to groups
Set permissions and roles

Meeting Features

Starting a Meeting

Log in to OpenMeetings
Select a room from the dashboard
Click “Enter” to join the room
Grant browser permissions for camera and microphone

During Meetings

Features available during meetings:

Toggle camera and microphone
Share screen or application window
Use the whiteboard for drawing
Upload and present documents
Send chat messages
Record the meeting

Recording Meetings

Enable meeting recording:

As moderator, click the record button
Recording captures audio, video, and screen content
Stop recording when finished
Access recordings from the administration panel

Integration Options

LDAP Authentication

Configure LDAP for user authentication:

Navigate to Administration > LDAP Config
Add LDAP server configuration:
- Server hostname and port
- Base DN for user search
- Bind credentials
- Attribute mappings

OAuth/SSO

Enable single sign-on:

Configure OAuth provider settings
Set up redirect URIs
Map user attributes

Calendar Integration

Use the built-in calendar:

Schedule meetings in advance
Send invitations to participants
Integrate with external calendars via API

Performance Optimization

Resource Requirements

Video conferencing requires significant resources:

Concurrent Participants	Recommended CPU	Recommended RAM
1-10	2 cores	4 GB
10-25	4 cores	8 GB
25-50	8 cores	16 GB
50+	16+ cores	32+ GB

Video Quality Settings

Configure video quality for your bandwidth:

Adjust default video resolution
Set bandwidth limits per participant
Configure adaptive bitrate

Kurento Optimization

Optimize media server performance:

Allocate dedicated resources for Kurento
Configure ICE servers for NAT traversal
Use TURN server for restrictive networks

Security Configuration

HTTPS Requirements

HTTPS is required for WebRTC:

Klutch.sh provides automatic certificates
Configure your custom domain
Ensure all URLs use HTTPS

Room Security

Secure your meeting rooms:

Set room passwords
Enable waiting room
Restrict screen sharing to moderators
Control participant permissions

User Authentication

Strengthen user security:

Enforce strong passwords
Enable two-factor authentication
Use OAuth/LDAP for centralized management

Troubleshooting Common Issues

Cannot Join Meetings

Symptoms: Users cannot enter meeting rooms.

Solutions:

Verify WebRTC is working (camera/mic permissions)
Check Kurento Media Server is running
Ensure HTTPS is properly configured
Test in a different browser

Poor Video Quality

Symptoms: Choppy video or audio.

Solutions:

Check network bandwidth
Reduce video resolution settings
Ensure Kurento has adequate resources
Configure TURN server for NAT traversal

Recordings Not Working

Symptoms: Recordings fail or are corrupted.

Solutions:

Check storage volume has space
Verify FFmpeg is properly installed
Check Kurento recording configuration
Review application logs

LDAP Authentication Failing

Symptoms: Users cannot log in with LDAP credentials.

Solutions:

Verify LDAP server connectivity
Check bind credentials
Verify attribute mappings
Test LDAP connection independently

Additional Resources

Conclusion

Deploying OpenMeetings on Klutch.sh provides a comprehensive, self-hosted video conferencing solution. With features including video meetings, screen sharing, recording, and collaboration tools, OpenMeetings delivers enterprise-grade conferencing under your control.

The combination of persistent storage for recordings, reliable uptime, and HTTPS security makes Klutch.sh well-suited for hosting OpenMeetings. Whether conducting team meetings, webinars, or online training, your self-hosted conferencing platform provides the privacy and control that commercial services cannot match.

Start with basic meetings, then expand with recording, calendar integration, and user management as your needs grow. With OpenMeetings on Klutch.sh, you own your communication infrastructure.