Getting Started

Welcome to SnapEncode! This guide provides a comprehensive, step-by-step walkthrough for deploying your self-hosted video platform. We will cover all prerequisites, application setup, and media server configuration in detail.

System Requirements

Important: Ensure your server meets these minimum requirements before proceeding with installation.

CPU

4+ cores recommended
2 cores minimum

RAM

8GB recommended
4GB minimum

Storage

100GB+ SSD
Fast I/O essential

OS Support

Ubuntu 22.04 LTS
(Fully Supported)

Supported Operating Systems

Ubuntu 22.04 LTS (Recommended & Fully Supported)
Ubuntu 20.04 LTS (Compatible)
Debian 11/12 (Compatible)
CentOS 8+ (Community Support)

Network Requirements

Bandwidth: 100 Mbps+ for HD streaming
Ports: 80, 443, 1935 (RTMP), 8888 (Media API)
UDP Range: 20000-21000 (WebRTC)

Who is this for?

SnapEncode is a powerful, self-hosted application. Successful installation and management require a strong understanding of Linux server administration and the Laravel ecosystem. While control panels (like cPanel or Plesk) can be used, you must have the ability to manage background processes, configure web servers, and handle command-line operations. A clean VPS or dedicated server running Ubuntu 22.04 is the recommended and fully supported environment.

Purchase & Support

Before you begin, you will need a license to use the SnapEncode software.

Buy on Snapencode

Purchase a license and download the source code from the official marketplace.

Contact Us for Help

Need help with installation, customization, or have a pre-sale question? We’re here to help.

Installation Method

Choose your preferred installation method. Docker is recommended for a streamlined, isolated setup. The Manual method offers maximum control for experienced administrators.

undefined

Phase 1: Server Preparation (Manual)

1. Install Core Dependencies

Use the commands for Ubuntu 22.04 (Recommended).


# Update package lists
sudo apt update && sudo apt upgrade -y
 
# Install Core Services
sudo apt install -y nginx mariadb-server redis-server supervisor
 
# Install PHP 8.2 and extensions
sudo apt install -y software-properties-common
sudo add-apt-repository ppa:ondrej/php -y
sudo apt update
sudo apt install -y php8.2-fpm php8.2-mysql php8.2-mbstring php8.2-xml php8.2-bcmath php8.2-curl php8.2-gd php8.2-zip php8.2-fileinfo php8.2-redis
 
# Install Media & System Tools
sudo apt install -y ffmpeg composer git unzip nodejs npm wget
 
# Nodejs
curl -fsSL https://deb.nodesource.com/setup_20.x | sudo -E bash -
sudo apt install nodejs
 
# Install Shaka Packager
wget https://github.com/google/shaka-packager/releases/latest/download/packager-linux-x64
sudo chmod +x packager-linux-x64
sudo mv packager-linux-x64 /usr/local/bin/shaka-packager
 
 
    # Whisper: This creates a new 'build' folder and moves you into it.
    # bin is on snapencode project
    cd ./bin/whisper
    mkdir build && cd build
    cmake .. -DCMAKE_BUILD_TYPE=Release
    make
    cd .bin/models
    # You should download small model type
    ./download-ggml-model.sh small
cd .bin/models
# You should download small model type
./download-ggml-model.sh small

2. Increase Upload Limits (Prevent 413 Errors)

Create a new PHP configuration file to increase upload limits for large video files.


sudo bash -c 'cat > /etc/php/8.2/fpm/conf.d/99-uploads.ini' <<EOF
file_uploads = On
upload_max_filesize = 10G
post_max_size = 10G
max_execution_time = 0
memory_limit = 2G
EOF

Apply the new PHP settings by restarting the PHP-FPM service.


sudo systemctl restart php8.2-fpm

3. Configure Firewall

Your server’s firewall must allow traffic on the following ports. If using ufw:


sudo ufw allow 22/tcp   # SSH
sudo ufw allow 80/tcp   # HTTP
sudo ufw allow 443/tcp  # HTTPS
sudo ufw allow 1935/tcp # RTMP Streaming
sudo ufw allow 8888/tcp # Media API
sudo ufw allow 20000:21000/udp # WebRTC
sudo ufw enable

4. Secure Your Database

Run the secure installation script, then create a dedicated database and user.


sudo mysql_secure_installation

Create the database and user:


# Log into MySQL as root
sudo mysql -u root -p
 
# Run these SQL commands
CREATE DATABASE snapencode CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
CREATE USER 'snapencode_user'@'localhost' IDENTIFIED BY 'your_strong_password_here';
GRANT ALL PRIVILEGES ON snapencode.* TO 'snapencode_user'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Phase 2: Application Setup (Manual)

1. Upload & Install

Upload the source code to /var/www/snapencode. Then, install dependencies.


cd /var/www/snapencode

Customizing Frontend Assets (Optional): The following command is only necessary if you plan to modify the JavaScript or CSS files in the resources directory. If you are just installing the application as-is, you can skip this step.


npm install && npm run build

Make the binary files executable:


chmod +x ./bin/*

2. Configure Environment (`.env`)

Create and configure your .env file for production.


cp .env.example .env
php artisan key:generate

Open nano .env and edit the following settings:


APP_NAME=SnapEncode
APP_ENV=production
APP_DEBUG=false
APP_URL=https://your-domain.com
FRONTEND_URL=https://your-domain.com
 
DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=snapencode
DB_USERNAME=snapencode_user
DB_PASSWORD=your_strong_password_here
 
BROADCAST_DRIVER=log
CACHE_DRIVER=redis
FILESYSTEM_DISK=local
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis
SESSION_LIFETIME=120
 
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379
 
FFMPEG_BINARIES=/usr/bin/ffmpeg
FFPROBE_BINARIES=/usr/bin/ffprobe
SHAKA_PACKAGER_BINARIES=/usr/local/bin/packager

3. Run Database Migrations


php artisan migrate --seed --force
php artisan storage:link

4. Optimize for Production

Critical Step: Run these commands only after you have finished configuring your .env file. This caches your settings for a significant performance boost.


php artisan config:cache
php artisan route:cache
php artisan view:cache

5. Configure Nginx & Permissions

Set proper ownership and permissions:


sudo chown -R www-data:www-data /var/www/snapencode
sudo chmod -R 755 /var/www/snapencode
sudo chmod -R 775 /var/www/snapencode/storage /var/www/snapencode/bootstrap/cache

Create a new Nginx site configuration at /etc/nginx/sites-available/snapencode.conf:


server {
listen 80;
server_name your-domain.com;
root /var/www/snapencode/public;
index index.php index.html;
 
# Security headers
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header X-Content-Type-Options "nosniff" always;
 
# Increase upload limits for large video files
client_max_body_size 10G;
client_body_timeout 300s;
client_header_timeout 300s;
 
# Handle static files
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
}
 
# Main location block
location / {
try_files $uri $uri/ /index.php?$query_string;
}
 
# PHP processing
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass unix:/var/run/php/php8.2-fpm.sock;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
include fastcgi_params;
fastcgi_read_timeout 300;
fastcgi_buffer_size 16k;
fastcgi_buffers 4 16k;
}
 
# Deny access to sensitive files
location ~ /\. {
deny all;
}
}

Enable the site and secure it with SSL:


sudo ln -s /etc/nginx/sites-available/snapencode.conf /etc/nginx/sites-enabled/
sudo nginx -t
sudo apt install -y certbot python3-certbot-nginx
sudo certbot --nginx -d your-domain.com
sudo systemctl restart nginx

6. Configure Queue Worker (Supervisor)

Create a Supervisor config file at /etc/supervisor/conf.d/snapencode-worker.conf:


[program:snapencode-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/snapencode/artisan queue:work redis --queue=high,default,video-encoding --timeout=0 --memory=2048 --tries=3
directory=/var/www/snapencode
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=2
redirect_stderr=true
stdout_logfile=/var/log/snapencode-worker.log
stdout_logfile_maxbytes=100MB
stdout_logfile_backups=5

Start the worker processes:


sudo supervisorctl reread
sudo supervisorctl update
sudo supervisorctl start snapencode-worker:*

Verify the Worker Status:


sudo supervisorctl status

Expected output:


snapencode-worker:snapencode-worker_00 RUNNING   pid 12345, uptime 0:01:15
snapencode-worker:snapencode-worker_01 RUNNING   pid 12346, uptime 0:01:15

7. Configure Task Scheduling

The Laravel Scheduler requires a system cron job. Run sudo crontab -e and add:


* * * * * cd /var/www/snapencode && php artisan schedule:run >> /dev/null 2>&1

Phase 3: Activation (Manual)

Default Admin Credentials

Navigate to https://your-domain.com/login and use the credentials created by the database seeder:

Email: [email protected]
Password: snapencode

⚠️ Change these credentials immediately after first login!

2. Verify Your License

Once logged in, you will be prompted to enter your Snapencode Purchase Code. This will activate your application and unlock all features, including Live Streaming.

3. Enable Live Streaming Server

Create a systemd service for the live media server:


sudo nano /etc/systemd/system/snapencode-live.service

Paste the following configuration:


[Unit]
Description=SnapEncode Live Media Server
After=network.target mysql.service redis.service
 
[Service]
Type=simple
User=www-data
Group=www-data
WorkingDirectory=/var/www/snapencode
ExecStart=/var/www/snapencode/bin/media-live start --api-port="8888" --live-media-dir="/var/www/snapencode/storage/app/public/live_media"
Restart=always
RestartSec=5
StandardOutput=journal
StandardError=journal
SyslogIdentifier=snapencode-live
 
# Resource limits
LimitNOFILE=65536
LimitNPROC=32768
 
[Install]
WantedBy=multi-user.target

Enable and start the service:


sudo systemctl daemon-reload
sudo systemctl enable snapencode-live.service
sudo systemctl start snapencode-live.service

Verify the service status:


sudo systemctl status snapencode-live.service

View live logs:


sudo journalctl -u snapencode-live -f

4. Final System Health Check

Verify all components are running correctly:


# Check Nginx
sudo systemctl status nginx
 
# Check PHP-FPM
sudo systemctl status php8.2-fpm
 
# Check MariaDB
sudo systemctl status mariadb
 
# Check Redis
sudo systemctl status redis-server
 
# Check Supervisor workers
sudo supervisorctl status
 
# Check Live Media Server
sudo systemctl status snapencode-live
 
# Test database connection
php /var/www/snapencode/artisan tinker --execute="DB::connection()->getPdo();"

undefined

This setup uses Docker and Docker Compose for a complete, isolated environment. All processes are managed by containers with proper resource limits.

Phase 1: File Preparation

First, create the necessary configuration files in your project root.

1. Create `Dockerfile`


FROM php:8.2-fpm
 
# Set working directory
WORKDIR /var/www
 
# Install system dependencies
RUN apt-get update && apt-get install -y \
build-essential \
libpng-dev \
libjpeg62-turbo-dev \
libfreetype6-dev \
locales \
zip \
unzip \
git \
curl \
wget \
supervisor \
mariadb-client \
ffmpeg \
nodejs \
npm \
&& rm -rf /var/lib/apt/lists/*
 
# Install PHP extensions
RUN docker-php-ext-configure gd --with-freetype --with-jpeg \
&& docker-php-ext-install pdo_mysql mbstring exif pcntl bcmath gd zip
 
# Install Redis extension
RUN pecl install redis && docker-php-ext-enable redis
 
# Configure PHP for large uploads
RUN echo "upload_max_filesize = 10G" > /usr/local/etc/php/conf.d/uploads.ini \
&& echo "post_max_size = 10G" >> /usr/local/etc/php/conf.d/uploads.ini \
&& echo "max_execution_time = 0" >> /usr/local/etc/php/conf.d/uploads.ini \
&& echo "memory_limit = 2G" >> /usr/local/etc/php/conf.d/uploads.ini
 
# Install Shaka Packager
RUN wget https://github.com/google/shaka-packager/releases/latest/download/packager-linux-x64 -O /usr/local/bin/packager \
&& chmod +x /usr/local/bin/packager
 
# Install Composer
COPY --from=composer:latest /usr/bin/composer /usr/bin/composer
 
# Copy application files
COPY . /var/www
 
# Install PHP dependencies
RUN composer install --no-dev --optimize-autoloader --no-interaction
 
# Install and build frontend assets (optional)
RUN npm install && npm run build
 
# Set permissions
RUN chmod +x /var/www/bin/* \
&& chown -R www-data:www-data /var/www \
&& chmod -R 775 /var/www/storage /var/www/bootstrap/cache
 
EXPOSE 9000
 
CMD ["php-fpm"]

2. Create Supervisor Configuration

Create docker/supervisor/supervisord.conf:


[supervisord]
nodaemon=true
user=root
logfile=/var/log/supervisor/supervisord.log
pidfile=/var/run/supervisord.pid
 
[program:laravel-worker]
process_name=%(program_name)s_%(process_num)02d
command=php /var/www/artisan queue:work redis --queue=high,default,video-encoding --timeout=0 --memory=2048 --tries=3
directory=/var/www
autostart=true
autorestart=true
stopasgroup=true
killasgroup=true
user=www-data
numprocs=2
redirect_stderr=true
stdout_logfile=/var/log/supervisor/laravel-worker.log
stdout_logfile_maxbytes=100MB
stdout_logfile_backups=5

3. Create Nginx Configuration

Create docker/nginx/default.conf:


server {
listen 80;
server_name localhost;
root /var/www/public;
index index.php index.html;
 
# Security headers
add_header X-Frame-Options "SAMEORIGIN" always;
add_header X-XSS-Protection "1; mode=block" always;
add_header X-Content-Type-Options "nosniff" always;
 
# Increase upload limits
client_max_body_size 10G;
client_body_timeout 300s;
client_header_timeout 300s;
 
# Handle static files
location ~* \.(js|css|png|jpg|jpeg|gif|ico|svg|woff|woff2|ttf|eot)$ {
expires 1y;
add_header Cache-Control "public, immutable";
}
 
# Main location
location / {
try_files $uri $uri/ /index.php?$query_string;
}
 
# PHP processing
location ~ \.php$ {
fastcgi_split_path_info ^(.+\.php)(/.+)$;
fastcgi_pass app:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME $document_root$fastcgi_script_name;
include fastcgi_params;
fastcgi_read_timeout 300;
fastcgi_buffer_size 16k;
fastcgi_buffers 4 16k;
}
 
# Media server API proxy
location /api/live/ {
proxy_pass http://snapencode-live:8888/;
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;
}
 
# Deny access to sensitive files
location ~ /\. {
deny all;
}
}

4. Create `docker-compose.yml`


version: '3.8'
 
services:
app:
build:
context: .
dockerfile: Dockerfile
container_name: snapencode_app
restart: unless-stopped
volumes:
- .:/var/www
- storage_data:/var/www/storage/app/public
networks:
- snapencode-network
depends_on:
- db
- redis
 
nginx:
image: nginx:alpine
container_name: snapencode_nginx
restart: unless-stopped
ports:
- "80:80"
- "443:443"
- "1935:1935"
volumes:
- .:/var/www
- ./docker/nginx/default.conf:/etc/nginx/conf.d/default.conf
- storage_data:/var/www/storage/app/public
networks:
- snapencode-network
depends_on:
- app
 
db:
image: mysql:8.0
container_name: snapencode_db
restart: unless-stopped
environment:
MYSQL_DATABASE: ${DB_DATABASE}
MYSQL_ROOT_PASSWORD: ${DB_PASSWORD}
MYSQL_PASSWORD: ${DB_PASSWORD}
MYSQL_USER: ${DB_USERNAME}
volumes:
- mysql_data:/var/lib/mysql
networks:
- snapencode-network
command: --default-authentication-plugin=mysql_native_password
healthcheck:
test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
timeout: 20s
retries: 10
 
redis:
image: redis:7-alpine
container_name: snapencode_redis
restart: unless-stopped
volumes:
- redis_data:/data
networks:
- snapencode-network
command: redis-server --appendonly yes
healthcheck:
test: ["CMD", "redis-cli", "ping"]
timeout: 20s
retries: 5
 
queue:
build:
context: .
dockerfile: Dockerfile
container_name: snapencode_queue
restart: unless-stopped
command: /usr/bin/supervisord -c /etc/supervisor/conf.d/supervisord.conf
volumes:
- .:/var/www
- ./docker/supervisor/supervisord.conf:/etc/supervisor/conf.d/supervisord.conf
- storage_data:/var/www/storage/app/public
- /var/log/supervisor:/var/log/supervisor
networks:
- snapencode-network
depends_on:
- db
- redis
deploy:
resources:
limits:
cpus: '4.0'
memory: 4G
reservations:
cpus: '2.0'
memory: 2G
 
snapencode-live:
build:
context: .
dockerfile: Dockerfile
container_name: snapencode_live
restart: unless-stopped
command: /var/www/bin/media-live start --api-port="8888" --live-media-dir="/var/www/storage/app/public/live_media"
ports:
- "8888:8888"
volumes:
- .:/var/www
- storage_data:/var/www/storage/app/public
networks:
- snapencode-network
depends_on:
- db
- redis
deploy:
resources:
limits:
cpus: '2.0'
memory: 2G
profiles:
- live
 
networks:
snapencode-network:
driver: bridge
 
volumes:
mysql_data:
driver: local
redis_data:
driver: local
storage_data:
driver: local

Phase 2: Application Launch (Docker)

1. Configure Environment

Create your .env file and configure it for the Docker environment:


cp .env.example .env

Edit .env with the following values:


APP_NAME=SnapEncode
APP_ENV=production
APP_DEBUG=false
APP_URL=http://your-domain.com
FRONTEND_URL=http://your-domain.com
 
DB_CONNECTION=mysql
DB_HOST=db
DB_PORT=3306
DB_DATABASE=snapencode
DB_USERNAME=snapencode_user
DB_PASSWORD=your_strong_password_here
 
BROADCAST_DRIVER=log
CACHE_DRIVER=redis
FILESYSTEM_DISK=local
QUEUE_CONNECTION=redis
SESSION_DRIVER=redis
SESSION_LIFETIME=120
 
REDIS_HOST=redis
REDIS_PASSWORD=null
REDIS_PORT=6379
 
FFMPEG_BINARIES=/usr/bin/ffmpeg
FFPROBE_BINARIES=/usr/bin/ffprobe
SHAKA_PACKAGER_BINARIES=/usr/local/bin/packager

2. Build and Start Containers


# Build and start all services
docker-compose up -d --build
 
# Wait for database to be ready
docker-compose logs -f db
 
# Check all services are running
docker-compose ps

3. Initialize the Application

Run the Laravel setup commands:


# Generate application key
docker-compose exec app php artisan key:generate
 
# Run database migrations and seeders
docker-compose exec app php artisan migrate --seed --force
 
# Create storage link
docker-compose exec app php artisan storage:link

Critical Step: Run the optimization commands below only after your .env file has been fully configured.


# Cache configuration for production
docker-compose exec app php artisan config:cache
docker-compose exec app php artisan route:cache
docker-compose exec app php artisan view:cache

4. Verify Queue Workers

Check that the background workers are running:


# View queue container logs
docker-compose logs queue
 
# Check supervisor status inside container
docker-compose exec queue supervisorctl status

Expected output:


laravel-worker:laravel-worker_00   RUNNING   pid 12, uptime 0:15:00
laravel-worker:laravel-worker_01   RUNNING   pid 13, uptime 0:15:00

5. Configure Task Scheduling

Add a cron job to your host machine to run the Laravel scheduler:


# Edit crontab
sudo crontab -e
 
# Add this line
* * * * * cd /path/to/your/project && docker-compose exec -T app php artisan schedule:run >> /dev/null 2>&1

Phase 3: Activation (Docker)

1. Access Your Application

Default Admin Credentials

Navigate to http://your-domain.com/login and use the credentials:

Email: [email protected]
Password: password

⚠️ Change these credentials immediately after first login!

2. Verify Your License

Once logged in, enter your Snapencode Purchase Code to activate your application and unlock all features, including Live Streaming.

3. Enable Live Streaming Server

After license activation, start the live streaming service as a separate container:


# Start the live streaming service
docker-compose --profile live up -d snapencode-live
 
# Verify it's running
docker-compose ps

Expected output after activation:


NAME                 COMMAND                  SERVICE             STATUS              PORTS
snapencode_app       "docker-php-entrypoi…"   app                 running             9000/tcp
snapencode_db        "docker-entrypoint.s…"   db                  running             3306/tcp, 33060/tcp
snapencode_live      "/var/www/bin/media-…"   snapencode-live     running             0.0.0.0:8888->8888/tcp
snapencode_nginx     "/docker-entrypoint.…"   nginx               running             0.0.0.0:80->80/tcp, 0.0.0.0:443->443/tcp, 0.0.0.0:1935->1935/tcp
snapencode_queue     "/usr/bin/supervisor…"   queue               running
snapencode_redis     "docker-entrypoint.s…"   redis               running             6379/tcp

Check Live Streaming Service Status:


# View live streaming logs
docker-compose logs -f snapencode-live
 
# Check if the API is responding
curl http://localhost:8888/health

4. SSL Certificate Setup (Optional)

To enable HTTPS, you can use Let’s Encrypt with Certbot:


# Install Certbot on host machine
sudo apt install certbot python3-certbot-nginx
 
# Stop containers temporarily
docker-compose down
 
# Get SSL certificate
sudo certbot certonly --standalone -d your-domain.com
 
# Update docker-compose.yml to mount certificates
# Add to nginx service volumes:
# - /etc/letsencrypt:/etc/letsencrypt:ro
 
# Update nginx config for SSL and restart
docker-compose up -d

5. Container Health Check

Verify all services are healthy:


# Check container status
docker-compose ps
 
# Check application health
docker-compose exec app php artisan tinker --execute="DB::connection()->getPdo();"
 
# Check storage permissions
docker-compose exec app ls -la storage/
 
# Test Redis connection
docker-compose exec redis redis-cli ping
 
# View logs for any issues
docker-compose logs --tail=50

6. Backup Strategy Setup

Create a backup script for your Docker installation:


#!/bin/bash
# Create backup directory
mkdir -p /backups/snapencode/$(date +%Y-%m-%d)
 
# Backup database
docker-compose exec -T db mysqldump -u root -p$DB_PASSWORD snapencode > /backups/snapencode/$(date +%Y-%m-%d)/database.sql
 
# Backup uploaded content
docker run --rm -v snapencode_storage_data:/data -v /backups/snapencode/$(date +%Y-%m-%d):/backup alpine tar czf /backup/storage.tar.gz /data
 
# Backup configuration
cp .env /backups/snapencode/$(date +%Y-%m-%d)/
cp docker-compose.yml /backups/snapencode/$(date +%Y-%m-%d)/

Installation Complete!

Your SnapEncode platform is now fully installed and operational. Here are your next steps:

Immediate Security Tasks

Change default admin credentials immediately
Update your .env file with strong, unique passwords
Enable firewall if not already configured
Set up SSL certificates for production use

Performance Optimization

Monitor system resources during video processing
Adjust queue worker count based on server capacity
Configure CDN for video delivery (recommended)
Set up regular backups of database and uploaded content

Troubleshooting

Common Issues & Solutions:

Queue Workers Not Processing Jobs:


# Manual installation
sudo supervisorctl restart snapencode-worker:*
 
# Docker installation
docker-compose restart queue

Large File Upload Errors (413):

Verify PHP upload limits in /etc/php/8.2/fpm/conf.d/99-uploads.ini
Check Nginx client_max_body_size setting
Restart both PHP-FPM and Nginx services

Live Streaming Not Working:


# Check if ports are open
sudo ufw status
netstat -tlnp | grep :1935
netstat -tlnp | grep :8888
 
# Verify media server is running
# Manual: sudo systemctl status snapencode-live
# Docker: docker-compose exec queue supervisorctl status snapencode-live

Database Connection Errors:


# Test database connection
php artisan tinker --execute="DB::connection()->getPdo();"
 
# Check database service status
# Manual: sudo systemctl status mariadb
# Docker: docker-compose exec db mysqladmin ping -h localhost

Support Resources

Documentation: Check our knowledge base for detailed configuration guides
Community: Join our Discord server for community support
Professional Support: Contact us for priority technical assistance

Your SnapEncode video platform is ready for configuration and use. Access the admin panel to customize your platform settings, upload policies, and streaming configurations.

Getting Started

System Requirements

CPU

RAM

Storage

OS Support

Supported Operating Systems

Network Requirements

Who is this for?

Purchase & Support

Buy on Snapencode

Contact Us for Help

Installation Method

undefined

Phase 1: Server Preparation (Manual)

1. Install Core Dependencies

2. Increase Upload Limits (Prevent 413 Errors)

3. Configure Firewall

4. Secure Your Database

Phase 2: Application Setup (Manual)

1. Upload & Install

2. Configure Environment (.env)

3. Run Database Migrations

4. Optimize for Production

5. Configure Nginx & Permissions

6. Configure Queue Worker (Supervisor)

7. Configure Task Scheduling

Phase 3: Activation (Manual)

1. Login to Your Application

Default Admin Credentials

2. Verify Your License

3. Enable Live Streaming Server

4. Final System Health Check

undefined

Phase 1: File Preparation

1. Create Dockerfile

2. Create Supervisor Configuration

3. Create Nginx Configuration

4. Create docker-compose.yml

Phase 2: Application Launch (Docker)

1. Configure Environment

2. Build and Start Containers

3. Initialize the Application

4. Verify Queue Workers

5. Configure Task Scheduling

Phase 3: Activation (Docker)

1. Access Your Application

Default Admin Credentials

2. Verify Your License

3. Enable Live Streaming Server

4. SSL Certificate Setup (Optional)

5. Container Health Check

6. Backup Strategy Setup

Installation Complete!

Immediate Security Tasks

Performance Optimization

Troubleshooting

Support Resources

2. Configure Environment (`.env`)

1. Create `Dockerfile`

4. Create `docker-compose.yml`