Deploying Screego

Introduction

Screego is a lightweight, self-hosted screen sharing application that enables secure, real-time screen sharing through WebRTC technology. Unlike commercial solutions that route your data through third-party servers, Screego establishes direct peer-to-peer connections between participants, ensuring your screen content remains private and under your control.

Built with Go on the backend and a modern web frontend, Screego provides a minimalist yet effective solution for sharing your screen with colleagues, conducting remote presentations, or providing technical support. The application requires no client installation - participants simply need a modern web browser to view shared screens.

Key highlights of Screego:

WebRTC-Based: Utilizes peer-to-peer connections for low-latency, high-quality screen sharing
No Client Installation: Viewers only need a web browser to participate
TURN Server Included: Built-in TURN server for NAT traversal when direct connections aren’t possible
User Authentication: Supports multiple authentication methods including local users and reverse proxy authentication
Room-Based Sharing: Create rooms for organizing different sharing sessions
Multi-User Viewing: Multiple participants can view the same screen simultaneously
Lightweight: Minimal resource requirements with a single binary deployment
100% Open Source: Licensed under GPL-3.0 with no proprietary components

This guide walks through deploying Screego on Klutch.sh using Docker, configuring TURN server settings, and setting up secure screen sharing for your team.

Why Deploy Screego on Klutch.sh

Deploying Screego on Klutch.sh provides several advantages for self-hosted screen sharing:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Screego without complex networking configuration. Push to GitHub, and your screen sharing service deploys automatically.

HTTPS by Default: Klutch.sh provides automatic SSL certificates, which is required for WebRTC to function in modern browsers. No manual certificate management needed.

Environment Variable Management: Securely store sensitive configuration like TURN server credentials through Klutch.sh’s environment variable system without exposing secrets in your repository.

GitHub Integration: Connect your configuration repository directly from GitHub. Updates to your Dockerfile trigger automatic redeployments.

Custom Domains: Assign a custom domain for a professional, branded screen sharing experience.

Always-On Availability: Your screen sharing service remains accessible 24/7 without managing your own hardware.

Prerequisites

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

A Klutch.sh account
A GitHub account with a repository for your Screego configuration
Basic familiarity with Docker and containerization concepts
(Optional) A custom domain for your Screego instance

Preparing Your Repository

Create a GitHub repository with your Screego configuration.

Repository Structure

screego-deploy/
├── Dockerfile
└── .dockerignore

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM ghcr.io/screego/server:1

# Environment variables for Screego configuration
ENV SCREEGO_EXTERNAL_URL=${SCREEGO_EXTERNAL_URL}
ENV SCREEGO_SECRET=${SCREEGO_SECRET}
ENV SCREEGO_TURN_PORT_RANGE=${SCREEGO_TURN_PORT_RANGE:-50000:50100}

# Optional authentication settings
ENV SCREEGO_AUTH_MODE=${SCREEGO_AUTH_MODE:-turn}
ENV SCREEGO_USERS_FILE=${SCREEGO_USERS_FILE:-}

# TURN server settings
ENV SCREEGO_TURN_STRICT_AUTH=${SCREEGO_TURN_STRICT_AUTH:-true}

# Expose the web interface port
EXPOSE 5050

# Expose TURN server UDP ports
EXPOSE 50000-50100/udp

Environment Variables Reference

Variable	Required	Default	Description
`SCREEGO_EXTERNAL_URL`	Yes	-	The external URL of your Screego instance (e.g., `https://screego.example.com`)
`SCREEGO_SECRET`	Yes	-	Secret key for session encryption. Generate with `openssl rand -hex 32`
`SCREEGO_AUTH_MODE`	No	turn	Authentication mode: `turn`, `all`, or `none`
`SCREEGO_USERS_FILE`	No	-	Path to users file for local authentication
`SCREEGO_TURN_PORT_RANGE`	No	50000:50100	UDP port range for TURN server
`SCREEGO_TURN_STRICT_AUTH`	No	true	Require authentication for TURN server
`SCREEGO_LOG_LEVEL`	No	info	Logging verbosity: debug, info, warn, error

Deploying Screego on Klutch.sh

Generate Your Secret Key

Before deployment, generate a secure secret key:

openssl rand -hex 32

Save this key securely for the environment variables configuration.

Push Your Repository to GitHub

Initialize and push your repository:

git init
git add Dockerfile .dockerignore
git commit -m "Initial Screego deployment configuration"
git remote add origin https://github.com/yourusername/screego-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 with a descriptive name like “screego” or “screen-sharing”.

Create a New App

Within your project, create a new app. Connect your GitHub account and select your Screego repository.

Configure HTTP Traffic

In the deployment settings:

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

Set Environment Variables

Add the following environment variables:

Variable	Value
`SCREEGO_EXTERNAL_URL`	`https://your-app-name.klutch.sh`
`SCREEGO_SECRET`	Your generated secret key
`SCREEGO_AUTH_MODE`	`turn` (or your preferred mode)

Deploy Your Application

Click Deploy to start the build process. Klutch.sh will build the container and provision an HTTPS certificate.

Access Screego

Once deployment completes, access your Screego instance at https://your-app-name.klutch.sh.

Using Screego

Creating a Room

Navigate to your Screego instance
Enter a room name or leave blank for a random name
Click Create Room
Share the room URL with participants

In the room, click Share Screen
Select the screen, window, or browser tab to share
Confirm the selection
Your screen is now visible to all room participants

Viewing a Shared Screen

Open the shared room URL
The shared screen appears automatically
No installation or registration required

Authentication Options

TURN-Only Authentication (Default)

With SCREEGO_AUTH_MODE=turn, users can create rooms without authentication, but the TURN server requires valid credentials for NAT traversal.

Full Authentication

Set SCREEGO_AUTH_MODE=all to require authentication for all actions. Create a users file:

admin:$2a$12$hashedpassword
user1:$2a$12$anotherhashedpassword

Generate password hashes using bcrypt tools or the Screego CLI.

No Authentication

Set SCREEGO_AUTH_MODE=none for open access (not recommended for public deployments).

Troubleshooting

Connection Issues

Symptoms: Participants cannot see the shared screen.

Solutions:

Verify SCREEGO_EXTERNAL_URL matches your actual deployment URL
Ensure HTTPS is properly configured (required for WebRTC)
Check that the TURN server is accessible

Audio/Video Quality Issues

Symptoms: Poor quality or laggy screen sharing.