Deploying plugNmeet

Introduction

plugNmeet is a modern, open-source web conferencing platform that provides secure video meetings, webinars, and virtual classroom capabilities. Built on WebRTC technology and powered by LiveKit, plugNmeet delivers low-latency, high-quality audio and video communication without requiring any plugins or downloads.

The platform combines powerful real-time communication features with collaborative tools like screen sharing, whiteboard, shared notes, and breakout rooms. With its self-hosted architecture, organizations maintain complete control over their communication infrastructure and data privacy.

Key highlights of plugNmeet:

WebRTC-Based: Browser-native video conferencing with no plugins required
HD Video & Audio: High-quality media with adaptive bitrate streaming
Screen Sharing: Share entire screen or specific applications
Interactive Whiteboard: Real-time collaborative drawing and annotation
Shared Notes: Collaborative document editing during meetings
Breakout Rooms: Split participants into smaller groups for discussions
Recording: Record meetings for later playback and sharing
Waiting Room: Control participant entry with a moderated lobby
Chat & Messaging: Text chat with file sharing capabilities
Polls & Voting: Engage participants with interactive polls
Raise Hand: Orderly Q&A with hand raising feature
Multi-Language: Interface available in multiple languages
API & Webhooks: Integrate with external systems and LMS platforms

This guide walks through deploying plugNmeet on Klutch.sh using Docker, configuring the video conferencing infrastructure, and preparing for production meetings.

Why Deploy plugNmeet on Klutch.sh

Deploying plugNmeet on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds plugNmeet. Push to GitHub, and your conferencing platform deploys automatically.

Persistent Storage: Attach persistent volumes for recordings, configurations, and user data. Your meeting history survives container restarts.

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

GitHub Integration: Connect your configuration repository directly from GitHub for version-controlled deployments.

Scalable Resources: Allocate CPU and memory based on expected concurrent meetings and participants.

Environment Variable Management: Securely store API keys and secrets through Klutch.sh’s environment variable system.

Custom Domains: Assign a custom domain for professional, branded meeting URLs.

Always-On Availability: Your video conferencing platform remains accessible 24/7 for scheduled and ad-hoc meetings.

Prerequisites

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

A Klutch.sh account
A GitHub account with a repository for your plugNmeet configuration
Basic familiarity with Docker and containerization concepts
A Redis instance for session management
A MySQL or MariaDB database (optional, for persistent data)
(Optional) A LiveKit server for scalable media handling
(Optional) A custom domain with SSL certificate

Understanding plugNmeet Architecture

plugNmeet uses a microservices architecture:

plugNmeet Server: The main application server handling API requests, room management, and user authentication. Built with Go for performance.

plugNmeet Client: React-based web application providing the meeting interface. Runs entirely in the browser.

LiveKit Server: Selective Forwarding Unit (SFU) handling WebRTC media streams. Can be self-hosted or use LiveKit Cloud.

Redis: Stores session data, room state, and real-time information for quick access.

Database (Optional): MySQL/MariaDB for persistent storage of room configurations, recordings metadata, and analytics.

Recording Service: Handles meeting recording using browser-based capture for high-fidelity recordings.

Preparing Your Repository

To deploy plugNmeet on Klutch.sh, create a GitHub repository with your Dockerfile and configuration.

Repository Structure

plugnmeet-deploy/
├── Dockerfile
├── README.md
├── .dockerignore
└── config/
    └── config.yaml

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM mynaparrot/plugnmeet-server:latest

# Copy custom configuration
COPY config/config.yaml /config/config.yaml

# Set environment variables
ENV PNM_CONFIG_FILE=/config/config.yaml
ENV PNM_SERVER_PORT=8080
ENV PNM_REDIS_HOST=${PNM_REDIS_HOST}
ENV PNM_REDIS_PORT=${PNM_REDIS_PORT:-6379}
ENV PNM_LIVEKIT_HOST=${PNM_LIVEKIT_HOST}
ENV PNM_LIVEKIT_API_KEY=${PNM_LIVEKIT_API_KEY}
ENV PNM_LIVEKIT_SECRET=${PNM_LIVEKIT_SECRET}
ENV PNM_API_KEY=${PNM_API_KEY}
ENV PNM_API_SECRET=${PNM_API_SECRET}

# Create directories
RUN mkdir -p /recordings /uploads

# Expose port
EXPOSE 8080

# Health check
HEALTHCHECK --interval=30s --timeout=10s --start-period=30s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/healthcheck || exit 1

CMD ["plugnmeet-server"]

Creating the Configuration File

Create config/config.yaml:

server:
  port: 8080
  debug: false

client:
  path: "/client"
  title: "plugNmeet"

livekit:
  host: "${PNM_LIVEKIT_HOST}"
  api_key: "${PNM_LIVEKIT_API_KEY}"
  secret: "${PNM_LIVEKIT_SECRET}"

redis:
  host: "${PNM_REDIS_HOST}"
  port: 6379
  password: "${PNM_REDIS_PASSWORD}"
  db: 0

api_keys:
  - key: "${PNM_API_KEY}"
    secret: "${PNM_API_SECRET}"

room_default_settings:
  max_participants: 100
  lock_settings_on_start: false
  allow_webcams: true
  allow_screen_share: true
  allow_rtmp: false
  allow_view_other_webcams: true
  allow_view_other_users_list: true
  mute_on_start: false
  allow_recording: true
  allow_chat: true
  allow_polls: true
  allow_virtual_bg: true
  allow_raise_hand: true

recording:
  enabled: true
  path: "/recordings"
  max_duration: 86400

uploads:
  path: "/uploads"
  max_size: 50
  allowed_types: ["pdf", "pptx", "docx", "xlsx", "jpg", "png"]

Creating the .dockerignore File

.git
.github
*.md
LICENSE
.gitignore
*.log
.DS_Store
.env

Environment Variables Reference

Variable	Required	Default	Description
`PNM_LIVEKIT_HOST`	Yes	-	LiveKit server URL
`PNM_LIVEKIT_API_KEY`	Yes	-	LiveKit API key
`PNM_LIVEKIT_SECRET`	Yes	-	LiveKit secret key
`PNM_REDIS_HOST`	Yes	-	Redis server hostname
`PNM_REDIS_PORT`	No	6379	Redis port
`PNM_REDIS_PASSWORD`	No	-	Redis password
`PNM_API_KEY`	Yes	-	plugNmeet API key
`PNM_API_SECRET`	Yes	-	plugNmeet API secret

Deploying plugNmeet on Klutch.sh

Set Up Supporting Services

Before deploying plugNmeet, ensure you have:

A Redis instance (can be deployed on Klutch.sh or use a managed service)
A LiveKit server (self-hosted or LiveKit Cloud)

Generate API Keys

Generate secure API keys:

# plugNmeet API key/secret
openssl rand -base64 32

# LiveKit API key/secret (if self-hosting)
openssl rand -base64 32

Push Your Repository to GitHub

Initialize your repository and push to GitHub:

git init
git add Dockerfile .dockerignore config/ README.md
git commit -m "Initial plugNmeet deployment configuration"
git remote add origin https://github.com/yourusername/plugnmeet-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. Give it a descriptive name like “plugnmeet” or “video-meetings”.

Create a New App

Within your project, create a new app. Connect your GitHub account if you haven’t already, then select the repository containing your plugNmeet Dockerfile.

Configure HTTP Traffic

In the deployment settings:

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

Set Environment Variables

In the environment variables section, add:

Variable	Value
`PNM_LIVEKIT_HOST`	`wss://your-livekit-server.com`
`PNM_LIVEKIT_API_KEY`	Your LiveKit API key
`PNM_LIVEKIT_SECRET`	Your LiveKit secret
`PNM_REDIS_HOST`	Your Redis hostname
`PNM_REDIS_PASSWORD`	Your Redis password (if set)
`PNM_API_KEY`	Your generated API key
`PNM_API_SECRET`	Your generated API secret

Attach Persistent Volumes

Add the following volumes:

Mount Path	Recommended Size	Purpose
`/recordings`	50+ GB	Meeting recordings
`/uploads`	10 GB	Uploaded files and presentations
`/config`	100 MB	Configuration files

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will build and deploy your plugNmeet instance.

Access plugNmeet

Once deployment completes, access your video conferencing platform at https://your-app-name.klutch.sh.

Creating and Managing Meetings

Creating a Room via API

curl -X POST https://your-plugnmeet.klutch.sh/api/room/create \
  -H "Content-Type: application/json" \
  -H "API-KEY: your-api-key" \
  -H "API-SECRET: your-api-secret" \
  -d '{
    "name": "Team Meeting",
    "room_id": "room-123",
    "max_participants": 50
  }'

Generating Join Tokens

curl -X POST https://your-plugnmeet.klutch.sh/api/room/getJoinToken \
  -H "Content-Type: application/json" \
  -H "API-KEY: your-api-key" \
  -H "API-SECRET: your-api-secret" \
  -d '{
    "room_id": "room-123",
    "user_info": {
      "name": "John Doe",
      "user_id": "user-456",
      "is_admin": true
    }
  }'

Room Settings

Configure room features during creation:

allow_webcams: Enable/disable video
allow_screen_share: Enable screen sharing
allow_chat: Enable text chat
allow_polls: Enable polling feature
allow_recording: Enable recording capability
mute_on_start: Mute participants on entry

Troubleshooting Common Issues

Video/Audio Not Working

Verify HTTPS is properly configured (required for WebRTC)
Check browser permissions for camera/microphone
Ensure LiveKit server is accessible
Review browser console for WebRTC errors

Connection Issues

Verify Redis connectivity
Check LiveKit server status
Ensure all required ports are accessible

Recording Problems

Verify recording service is configured
Check disk space availability
Ensure proper permissions on recording directory

Additional Resources

Conclusion

Deploying plugNmeet on Klutch.sh provides a powerful, self-hosted video conferencing solution with full control over your communication infrastructure. The combination of plugNmeet’s comprehensive features and Klutch.sh’s deployment simplicity enables professional video meetings without relying on third-party services.

Whether you’re hosting team meetings, webinars, or virtual classrooms, plugNmeet on Klutch.sh delivers the tools needed for effective online collaboration while maintaining data privacy and security.