Deploying BigBlueButton

BigBlueButton is a powerful, open-source web conferencing platform designed specifically for online learning and virtual collaboration. Built with educators and organizations in mind, BigBlueButton provides a complete solution for hosting interactive virtual classrooms, training sessions, webinars, and meetings. With a focus on usability, accessibility, and privacy, BigBlueButton enables seamless real-time communication with video, audio, screen sharing, whiteboarding, and collaborative tools—all while keeping your data secure on your own infrastructure.

Why BigBlueButton?

BigBlueButton stands out in the web conferencing landscape with its education-first approach and comprehensive features:

• Video and Audio: High-quality video conferencing with multiple layout options and dynamic participant switching
• Screen Sharing: Share your screen or applications with full control and annotation capabilities
• Whiteboarding: Built-in whiteboard with drawing tools for collaborative problem-solving
• Chat and Messaging: Real-time text chat with public and private messaging options
• Polls and Surveys: Engage participants with interactive polls and instant feedback collection
• Breakout Rooms: Divide participants into smaller groups for collaborative work
• Virtual Backgrounds: Support for custom backgrounds to enhance professionalism
• Recording and Playback: Automatically record sessions for asynchronous learning
• Accessibility Features: Full support for captions, screen reader compatibility, and keyboard navigation
• API Integration: Comprehensive REST API for integrating with learning management systems
• Privacy First: No analytics tracking, data stays on your server
• Multi-User Support: Hundreds of concurrent users with role-based permissions
• Open Source: AGPL licensed with active community and commercial support available

BigBlueButton is ideal for educational institutions, training organizations, enterprises, and anyone who needs reliable, private web conferencing without vendor lock-in. With persistent storage on Klutch.sh, your meeting recordings and configuration are always safe and accessible.

Prerequisites

Before deploying BigBlueButton, ensure you have:

• A Klutch.sh account
• A GitHub repository with your BigBlueButton deployment configuration
• Basic familiarity with Docker, Git, and web conferencing
• A domain name (recommended for SSL certificates and professional appearance)
• At least 4GB RAM recommended for smooth operation
• Sufficient bandwidth for video streaming

Important Considerations

Resource Requirements

BigBlueButton is resource-intensive compared to typical web applications. Ensure your Klutch.sh instance has:

• Minimum 2 CPU cores (4+ cores recommended)
• Minimum 4GB RAM (8GB+ for 50+ concurrent users)
• Persistent storage for recordings (100GB+ recommended)
• Stable, high-bandwidth network connection

Deploying BigBlueButton

1. Create a New Project

   Log in to your Klutch.sh dashboard and create a new project for your BigBlueButton deployment.

2. Prepare Your Repository

   Create a GitHub repository with the following structure for your BigBlueButton deployment:

   bigbluebutton-deploy/
   ├─ Dockerfile
   ├─ .env.example
   ├─ bbb-config.yml
   ├─ .gitignore
   └─ README.md

   Here’s a Dockerfile for BigBlueButton (note: this uses a pre-built BigBlueButton image for simplicity):

   FROM bigbluebutton/bigbluebutton:latest
   
   # Install additional dependencies
   RUN apt-get update && apt-get install -y \
       curl \
       wget \
       ssl-cert \
       && rm -rf /var/lib/apt/lists/*
   
   # Create necessary directories
   RUN mkdir -p /bbb-data /bbb-recordings /bbb/logs
   
   # Expose ports for BigBlueButton
   # 80: HTTP
   # 443: HTTPS
   # 1935: RTMP
   # 3478-3479: STUN servers
   EXPOSE 80 443 1935 3478 3479
   
   # Health check
   HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
     CMD curl -f http://localhost/bigbluebutton/api/getMeetings || exit 1
   
   # Start BigBlueButton services
   CMD ["/etc/bigbluebutton/bbb-entrypoint.sh"]

   Create a .env.example file for environment configuration:

   # BigBlueButton Configuration
   BBB_HOSTNAME=bbb.yourdomain.com
   BBB_PROTOCOL=https
   BBB_PORT=443
   
   # Security and API
   BBB_SECRET_SHARED_SECRET=your-secure-secret-key
   BBB_MODERATOR_PASSWORD=secure-password-here
   BBB_VIEWER_PASSWORD=secure-password-here
   
   # Recording Configuration
   BBB_RECORDING_ENABLED=true
   BBB_RECORDING_FORMAT=mp4
   BBB_RECORDING_KEEP_DAYS=90
   
   # Performance Tuning
   BBB_MAX_PARTICIPANTS=100
   BBB_MEETING_DURATION_MINUTES=240
   
   # Features
   BBB_ENABLE_VIRTUAL_BACKGROUNDS=true
   BBB_ENABLE_CAPTIONS=true
   BBB_ENABLE_POLLING=true
   BBB_ENABLE_BREAKOUT_ROOMS=true
   BBB_ENABLE_SCREEN_SHARING=true

   Commit and push to your GitHub repository:

   git init
   git add .
   git commit -m "Initial BigBlueButton deployment"
   git remote add origin https://github.com/yourusername/bigbluebutton-deploy.git
   git push -u origin main

3. Create a New App

   In the Klutch.sh dashboard:

   • Click “Create New App”
   • Select your GitHub repository containing the Dockerfile
   • Choose the branch (typically main or master)
   • Klutch.sh will automatically detect the Dockerfile in the root directory

4. Configure Environment Variables

   Set up these essential environment variables in your Klutch.sh dashboard:

   Variable	Description	Example
   BBB_HOSTNAME	Your domain name for BigBlueButton	bbb.example.com
   BBB_PROTOCOL	Protocol (http or https)	https
   BBB_PORT	Port number (usually 443 for HTTPS)	443
   BBB_SECRET_SHARED_SECRET	Shared secret for API authentication (generate a secure random string)	your-secure-secret-key
   BBB_MODERATOR_PASSWORD	Default moderator password	secure-password-here
   BBB_VIEWER_PASSWORD	Default viewer password	secure-password-here
   BBB_RECORDING_ENABLED	Enable recording functionality	true
   BBB_MAX_PARTICIPANTS	Maximum concurrent participants	100
   BBB_ENABLE_VIRTUAL_BACKGROUNDS	Enable virtual background support	true
   BBB_ENABLE_CAPTIONS	Enable live captions	true

   Generating Secure Secrets

   Generate a secure shared secret: openssl rand -hex 32 or node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"

5. Configure Persistent Storage

   BigBlueButton requires persistent storage for recordings and configuration data. Add persistent volumes:

   Mount Path	Description	Recommended Size
   /var/bigbluebutton	BigBlueButton data directory	50GB
   /var/bigbluebutton/published	Published recordings and media	500GB+
   /var/bigbluebutton/unpublished	Unpublished recordings (work in progress)	100GB
   /var/log/bigbluebutton	Application logs	20GB

   In the Klutch.sh dashboard:

   • Navigate to your app settings
   • Go to the “Volumes” section
   • Click “Add Volume” for each mount path
   • Set mount paths and sizes as specified above

6. Set Network Configuration

   Configure your app’s network settings:

   • Select traffic type: HTTP (BigBlueButton uses standard web ports)
   • Klutch.sh will automatically handle HTTPS termination via reverse proxy
   • Ensure ports 80 and 443 are accessible from your domain

   Port Configuration

   BigBlueButton requires multiple ports. Klutch.sh’s reverse proxy handles HTTP/HTTPS traffic automatically. For RTMP (1935), STUN (3478-3479), and other services, ensure your deployment is properly configured.

7. Configure Custom Domain

   BigBlueButton requires a domain for proper operation:

   • Navigate to your app’s “Domains” section in Klutch.sh
   • Click “Add Custom Domain”
   • Enter your domain (e.g., bbb.yourdomain.com)
   • Configure DNS with a CNAME record to point to your Klutch.sh app
   • Update BBB_HOSTNAME environment variable to match your domain

8. Deploy Your App

   • Review all settings
   • Click “Deploy”
   • Klutch.sh will build the Docker image and start your BigBlueButton instance
   • Wait for the deployment to complete (typically 5-10 minutes for the initial build)
   • BigBlueButton services will initialize on first startup (may take several minutes)

Initial Setup and Configuration

After deployment completes, access your BigBlueButton instance:

Accessing BigBlueButton

Navigate to your app’s domain: https://bbb.yourdomain.com

You’ll see the BigBlueButton administration interface where you can configure settings and test the system.

Creating Your First Meeting

1. Log in to BigBlueButton (use default credentials or configured credentials)
2. Click “Create Meeting” or “Start New Meeting”
3. Enter meeting details:
   • Meeting name (e.g., “Weekly Team Standup”)
   • Meeting description (optional)
   • Duration (in minutes, or leave blank for unlimited)
   • Setting password (optional)
4. Configure meeting options:
   • Allow webcam sharing
   • Allow microphone use
   • Enable whiteboard
   • Allow screen sharing
5. Start the meeting

Joining a Meeting

Participants can join through:

• Direct meeting link
• Meeting name and password
• Integration with LMS (Moodle, Canvas, Blackboard)
• API-generated join links

Recording Meetings

Enable recording for any meeting:

1. Before starting: Check “Record this meeting” option
2. During meeting: Recording indicator shows active recording
3. After meeting: Recordings process automatically
4. Access recordings in meeting history or recordings section

Environment Variable Examples

Basic Configuration

BBB_HOSTNAME=bbb.yourdomain.com
BBB_PROTOCOL=https
BBB_PORT=443
BBB_SECRET_SHARED_SECRET=your-secure-random-string
BBB_MODERATOR_PASSWORD=moderator-password
BBB_VIEWER_PASSWORD=viewer-password
BBB_RECORDING_ENABLED=true

Advanced Configuration

For fine-tuned control:

BBB_HOSTNAME=bbb.yourdomain.com
BBB_PROTOCOL=https
BBB_PORT=443
BBB_SECRET_SHARED_SECRET=your-secure-secret
BBB_MAX_PARTICIPANTS=200
BBB_MEETING_DURATION_MINUTES=480
BBB_RECORDING_ENABLED=true
BBB_RECORDING_FORMAT=mp4
BBB_RECORDING_KEEP_DAYS=90
BBB_ENABLE_VIRTUAL_BACKGROUNDS=true
BBB_ENABLE_CAPTIONS=true
BBB_ENABLE_POLLING=true
BBB_ENABLE_BREAKOUT_ROOMS=true
BBB_ENABLE_SCREEN_SHARING=true
BBB_ENABLE_CHAT=true
BBB_CHAT_HISTORY_ENABLED=true
BBB_PRESENTATION_TIMEOUT_MINUTES=30
BBB_ALLOW_REQUEST_AUDIO_COOKIE=true

Sample Code and Getting Started

BigBlueButton API Integration

# Get list of active meetings
curl https://bbb.yourdomain.com/bigbluebutton/api/getMeetings \
  -d checksum=YOUR_CHECKSUM

# Create a new meeting
curl -X POST https://bbb.yourdomain.com/bigbluebutton/api/create \
  -d "name=My+Meeting&meetingID=meeting-123" \
  -d "checksum=YOUR_CHECKSUM"

# Join a meeting
curl https://bbb.yourdomain.com/bigbluebutton/api/join \
  -d "meetingID=meeting-123&fullName=User+Name&role=MODERATOR" \
  -d "checksum=YOUR_CHECKSUM"

# End a meeting
curl https://bbb.yourdomain.com/bigbluebutton/api/end \
  -d "meetingID=meeting-123" \
  -d "checksum=YOUR_CHECKSUM"

JavaScript Example - Creating Meeting with API

const crypto = require('crypto');

const BBB_URL = "https://bbb.yourdomain.com/bigbluebutton/api";
const SHARED_SECRET = "your-shared-secret";

function getChecksum(params, secret) {
  const str = params + secret;
  return crypto.createHash('sha1').update(str).digest('hex');
}

function createMeeting(meetingName, meetingID) {
  const params = `name=${encodeURIComponent(meetingName)}&meetingID=${meetingID}`;
  const checksum = getChecksum(`create${params}`, SHARED_SECRET);

  const url = `${BBB_URL}/create?${params}&checksum=${checksum}`;

  fetch(url)
    .then(response => response.text())
    .then(data => {
      console.log("Meeting created:", data);
      // Parse XML response and extract meetingToken
    })
    .catch(error => console.error('Error creating meeting:', error));
}

function joinMeeting(meetingID, fullName, role = "MODERATOR") {
  const params = `meetingID=${meetingID}&fullName=${encodeURIComponent(fullName)}&role=${role}`;
  const checksum = getChecksum(`join${params}`, SHARED_SECRET);

  const url = `${BBB_URL}/join?${params}&checksum=${checksum}`;
  window.location.href = url;
}

// Usage
createMeeting("Team Meeting", "meeting-123");
// joinMeeting("meeting-123", "John Doe", "MODERATOR");

Python Example - Meeting Management

import hashlib
import requests
from urllib.parse import quote

BBB_URL = "https://bbb.yourdomain.com/bigbluebutton/api"
SHARED_SECRET = "your-shared-secret"

def get_checksum(params, secret):
    """Generate checksum for BigBlueButton API calls"""
    data = params + secret
    return hashlib.sha1(data.encode()).hexdigest()

def create_meeting(meeting_name, meeting_id, max_participants=100):
    """Create a new BigBlueButton meeting"""
    params = f"name={quote(meeting_name)}&meetingID={meeting_id}&maxParticipants={max_participants}"
    checksum = get_checksum(f"create{params}", SHARED_SECRET)

    url = f"{BBB_URL}/create?{params}&checksum={checksum}"

    try:
        response = requests.get(url)
        if response.status_code == 200:
            print(f"Meeting '{meeting_name}' created successfully")
            return response.text
        else:
            print(f"Error creating meeting: {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"Request error: {e}")

def get_meetings():
    """Get list of active meetings"""
    params = ""
    checksum = get_checksum(f"getMeetings{params}", SHARED_SECRET)

    url = f"{BBB_URL}/getMeetings?checksum={checksum}"

    try:
        response = requests.get(url)
        if response.status_code == 200:
            print("Active meetings:", response.text)
            return response.text
        else:
            print(f"Error retrieving meetings: {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"Request error: {e}")

def get_recordings():
    """Get list of recordings"""
    params = ""
    checksum = get_checksum(f"getRecordings{params}", SHARED_SECRET)

    url = f"{BBB_URL}/getRecordings?checksum={checksum}"

    try:
        response = requests.get(url)
        if response.status_code == 200:
            print("Recordings:", response.text)
            return response.text
        else:
            print(f"Error retrieving recordings: {response.status_code}")
    except requests.exceptions.RequestException as e:
        print(f"Request error: {e}")

# Usage
create_meeting("Team Standup", "standup-123")
get_meetings()
get_recordings()

Docker Compose for Local Development

For local testing before deploying to Klutch.sh:

version: '3.8'

services:
  bigbluebutton:
    image: bigbluebutton/bigbluebutton:latest
    container_name: bigbluebutton
    environment:
      - BBB_HOSTNAME=localhost
      - BBB_PROTOCOL=http
      - BBB_PORT=8080
      - BBB_SECRET_SHARED_SECRET=dev-secret-key
      - BBB_RECORDING_ENABLED=true
    ports:
      - "80:80"
      - "443:443"
      - "1935:1935"
      - "3478:3478"
      - "3479:3479"
    volumes:
      - ./bbb-data:/var/bigbluebutton
      - ./recordings:/var/bigbluebutton/published
      - ./logs:/var/log/bigbluebutton
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost/bigbluebutton/api/getMeetings"]
      interval: 30s
      timeout: 10s
      retries: 3
      start_period: 60s

Save as docker-compose.yml and run:

docker-compose up -d

Access BigBlueButton at http://localhost

Local Development Note

Local development with BigBlueButton can be resource-intensive. Ensure your development machine has adequate CPU and RAM. Some features may not work properly in local development (e.g., video/audio may require network configuration).

LMS Integration

Moodle Integration

BigBlueButton integrates natively with Moodle:

1. Install BigBlueButton plugin in Moodle
2. Configure plugin with your BigBlueButton server details
3. Add “BigBlueButton Room” activity to courses
4. Students access meetings directly from Moodle

Canvas Integration

For Canvas LMS:

1. Use BigBlueButton’s Canvas integration tools
2. Configure API credentials in Canvas
3. Add BigBlueButton to course collaborations
4. Launch meetings from Canvas interface

Custom LMS Integration

Use the BigBlueButton API to integrate with custom systems:

# Generate join URL for custom integration
curl https://bbb.yourdomain.com/bigbluebutton/api/join \
  -d "meetingID=course-123-lesson-1" \
  -d "fullName=Student+Name" \
  -d "password=meeting-password" \
  -d "checksum=YOUR_CHECKSUM"

Recording Management

Accessing Recordings

1. Navigate to “Recordings” section in BigBlueButton admin
2. View all recordings with metadata and statistics
3. Publish or unpublish recordings
4. Delete recordings as needed

Recording Storage

Configure recording storage paths:

BBB_RECORDING_ENABLED=true
BBB_RECORDING_FORMAT=mp4
BBB_RECORDING_QUALITY=medium
BBB_RECORDING_KEEP_DAYS=90
BBB_RECORDING_STORAGE_PATH=/var/bigbluebutton/published

Downloading and Sharing Recordings

# List available recordings
curl https://bbb.yourdomain.com/bigbluebutton/api/getRecordings

# Access recording playback link
# URL format: https://bbb.yourdomain.com/playback/presentation/2.3/[recordID]

Performance and Scaling

Vertical Scaling

For larger deployments:

1. Navigate to your app settings in Klutch.sh
2. Increase instance resources:
   • Increase CPU cores (4+ cores recommended for 50+ users)
   • Increase RAM (8GB+ for production)
3. Increase persistent volume sizes:
   • Scale recording storage based on usage
   • Plan for growth: ~500MB per hour of recorded meetings

Performance Tuning

Optimize for your deployment:

BBB_MAX_PARTICIPANTS=150
BBB_JBOSS_HEAP_SIZE=2048m
BBB_RECORDING_PROCESS_TIMEOUT=3600
BBB_AUDIO_QUALITY=high
BBB_VIDEO_BITRATE=1000

Monitoring Performance

Monitor key metrics:

• Active meeting count
• Participant count
• Recording queue length
• Disk usage on recording volume
• CPU and memory utilization

Custom Domain Configuration

BigBlueButton requires a proper domain for operation:

1. Navigate to your app’s “Domains” section in Klutch.sh
2. Click “Add Custom Domain”
3. Enter your domain (e.g., bbb.yourdomain.com)
4. Configure your DNS provider:

   bbb.yourdomain.com → example-app.klutch.sh (CNAME record)

5. Update BBB_HOSTNAME environment variable
6. Redeploy the application
7. Klutch.sh automatically provisions SSL certificates

Security Best Practices

Authentication and Access Control

• Use strong, unique moderator and viewer passwords
• Generate secure shared secret using cryptographically random methods
• Implement role-based access control (moderator vs participant)
• Enable password protection for sensitive meetings
• Rotate shared secrets regularly

Meeting Security

• Set meeting duration limits to prevent resource hogging
• Enable waiting room for authenticated meetings
• Require moderator approval for participant entry
• Log all meeting access and recordings
• Monitor for unauthorized access attempts

Network Security

• Always use HTTPS (Klutch.sh provides this automatically)
• Restrict API access to authorized applications only
• Implement rate limiting to prevent abuse
• Monitor network traffic for suspicious activity
• Keep BigBlueButton and dependencies updated

Data Privacy

• Recordings stay on your server
• No third-party data collection or analytics
• Full control over data retention policies
• Implement GDPR/CCPA compliance measures
• Regular backups of all meeting data and recordings

Troubleshooting

Common Issues and Solutions

Issue: BigBlueButton fails to start

Check the deployment logs in Klutch.sh dashboard. Common causes:

• Missing BBB_HOSTNAME environment variable
• Insufficient disk space on recording volume
• Port conflicts (ensure 80, 443 are available)
• Insufficient memory allocation

Issue: Unable to join meetings

Solutions:

• Verify domain is correctly configured (BBB_HOSTNAME)
• Check that domain resolves properly via DNS
• Ensure SSL certificate is valid
• Verify meeting URL format is correct
• Check network firewall rules

Issue: No audio/video in meetings

Causes and solutions:

• Check browser permissions for camera/microphone
• Verify network bandwidth is sufficient
• Check WebRTC configuration
• Enable TURN servers if behind restrictive firewall
• Test audio/video in meeting setup screen

Issue: Recordings not processing

Troubleshooting:

• Check disk space on recording volume
• Verify recording process is running
• Review recording process logs
• Increase BBB_RECORDING_PROCESS_TIMEOUT
• Check file permissions on recording directories

Issue: High CPU/Memory usage

Solutions:

• Reduce BBB_MAX_PARTICIPANTS
• Disable unused features (virtual backgrounds, etc.)
• Increase instance resources
• Optimize video quality settings
• Monitor and limit concurrent meetings

Upgrading BigBlueButton

To update BigBlueButton to a newer version:

1. Update your Dockerfile to use the latest BigBlueButton image:

   FROM bigbluebutton/bigbluebutton:2.6-latest

2. Commit and push to GitHub
3. Klutch.sh will automatically rebuild with the latest version
4. Test in a staging environment before production
5. Backup all recordings before major version upgrades

Additional Resources

• BigBlueButton Official Website - Project information and news
• BigBlueButton Documentation - Complete reference and guides
• BigBlueButton API Documentation - API reference
• BigBlueButton GitHub Repository - Source code
• BigBlueButton Support - Community and professional support
• Klutch.sh Getting Started Guide
• Klutch.sh Volumes Documentation
• Klutch.sh Custom Domains Guide

Conclusion

Deploying BigBlueButton on Klutch.sh provides you with a complete, self-hosted web conferencing platform that respects privacy while supporting interactive online learning and collaboration. With persistent storage for recordings, powerful meeting features, and full control over your infrastructure, BigBlueButton enables organizations to deliver effective virtual education and meetings. Klutch.sh’s managed infrastructure ensures your conferencing system is always available, secure, and performant.

Start hosting virtual meetings and classrooms today by deploying BigBlueButton on Klutch.sh and give your organization the conferencing solution it deserves.