Deploying Files Sharing

Introduction

Files Sharing is a straightforward, self-hosted file sharing application designed to make sharing files simple, secure, and private. Built with a focus on ease of use and minimal configuration, Files Sharing provides a clean web interface for uploading, managing, and sharing files without the complexity of heavyweight solutions or the privacy concerns of commercial cloud services.

Files Sharing excels at providing essential functionality with zero friction:

Simple Upload: Drag-and-drop file uploads with instant shareable links
Zero Configuration: Works out of the box with sensible defaults
Clean Interface: Minimalist design that doesn’t get in your way
Shareable Links: Generate unique links for each uploaded file
No Account Required: Upload and share without user registration
Self-Hosted Privacy: Complete control over your files and data
Lightweight: Minimal resource usage for efficient operation
Fast Performance: Quick uploads and downloads with no unnecessary overhead
Mobile Responsive: Works seamlessly on phones, tablets, and desktops
Direct Access: Recipients download files directly without barriers
File Management: View, organize, and delete uploaded files
Storage Limits: Set maximum file sizes and storage quotas

Whether you need a quick way to share files with colleagues, send documents to clients, or provide a simple upload portal for your team, Files Sharing delivers exactly what you need without unnecessary complexity. It’s perfect for individuals and small teams who want file sharing that just works.

This comprehensive guide walks you through deploying Files Sharing on Klutch.sh using Docker, including detailed installation steps, persistent storage configuration, customization options, and production-ready best practices.

What You’ll Learn

How to deploy Files Sharing with a Dockerfile on Klutch.sh
Setting up persistent storage for uploaded files
Configuring environment variables for customization
Implementing file size limits and storage management
Best practices for production deployment and security

Prerequisites

Before you begin, ensure you have:

A Klutch.sh account
A GitHub account with a repository for your Files Sharing project
Basic familiarity with Docker and file sharing concepts
(Optional) Docker installed locally for testing

Files Sharing consists of several key components:

Web Server: Lightweight HTTP server handling uploads and downloads
Web Interface: Simple HTML/CSS/JavaScript frontend for file operations
Storage Layer: File system storage for uploaded files
Link Generator: Creates unique shareable links for each file
File Manager: Handles file metadata and organization

The application typically runs on a single HTTP port (usually 3000 or 8080), making it easy to deploy on Klutch.sh with automatic HTTPS.

Step 1: Prepare Your GitHub Repository

Create a new GitHub repository for your Files Sharing deployment.
Create a Dockerfile in the root of your repository with the following content:

FROM node:18-alpine

# Set working directory
WORKDIR /app

# Install git to clone the repository
RUN apk add --no-cache git

# Clone Files Sharing repository
RUN git clone https://github.com/filessharing/files-sharing.git .

# Install dependencies
RUN npm install --production

# Create uploads directory
RUN mkdir -p /app/uploads && \
    chown -R node:node /app/uploads

# Switch to non-root user
USER node

# Expose HTTP port
EXPOSE 3000

# Set environment variables
ENV NODE_ENV=production
ENV PORT=3000
ENV UPLOAD_DIR=/app/uploads

# Health check
HEALTHCHECK --interval=30s --timeout=3s --start-period=40s --retries=3 \
  CMD node healthcheck.js || exit 1

# Start the application
CMD ["npm", "start"]

Note: This Dockerfile uses the official Node.js Alpine image for a minimal, secure deployment. Adjust the repository URL if using a different Files Sharing implementation.

(Optional) Create an advanced Dockerfile with custom configuration:

FROM node:18-alpine

# Install system dependencies
RUN apk add --no-cache \
    git \
    ffmpeg \
    imagemagick \
    && rm -rf /var/cache/apk/*

# Set working directory
WORKDIR /app

# Clone application
RUN git clone https://github.com/filessharing/files-sharing.git . && \
    npm install --production && \
    npm cache clean --force

# Create necessary directories
RUN mkdir -p /app/uploads /app/config /app/logs && \
    chown -R node:node /app

# Copy custom configuration if exists
COPY --chown=node:node config.json /app/config/ 2>/dev/null || true

# Switch to non-root user
USER node

# Expose HTTP port
EXPOSE 3000

# Environment variables
ENV NODE_ENV=production
ENV PORT=3000
ENV UPLOAD_DIR=/app/uploads
ENV CONFIG_DIR=/app/config
ENV LOG_DIR=/app/logs

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

# Start application
CMD ["node", "server.js"]

(Optional) Create a .dockerignore file:

.git
.github
*.md
README.md
.env
.env.local
docker-compose.yml
node_modules
.DS_Store
npm-debug.log
yarn-error.log
.vscode
.idea

Create a README.md file with setup information:

# Files Sharing Deployment on Klutch.sh

This repository contains the Docker configuration for deploying Files Sharing on Klutch.sh.

## About Files Sharing

Files Sharing is a simple, self-hosted file sharing application with no unnecessary complexity.

## Features

- Simple drag-and-drop file uploads
- Instant shareable links
- No user registration required
- Self-hosted privacy
- Lightweight and fast
- Mobile responsive design
- File management interface

## Initial Setup

1. Deploy on Klutch.sh
2. Attach persistent volume for uploads
3. Configure environment variables (optional)
4. Access the web interface
5. Start uploading and sharing files

## Configuration

Set environment variables in Klutch.sh dashboard:
- `MAX_FILE_SIZE`: Maximum upload size in bytes
- `STORAGE_QUOTA`: Total storage limit
- `UPLOAD_DIR`: Directory for uploaded files
- `BASE_URL`: Public URL for your deployment

## Documentation

- Files Sharing: https://github.com/filessharing/files-sharing
- Klutch.sh: https://docs.klutch.sh

Commit and push your changes to GitHub:

git add Dockerfile .dockerignore README.md
git commit -m "Add Files Sharing Dockerfile for Klutch.sh deployment"
git push origin main

Step 2: Create Your App on Klutch.sh

Log in to Klutch.sh and navigate to the dashboard.
Create a new project (if you don’t have one already) by clicking “New Project” and providing a project name like “File Sharing Platform”.
Create a new app within your project by clicking “New App”.
Connect your GitHub repository by selecting it from the list of available repositories.
Configure the build settings:
- Klutch.sh will automatically detect the Dockerfile in your repository root
- The build will use this Dockerfile automatically
Set the internal port to 3000 (Files Sharing’s default HTTP port). This is the port that traffic will be routed to within the container.
Select HTTP traffic for the app’s traffic type.

Step 3: Configure Persistent Storage

Files Sharing requires persistent storage to retain uploaded files across deployments.

In your app settings, navigate to the “Volumes” section.
Add a persistent volume for uploaded files:
- Mount Path: /app/uploads
- Size: Choose based on your file sharing needs (start with 10 GB, scale as needed)
(Optional) Add a second persistent volume for logs and configuration:
- Mount Path: /app/logs
- Size: 1 GB is typically sufficient
Save the volume configuration. This ensures all your uploaded files persist even when the container is restarted or redeployed.

The persistent volume stores:

/app/uploads: All user-uploaded files
/app/logs: (Optional) Application logs and access records

For more details on managing persistent storage, see the Volumes Guide.

Step 4: Configure Environment Variables

Files Sharing can be customized using environment variables. Configure these in the Klutch.sh dashboard:

In your app settings, navigate to the “Environment Variables” section.
Add basic configuration variables:

# Server configuration
PORT=3000
NODE_ENV=production

# Public URL (set to your actual app URL)
BASE_URL=https://example-app.klutch.sh

# File storage settings
UPLOAD_DIR=/app/uploads

# Upload limits (in bytes)
MAX_FILE_SIZE=104857600
MAX_TOTAL_SIZE=10737418240

# Timezone configuration
TZ=America/New_York

Add optional customization variables:

# File retention settings
FILE_EXPIRY_DAYS=30
AUTO_DELETE_EXPIRED=true

# Upload restrictions
ALLOWED_EXTENSIONS=pdf,doc,docx,xls,xlsx,jpg,jpeg,png,gif,zip,tar,gz
BLOCKED_EXTENSIONS=exe,bat,sh,ps1

# Rate limiting
ENABLE_RATE_LIMIT=true
MAX_UPLOADS_PER_HOUR=50

# Interface customization
APP_TITLE=Files Sharing
APP_DESCRIPTION=Simple file sharing platform
THEME_COLOR=#2563eb

# Logging
LOG_LEVEL=info
LOG_FORMAT=json
ENABLE_ACCESS_LOG=true

Optional advanced configuration:

# Storage management
ENABLE_COMPRESSION=true
GENERATE_THUMBNAILS=true
THUMBNAIL_SIZE=200

# Security settings
REQUIRE_PASSWORD=false
ALLOW_PUBLIC_UPLOADS=true
ENABLE_CAPTCHA=false

# Link generation
LINK_LENGTH=8
CUSTOM_DOMAIN=files.example.com

# Cleanup settings
CLEANUP_INTERVAL=3600
DELETE_EMPTY_FOLDERS=true

Mark sensitive values as secrets in the Klutch.sh UI to prevent them from appearing in logs.

Important Configuration Notes:

Never commit secrets or API keys to your repository
Always use Klutch.sh environment variables for configuration
Set appropriate file size limits to prevent abuse
Configure retention policies to manage storage
Enable rate limiting for public deployments

Step 5: Deploy Your Application

Review your configuration to ensure all settings are correct:
- Dockerfile is detected
- Internal port is set to 3000
- Persistent volume is mounted to /app/uploads
- Environment variables are configured
- Traffic type is set to HTTP
Click “Deploy” to start the build and deployment process.
Monitor the build logs to ensure the deployment completes successfully. The build typically takes 2-4 minutes.
Wait for the deployment to complete. Once done, you’ll see your app URL (e.g., https://example-app.klutch.sh).

Access your Files Sharing instance by navigating to your app URL (e.g., https://example-app.klutch.sh).
Upload your first file:
- Click the upload button or drag and drop a file
- Wait for the upload to complete
- Receive your shareable link
Copy and share the link:
- Click the “Copy Link” button
- Share with recipients via email, chat, etc.
Test the download:
- Open the link in an incognito browser
- Verify the file downloads correctly
- Check file integrity

Here’s how to use Files Sharing for common tasks:

Basic File Upload

Via Web Interface:

1. Navigate to your Files Sharing URL
2. Click "Upload" or drag & drop file
3. Wait for upload to complete
4. Copy the generated link
5. Share the link with recipients

Upload via cURL

Files Sharing provides a simple API for programmatic uploads:

# Upload a file
curl -X POST https://example-app.klutch.sh/upload \
  -F "file=@/path/to/document.pdf"

# Response includes download link
{
  "success": true,
  "fileId": "abc123xyz",
  "downloadLink": "https://example-app.klutch.sh/d/abc123xyz",
  "filename": "document.pdf",
  "size": 1048576,
  "uploadedAt": "2025-12-21T15:00:00Z"
}

Download via cURL

# Download a file
curl -O https://example-app.klutch.sh/d/abc123xyz

# Download with custom filename
curl -o mydocument.pdf https://example-app.klutch.sh/d/abc123xyz

# Get file information
curl https://example-app.klutch.sh/api/info/abc123xyz

JavaScript Integration

// Files Sharing Upload Client
class FilesSharingClient {
    constructor(baseUrl) {
        this.baseUrl = baseUrl;
    }

    async uploadFile(file, options = {}) {
        const formData = new FormData();
        formData.append('file', file);

        // Optional metadata
        if (options.description) {
            formData.append('description', options.description);
        }

        if (options.expiryDays) {
            formData.append('expiryDays', options.expiryDays);
        }

        try {
            const response = await fetch(`${this.baseUrl}/upload`, {
                method: 'POST',
                body: formData
            });

            if (!response.ok) {
                throw new Error(`Upload failed: ${response.statusText}`);
            }

            return await response.json();
        } catch (error) {
            console.error('Upload error:', error);
            throw error;
        }
    }

    async getFileInfo(fileId) {
        try {
            const response = await fetch(`${this.baseUrl}/api/info/${fileId}`);

            if (!response.ok) {
                throw new Error(`Failed to get file info: ${response.statusText}`);
            }

            return await response.json();
        } catch (error) {
            console.error('Get info error:', error);
            throw error;
        }
    }

    async deleteFile(fileId, deleteToken) {
        try {
            const response = await fetch(`${this.baseUrl}/api/delete/${fileId}`, {
                method: 'DELETE',
                headers: {
                    'Content-Type': 'application/json'
                },
                body: JSON.stringify({ token: deleteToken })
            });

            if (!response.ok) {
                throw new Error(`Delete failed: ${response.statusText}`);
            }

            return await response.json();
        } catch (error) {
            console.error('Delete error:', error);
            throw error;
        }
    }

    getDownloadUrl(fileId) {
        return `${this.baseUrl}/d/${fileId}`;
    }
}

// Usage example
const client = new FilesSharingClient('https://example-app.klutch.sh');

// Upload file with progress tracking
const fileInput = document.querySelector('#file-input');
fileInput.addEventListener('change', async (e) => {
    const file = e.target.files[0];
    const progressBar = document.querySelector('#progress');

    try {
        const result = await client.uploadFile(file, {
            description: 'Project documentation',
            expiryDays: 7
        });

        console.log('Upload successful!');
        console.log('Download link:', result.downloadLink);

        // Display shareable link
        document.querySelector('#share-link').textContent = result.downloadLink;
        document.querySelector('#share-link').href = result.downloadLink;
    } catch (error) {
        console.error('Upload failed:', error);
        alert('Upload failed. Please try again.');
    }
});

// Copy link to clipboard
function copyToClipboard(text) {
    navigator.clipboard.writeText(text).then(() => {
        console.log('Link copied to clipboard');
        showNotification('Link copied!');
    }).catch(err => {
        console.error('Failed to copy:', err);
    });
}

Python Integration

import requests
from pathlib import Path

class FilesSharingClient:
    def __init__(self, base_url):
        self.base_url = base_url

    def upload_file(self, file_path, description=None, expiry_days=None):
        """
        Upload a file to Files Sharing

        Args:
            file_path: Path to the file to upload
            description: Optional file description
            expiry_days: Optional expiration in days
        """
        url = f"{self.base_url}/upload"

        files = {
            'file': open(file_path, 'rb')
        }

        data = {}
        if description:
            data['description'] = description

        if expiry_days:
            data['expiryDays'] = expiry_days

        try:
            response = requests.post(url, files=files, data=data)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Upload failed: {e}")
            raise
        finally:
            files['file'].close()

    def download_file(self, file_id, save_path):
        """
        Download a file from Files Sharing

        Args:
            file_id: The file ID from the share link
            save_path: Where to save the downloaded file
        """
        url = f"{self.base_url}/d/{file_id}"

        try:
            response = requests.get(url, stream=True)
            response.raise_for_status()

            # Get filename from Content-Disposition header
            content_disposition = response.headers.get('Content-Disposition')
            if content_disposition:
                filename = content_disposition.split('filename=')[1].strip('"')
            else:
                filename = Path(save_path).name

            with open(save_path, 'wb') as f:
                for chunk in response.iter_content(chunk_size=8192):
                    f.write(chunk)

            print(f"File downloaded successfully to {save_path}")
            return filename
        except requests.exceptions.RequestException as e:
            print(f"Download failed: {e}")
            raise

    def get_file_info(self, file_id):
        """
        Get information about a shared file
        """
        url = f"{self.base_url}/api/info/{file_id}"

        try:
            response = requests.get(url)
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Failed to get file info: {e}")
            raise

    def delete_file(self, file_id, delete_token):
        """
        Delete a file using the delete token
        """
        url = f"{self.base_url}/api/delete/{file_id}"

        try:
            response = requests.delete(
                url,
                json={'token': delete_token}
            )
            response.raise_for_status()
            return response.json()
        except requests.exceptions.RequestException as e:
            print(f"Delete failed: {e}")
            raise

# Usage example
client = FilesSharingClient('https://example-app.klutch.sh')

# Upload a file
result = client.upload_file(
    'report.pdf',
    description='Monthly report',
    expiry_days=30
)

print(f"Upload successful!")
print(f"File ID: {result['fileId']}")
print(f"Download link: {result['downloadLink']}")
print(f"Delete token: {result.get('deleteToken', 'N/A')}")

# Download a file
client.download_file('abc123xyz', 'downloaded_report.pdf')

# Get file information
info = client.get_file_info('abc123xyz')
print(f"Filename: {info['filename']}")
print(f"Size: {info['size']} bytes")
print(f"Uploaded: {info['uploadedAt']}")

Production Best Practices

Security

File Type Restrictions: Block potentially dangerous file types
Size Limits: Set reasonable maximum file sizes to prevent abuse
Rate Limiting: Enable rate limiting for public deployments
HTTPS Only: Always use HTTPS (automatic on Klutch.sh)
Regular Updates: Keep Files Sharing updated to the latest version
Access Logs: Enable logging to monitor usage and detect abuse
Virus Scanning: Consider integrating virus scanning for uploads
Cleanup Policies: Implement automatic deletion of old files
Secure Links: Use long, random file IDs to prevent guessing
No Directory Listing: Ensure uploaded files aren’t browsable

Storage Management

Monitor Disk Usage: Regularly check volume capacity and usage
- Set up alerts for 80% capacity
- Plan for storage growth
- Implement quotas if needed
Storage Optimization:
- Enable compression for large files
- Set reasonable file size limits
- Implement automatic cleanup policies
- Archive old files if needed
Backup Strategy:
- Daily automated backups of upload volume
- Test restore procedures regularly
- Off-site backup storage
- Version control for important files

Performance

Resource Allocation: Allocate sufficient resources based on usage
- Small deployments (< 50 uploads/day): 512MB RAM, 1 CPU
- Medium deployments (50-500 uploads/day): 1GB RAM, 2 CPUs
- Large deployments (500+ uploads/day): 2GB+ RAM, 4+ CPUs

Optimization Settings:

# Node.js memory limits
NODE_OPTIONS=--max-old-space-size=1024

# Upload concurrency
MAX_CONCURRENT_UPLOADS=5

# Request timeout
REQUEST_TIMEOUT=300000

# Body parser limits
BODY_LIMIT=100mb

Caching: Enable caching for static assets
CDN Integration: Consider CDN for serving downloads (optional)

Monitoring

Monitor these key metrics:

Application Health: Response times, error rates, uptime
Storage Metrics: Available disk space, total files, storage growth rate
Resource Usage: CPU, memory, disk I/O, network bandwidth
Upload Statistics: Number of uploads, file sizes, upload success rate
Download Metrics: Download count, bandwidth usage, popular files
Error Tracking: Failed uploads, 404s, server errors
User Activity: Active users, peak usage times

Troubleshooting

Application Won’t Start

Issue: Container starts but application doesn’t respond

Solutions:

Verify internal port is set to 3000
Check application logs in Klutch.sh dashboard
Ensure persistent volume is properly mounted
Verify sufficient disk space in volume
Check for Node.js errors in startup logs
Verify all required dependencies are installed

Cannot Upload Files

Issue: File uploads fail or timeout

Solutions:

Check MAX_FILE_SIZE environment variable
Verify upload volume has sufficient free space
Ensure volume permissions are correct (node user needs write access)
Review network connectivity
Check for rate limiting configuration
Verify body parser limits are appropriate
Test with smaller files first

Files Not Persisting

Issue: Uploaded files disappear after restart

Solutions:

Verify persistent volume is attached to correct mount path
Check volume permissions (node user needs write access)
Ensure UPLOAD_DIR environment variable matches mount path
Review volume mount configuration in Klutch.sh dashboard
Check for disk space issues
Verify volume is not being cleared on restart

Download Links Not Working

Issue: Generated links return 404 or errors

Solutions:

Verify BASE_URL environment variable is set correctly
Check that files haven’t been deleted or expired
Ensure file IDs are correct
Review link format is correct
Check file permissions
Verify files exist in upload directory

Slow Upload/Download Performance

Issue: File transfers are slow or timeout

Solutions:

Increase instance CPU and memory resources
Check network bandwidth limits
Optimize upload buffer sizes
Review concurrent upload limits
Check volume I/O performance
Consider using compression
Monitor resource usage during transfers

Storage Full

Issue: Cannot upload files due to storage limits

Solutions:

Increase volume size in Klutch.sh dashboard
Implement automatic cleanup of old files
Review and adjust retention policies
Delete unnecessary files
Enable compression
Set more aggressive expiration times

High Memory Usage

Issue: Application consuming excessive memory

Solutions:

Adjust NODE_OPTIONS for memory limits
Review concurrent upload settings
Check for memory leaks in logs
Restart application periodically
Optimize file processing
Increase instance memory allocation

Advanced Configuration

Custom Branding

Customize the interface appearance:

# Branding environment variables
APP_TITLE=My File Sharing
APP_LOGO_URL=https://example.com/logo.png
THEME_PRIMARY_COLOR=#3b82f6
THEME_SECONDARY_COLOR=#10b981
FAVICON_URL=https://example.com/favicon.ico

File Expiration Policies

Configure automatic file deletion:

# Expiration settings
DEFAULT_EXPIRY_DAYS=7
MAX_EXPIRY_DAYS=365
MIN_EXPIRY_DAYS=1
AUTO_DELETE_EXPIRED=true
CLEANUP_INTERVAL=3600

# Size-based expiration
SMALL_FILE_EXPIRY=30
LARGE_FILE_EXPIRY=7
SIZE_THRESHOLD=52428800

Upload Restrictions

Control what can be uploaded:

# File type restrictions
ALLOWED_EXTENSIONS=pdf,doc,docx,xls,xlsx,ppt,pptx,jpg,jpeg,png,gif,zip,tar,gz,mp4,mp3
BLOCKED_EXTENSIONS=exe,bat,sh,ps1,cmd,scr,vbs,jar,dll

# Enable MIME type validation
VALIDATE_MIME_TYPES=true
STRICT_MIME_CHECK=true

# Size restrictions by type
IMAGE_MAX_SIZE=10485760
VIDEO_MAX_SIZE=524288000
DOCUMENT_MAX_SIZE=52428800

Rate Limiting

Prevent abuse with rate limits:

# Rate limiting configuration
ENABLE_RATE_LIMIT=true

# Uploads per IP
UPLOAD_LIMIT_PER_HOUR=20
UPLOAD_LIMIT_PER_DAY=100

# Downloads per IP
DOWNLOAD_LIMIT_PER_HOUR=50
DOWNLOAD_LIMIT_PER_DAY=500

# API requests
API_LIMIT_PER_MINUTE=60

# Ban configuration
BAN_AFTER_VIOLATIONS=3
BAN_DURATION=3600

Email Notifications

Configure email alerts:

# Email configuration
ENABLE_EMAIL=true

# SMTP settings
SMTP_HOST=smtp.example.com
SMTP_PORT=587
SMTP_SECURE=true
SMTP_USER=notifications@example.com
SMTP_PASSWORD=your-smtp-password
SMTP_FROM=Files Sharing <noreply@example.com>

# Notification settings
NOTIFY_ON_UPLOAD=false
NOTIFY_ADMIN_ON_UPLOAD=true
NOTIFY_ON_DOWNLOAD=false
ADMIN_EMAIL=admin@example.com

To upgrade Files Sharing to a new version:

Method 1: Update Dockerfile

Update the Dockerfile to use a specific version or latest:

# Pin to specific commit or tag
RUN git clone --branch v2.0.0 https://github.com/filessharing/files-sharing.git .

Commit and push the changes:

git add Dockerfile
git commit -m "Upgrade Files Sharing to version 2.0.0"
git push origin main

Redeploy the application through Klutch.sh dashboard.
Verify the upgrade was successful:
- Check version in application footer
- Test file upload and download
- Verify existing files are accessible

Pre-Upgrade Checklist

✅ Backup persistent volume
✅ Review changelog for breaking changes
✅ Test upgrade in development environment
✅ Notify users of scheduled maintenance
✅ Document current configuration
✅ Monitor logs after upgrade
✅ Test all functionality

Use Cases

Quick file sharing within teams:

Share project files with colleagues
Distribute meeting recordings
Exchange large design files
No email attachment limits
Track file downloads

Client File Delivery

Deliver files to clients professionally:

Send project deliverables
Share reports and documents
Provide download links in emails
Professional appearance
No client account required

Temporary File Hosting

Host files for limited-time needs:

Event materials and resources
Conference presentations
Workshop downloads
Time-limited access
Automatic cleanup

Internal File Portal

Provide upload portal for organization:

Collect files from team members
Receive documents from partners
Simple upload interface
Centralized storage
Easy access management

Resources

Conclusion

You now have a fully functional Files Sharing platform running on Klutch.sh with persistent storage, configured settings, and production-ready features. This setup allows you to:

Upload and share files with simple links
Manage files through a clean web interface
Control access with expiration and limits
Maintain privacy with self-hosted infrastructure
Scale storage as your needs grow
Track usage and downloads

Files Sharing on Klutch.sh provides a straightforward, privacy-focused alternative to commercial file sharing services while giving you complete control over your data. With automatic HTTPS, persistent storage, and easy scalability, you have a reliable platform for all your file sharing needs.

For questions or community support, refer to the Files Sharing GitHub Issues or the official documentation.

Deploying Files Sharing

Introduction

What You’ll Learn

Prerequisites

Understanding Files Sharing Architecture

Step 1: Prepare Your GitHub Repository

Step 2: Create Your App on Klutch.sh

Step 3: Configure Persistent Storage

Step 4: Configure Environment Variables

Step 5: Deploy Your Application

Step 6: Getting Started with Files Sharing

Sample Usage: Uploading and Sharing Files

Basic File Upload

Upload via cURL

Download via cURL

JavaScript Integration

Python Integration

Production Best Practices

Security

Storage Management

Performance

Monitoring

Troubleshooting

Application Won’t Start

Cannot Upload Files

Files Not Persisting

Download Links Not Working

Slow Upload/Download Performance

Storage Full

High Memory Usage

Advanced Configuration

Custom Branding

File Expiration Policies

Upload Restrictions

Rate Limiting

Email Notifications

Upgrading Files Sharing

Method 1: Update Dockerfile

Pre-Upgrade Checklist

Use Cases

Team File Sharing

Client File Delivery

Temporary File Hosting

Internal File Portal

Resources

Conclusion