Skip to content
Klutch.sh Docs

Deploying Cells

Introduction

Pydio Cells is a modern, open-source document management and file sharing platform designed for enterprises and teams that need secure, self-hosted collaboration tools. Built with Go and featuring a microservices architecture, Cells provides powerful features including file synchronization, versioning, collaborative editing, fine-grained access controls, activity streams, and enterprise-grade security. It serves as a robust alternative to proprietary solutions like Dropbox, Google Drive, or SharePoint, giving organizations complete control over their data.

Deploying Pydio Cells on Klutch.sh provides a production-ready, scalable infrastructure with automated Docker deployments, persistent storage for your files and databases, secure environment variable management, and automatic SSL certificate provisioning. Whether you’re building an internal document repository, team collaboration workspace, client portal, or enterprise content management system, Klutch.sh simplifies the deployment process and ensures your Cells instance is always available and performant.

This comprehensive guide walks you through deploying Pydio Cells on Klutch.sh using a Dockerfile, configuring persistent volumes for data retention, setting up databases (MySQL or PostgreSQL), managing environment variables for security, and implementing production best practices for scalable file sharing and collaboration.

Prerequisites

Before you begin deploying Pydio Cells on Klutch.sh, ensure you have:

  • A Klutch.sh account (sign up here)
  • A GitHub repository for your Cells deployment configuration
  • Basic understanding of Docker containers and file system permissions
  • (Recommended) A MySQL or PostgreSQL database instance for production use
  • Access to the Klutch.sh dashboard

Understanding Pydio Cells Architecture

Pydio Cells consists of several key components that work together to provide comprehensive file management:

  • Web Interface: Modern React-based frontend for file browsing, uploads, and collaboration
  • API Gateway: RESTful API and gRPC services for all backend operations
  • Storage Services: Handle file storage, versioning, and metadata management
  • Database: MySQL or PostgreSQL for storing metadata, permissions, and configurations
  • Search Engine: Built-in Bleve search for fast file and content discovery
  • Authentication: Supports LDAP, OAuth2, SAML, and built-in user management
  • Sync Client: Desktop and mobile clients for offline access and synchronization

When deployed on Klutch.sh, Cells automatically detects your Dockerfile and builds a container image. The platform manages traffic routing, SSL certificates, and provides persistent storage options for your files and database.

Project Structure

A minimal repository structure for deploying Pydio Cells on Klutch.sh:

cells-deployment/
├── Dockerfile
├── .dockerignore
├── .gitignore
├── README.md
└── pydio.env.example

This simple structure allows Klutch.sh to automatically detect and build your Cells container. The official Pydio Cells Docker image comes pre-packaged with all necessary components.

Getting Started: Sample Code and Installation

Creating Your Deployment Repository

    1. Initialize Your Repository

      Create a new directory and initialize it as a Git repository:

      Terminal window
      mkdir cells-deployment
      cd cells-deployment
      git init

    2. Create .gitignore File

      Create a .gitignore file to exclude sensitive and unnecessary files:

      .env
      .DS_Store
      node_modules/
      data/
      logs/
      *.log

    3. Create .dockerignore File

      Create a .dockerignore file to exclude files from Docker builds:

      .git
      .gitignore
      README.md
      .env
      data/
      logs/

    4. Initialize GitHub Repository

      Push your repository to GitHub:

      Terminal window
      git add .
      git commit -m "Initial Cells deployment setup"
      git remote add origin https://github.com/YOUR_USERNAME/cells-deployment.git
      git push -u origin main

Sample Dockerfile

Create a Dockerfile in your repository root. Klutch.sh will automatically detect this file and use it for deployment.

Option 1: Basic Dockerfile (Quick Start)

FROM pydio/cells:latest


# Expose the default Cells port
EXPOSE 8080


# The official image includes initialization scripts
CMD ["cells", "start"]

Option 2: Production Dockerfile with Health Checks

FROM pydio/cells:latest


# Set working directory
WORKDIR /var/cells


# Expose the application port
EXPOSE 8080


# Add health check for monitoring
HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/a/frontend/bootconf || exit 1


# Start Cells with production settings
CMD ["cells", "start"]

Option 3: Custom Dockerfile with Additional Configuration

FROM pydio/cells:latest


# Install additional utilities if needed
RUN apt-get update && apt-get install -y \
    curl \
    wget \
    ca-certificates \
    && rm -rf /var/lib/apt/lists/*


# Set working directory
WORKDIR /var/cells


# Copy custom configuration files (optional)
# COPY ./config/cells-config.yml /var/cells/


# Expose the application port
EXPOSE 8080


# Health check for production monitoring
HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
  CMD wget --no-verbose --tries=1 --spider http://localhost:8080/a/frontend/bootconf || exit 1


# Start Cells services
CMD ["cells", "start"]

Important Notes:

  • Pydio Cells listens on port 8080 by default
  • Klutch.sh will route external HTTP traffic to port 8080 in your container
  • The container requires persistent storage for files, databases, and configuration
  • Environment variables are used to configure database connections and security settings

Deploying to Klutch.sh

    1. Create Your Dockerfile

      Add your chosen Dockerfile to your repository:

      Terminal window
      cat > Dockerfile << 'EOF'
      FROM pydio/cells:latest
      

      WORKDIR /var/cells
      

      EXPOSE 8080
      

      HEALTHCHECK --interval=30s --timeout=10s --start-period=90s --retries=3 \
        CMD wget --no-verbose --tries=1 --spider http://localhost:8080/a/frontend/bootconf || exit 1
      

      CMD ["cells", "start"]
      EOF

    2. Commit and Push to GitHub

      Terminal window
      git add Dockerfile
      git commit -m "Add Dockerfile for Pydio Cells"
      git push origin main

    3. Access the Klutch.sh Dashboard

      Navigate to klutch.sh/app and log in to your account.

    4. Create a New Project

      • Click “New Project” in the dashboard
      • Enter a project name (e.g., “File Sharing Platform”)
      • Select your preferred region for deployment

    5. Create a New Application

      • Within your project, click “New App”
      • Name your application (e.g., “Cells”)
      • Connect your GitHub repository containing the Dockerfile

    6. Configure Build Settings

      Klutch.sh automatically detects the Dockerfile in your repository root. The platform will build your container image using this Dockerfile.

    7. Set Up Persistent Storage

      Pydio Cells requires persistent storage to retain files, databases, and configurations across deployments:

      • In the app settings, navigate to the “Volumes” section
      • Click “Add Volume”
      • Set the mount path to /var/cells
      • Set the volume size (recommended: 20GB minimum for production, 50GB+ for larger deployments)
      • Click “Add” to attach the volume

      Critical: The /var/cells directory stores:

      • Uploaded files and documents
      • Database files (if using embedded database)
      • Application configurations
      • User data and permissions
      • Search indexes
      • Activity logs and audit trails

    8. Configure Environment Variables

      In the app settings, add the following environment variables:

      Essential Variables:

      Terminal window
      CELLS_BIND=0.0.0.0:8080
      CELLS_EXTERNAL=https://your-app-name.klutch.sh

      Database Configuration (External Database - Recommended):

      For MySQL:

      Terminal window
      CELLS_DB_DRIVER=mysql
      CELLS_DB_DSN=username:password@tcp(mysql-host:8000)/cells?parseTime=true

      For PostgreSQL:

      Terminal window
      CELLS_DB_DRIVER=postgres
      CELLS_DB_DSN=postgresql://username:password@postgres-host:8000/cells?sslmode=disable

      Security Configuration:

      Terminal window
      CELLS_ADMIN_PWD=your-strong-admin-password
      CELLS_SECRET=your-random-secret-key-minimum-32-characters

      Optional Configuration:

      Terminal window
      CELLS_LOG_LEVEL=info
      CELLS_NO_TLS=true
      CELLS_SITE_BIND=0.0.0.0:8080
      CELLS_SITE_EXTERNAL=https://your-app-name.klutch.sh

      Security Best Practice: Always use the “Secret” checkbox for sensitive values like passwords, database credentials, and secret keys.

    9. Configure Traffic Settings

      • In the “Networking” section, select HTTP as the traffic type
      • Set the internal port to 8080 (Cells default port)
      • Enable automatic HTTPS/SSL (provided by Klutch.sh)

    10. Deploy the Application

      • Review all settings
      • Click “Deploy” to start the build process
      • Klutch.sh will:
        • Clone your repository from GitHub
        • Detect the Dockerfile in the root directory
        • Build the container image
        • Deploy to your selected region
        • Provision persistent storage
        • Configure networking and SSL certificates

    11. Monitor Deployment Progress

      • View real-time build logs in the dashboard
      • Wait for the deployment status to show “Running”
      • Initial startup may take 2-3 minutes as Cells initializes databases and services

Once deployment completes, your Pydio Cells instance will be accessible at https://example-app.klutch.sh (or your configured custom domain).

Database Setup and Configuration

Pydio Cells requires a database to store metadata, permissions, and configurations. You can use either an embedded database (suitable for development) or an external database (recommended for production).

Option 1: Embedded Database (Development)

For testing and small deployments, Cells can use an embedded BoltDB or SQLite database. When you attach a persistent volume to /var/cells, the database files are stored there automatically.

Pros:

  • No external database setup required
  • Simplified configuration
  • Good for evaluation and small teams

Cons:

  • Limited scalability
  • No replication or high availability
  • Resource sharing with application

Configuration:

No additional environment variables needed. Cells will automatically create a local database in the persistent volume.

For production deployments, use an external MySQL database:

    1. Deploy MySQL on Klutch.sh

      Follow the Klutch.sh MySQL deployment guide to set up a MySQL instance. When deploying:

      • Select TCP as the traffic type
      • Set the internal port to 3306
      • External connections will use port 8000

    2. Create Database and User

      Connect to your MySQL instance and create a database for Cells:

      CREATE DATABASE cells CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
      CREATE USER 'cells_user'@'%' IDENTIFIED BY 'strong-secure-password';
      GRANT ALL PRIVILEGES ON cells.* TO 'cells_user'@'%';
      FLUSH PRIVILEGES;

    3. Configure Connection String

      In your Klutch.sh app environment variables, set:

      Terminal window
      CELLS_DB_DRIVER=mysql
      CELLS_DB_DSN=cells_user:strong-secure-password@tcp(your-mysql-app.klutch.sh:8000)/cells?parseTime=true

      Note: Use port 8000 for TCP traffic when connecting to databases deployed on Klutch.sh.

    4. Restart Application

      After setting the environment variables, trigger a new deployment in the Klutch.sh dashboard for the changes to take effect.

Option 3: External PostgreSQL Database

Pydio Cells also supports PostgreSQL:

    1. Deploy PostgreSQL on Klutch.sh

      Follow the Klutch.sh PostgreSQL deployment guide. When deploying:

      • Select TCP as the traffic type
      • Set the internal port to 5432
      • External connections will use port 8000

    2. Create Database and User

      CREATE DATABASE cells;
      CREATE USER cells_user WITH PASSWORD 'strong-secure-password';
      GRANT ALL PRIVILEGES ON DATABASE cells TO cells_user;

    3. Configure Environment Variable

      Terminal window
      CELLS_DB_DRIVER=postgres
      CELLS_DB_DSN=postgresql://cells_user:strong-secure-password@your-postgres-app.klutch.sh:8000/cells?sslmode=disable

      Note: Use port 8000 for TCP traffic when connecting to databases deployed on Klutch.sh.

    4. Deploy Changes

      Trigger a new deployment in Klutch.sh for the configuration to take effect.

Setting Up Persistent Volumes

Persistent storage is critical for maintaining files, user data, and configurations across deployments and restarts.

Required Mount Path

Configure a persistent volume in the Klutch.sh dashboard:

  • Mount Path: /var/cells
  • Recommended Size:
    • Development: 10GB
    • Small team (< 50 users): 50GB
    • Medium team (50-200 users): 200GB
    • Large organization (200+ users): 500GB+

What Gets Stored

The /var/cells directory contains:

/var/cells/
├── data/              # Uploaded files and documents
├── logs/              # Application logs and audit trails
├── services/          # Service configurations
├── config/            # Application configuration files
├── indexes/           # Search indexes
└── certs/            # SSL certificates (if self-managed)

Backup Strategy

For production deployments, implement regular backups:

    1. Schedule Volume Snapshots

      Use Klutch.sh’s volume management features to create regular snapshots of your persistent volume.

    2. File System Backups

      Create regular backups of the /var/cells/data directory:

      Terminal window
      # Example backup script
      tar -czf cells-backup-$(date +%Y%m%d).tar.gz /var/cells/data

    3. Database Backups

      For external databases, set up automated backup schedules:

      MySQL:

      Terminal window
      mysqldump -h your-mysql-app.klutch.sh -P 8000 -u cells_user -p cells > cells-db-backup-$(date +%Y%m%d).sql

      PostgreSQL:

      Terminal window
      pg_dump -h your-postgres-app.klutch.sh -p 8000 -U cells_user cells > cells-db-backup-$(date +%Y%m%d).sql

    4. Store Backups Securely

      Upload backups to cloud storage (S3, Google Cloud Storage) or a secure backup service.

Environment Variables Reference

Required Variables

VariableDescriptionExample
CELLS_BINDInternal bind address and port0.0.0.0:8080
CELLS_EXTERNALExternal URL for accessing Cellshttps://cells.yourdomain.com
CELLS_SECRETSecret key for encryption (min 32 chars)your-random-secret-key-here
CELLS_ADMIN_PWDInitial administrator passwordstrong-admin-password

Database Variables

VariableDescriptionExample
CELLS_DB_DRIVERDatabase driver (mysql or postgres)mysql
CELLS_DB_DSNDatabase connection stringuser:pass@tcp(host:8000)/cells?parseTime=true

Optional Configuration

VariableDescriptionDefault
CELLS_LOG_LEVELLogging level (debug, info, warn, error)info
CELLS_NO_TLSDisable internal TLS (Klutch.sh handles SSL)true
CELLS_SITE_BINDAlternative bind address for frontend0.0.0.0:8080
CELLS_SITE_EXTERNALAlternative external URL-
CELLS_WORKING_DIRWorking directory path/var/cells

LDAP/Active Directory Integration

VariableDescription
CELLS_AUTH_CONNECTORAuthentication connector type
CELLS_LDAP_URLLDAP server URL
CELLS_LDAP_BIND_DNLDAP bind DN
CELLS_LDAP_BIND_PASSWORDLDAP bind password
CELLS_LDAP_USER_BASEUser search base DN

Email Configuration

VariableDescription
CELLS_SMTP_HOSTSMTP server hostname
CELLS_SMTP_PORTSMTP server port
CELLS_SMTP_USERSMTP username
CELLS_SMTP_PASSWORDSMTP password
CELLS_SMTP_FROMSender email address

Initial Setup and Configuration

After deploying your Pydio Cells instance, complete the initial setup:

    1. Access Your Instance

      Navigate to https://example-app.klutch.sh (or your custom domain).

    2. Complete Installation Wizard

      On first access, Cells will launch an installation wizard:

      • Step 1: Welcome - Review system requirements
      • Step 2: License - Accept the open-source license
      • Step 3: Database - Verify database connection (pre-configured via environment variables)
      • Step 4: Advanced Settings - Configure additional options
      • Step 5: Admin Account - Create your administrator account
      • Step 6: Summary - Review and complete installation

    3. Create Administrator Account

      If you set CELLS_ADMIN_PWD, use that password. Otherwise, create a new admin account:

      • Enter administrator username (e.g., admin)
      • Set a strong password
      • Enter email address

    4. Configure Organization Settings

      • Set your organization name
      • Configure default language and timezone
      • Set up branding (logo, colors)

    5. Create Workspaces

      Workspaces are shared folders with specific permissions:

      • Click “Workspaces” in the left sidebar
      • Click “Create Workspace”
      • Name your workspace (e.g., “Team Documents”, “Client Files”)
      • Configure permissions and access controls

    6. Add Users

      • Navigate to “Users & Groups”
      • Click “Create User”
      • Enter user details (username, email, password)
      • Assign users to workspaces and groups

Getting Started with Pydio Cells

Creating Your First Workspace

    1. Access Admin Console

      Log in as administrator and navigate to the admin console.

    2. Create a New Workspace

      • Click “Cells” in the top navigation
      • Click “Create Cell” or “Create Workspace”
      • Enter workspace details:
        • Label: Display name (e.g., “Marketing Files”)
        • Description: Purpose of the workspace
        • Template: Choose from available templates

    3. Configure Access Permissions

      Set up granular access controls:

      • Read: Users can view and download files
      • Write: Users can upload and modify files
      • Delete: Users can remove files
      • Share: Users can share files externally

    4. Add Users to Workspace

      • Select users or groups to grant access
      • Assign appropriate permission levels
      • Save configuration

Uploading and Managing Files

    1. Upload Files

      • Open your workspace
      • Click “Upload” button or drag-and-drop files
      • Files are uploaded with versioning enabled automatically

    2. Organize with Folders

      • Create folder structure to organize content
      • Right-click folders for additional options
      • Use tags and metadata for better organization

    3. Share Files

      • Select a file or folder
      • Click “Share” button
      • Choose sharing method:
        • Internal: Share with other Cells users
        • Public Link: Generate shareable link
        • Secure Link: Password-protected links with expiration

    4. Collaborate on Documents

      • Enable collaborative editing for supported file types
      • View activity stream for file changes
      • Leave comments and annotations

Sample Use Cases

Team Document Repository

Create a centralized document repository with version control:

Workspace: "Company Documents"
├── HR/
│   ├── Policies/
│   ├── Employee Handbook/
│   └── Forms/
├── Finance/
│   ├── Budgets/
│   ├── Reports/
│   └── Invoices/
└── Marketing/
    ├── Brand Assets/
    ├── Campaigns/
    └── Content/

Permissions:

  • HR team: Full access to HR folder
  • Finance team: Full access to Finance folder
  • Marketing team: Full access to Marketing folder
  • Executives: Read access to all folders

Client Portal

Set up secure file sharing with external clients:

    1. Create Client Workspace

      Create a workspace per client or project.

    2. Set Up External Sharing

      • Enable public links with password protection
      • Set link expiration dates
      • Require email verification for downloads

    3. Monitor Access

      • View activity logs for client file access
      • Track downloads and modifications
      • Receive notifications for important events

Custom Domain Configuration

To use your own domain with Pydio Cells on Klutch.sh:

    1. Add Domain in Dashboard

      • Navigate to your Cells app in Klutch.sh dashboard
      • Go to “Domains” section
      • Click “Add Custom Domain”
      • Enter your domain (e.g., files.yourdomain.com)

    2. Configure DNS Records

      Add a CNAME record in your DNS provider:

      Type: CNAME
      Name: files (or your subdomain)
      Value: your-cells-app.klutch.sh
      TTL: 3600

    3. Enable SSL/TLS

      Klutch.sh automatically provisions and manages SSL certificates for your custom domain.

    4. Update Cells Configuration

      Update the CELLS_EXTERNAL environment variable:

      Terminal window
      CELLS_EXTERNAL=https://files.yourdomain.com
      CELLS_SITE_EXTERNAL=https://files.yourdomain.com

    5. Redeploy Application

      Trigger a new deployment for changes to take effect.

    6. Verify Configuration

      • Wait for DNS propagation (5-15 minutes)
      • Visit https://files.yourdomain.com
      • Verify SSL certificate is active

For detailed domain configuration, see the Klutch.sh Custom Domains guide.

Production Best Practices

Security Hardening

    1. Use Strong Passwords

      • Enforce password complexity requirements
      • Enable multi-factor authentication (MFA)
      • Regularly rotate admin passwords

    2. Configure SSL/TLS Properly

      Klutch.sh provides automatic SSL. Ensure all connections use HTTPS:

      Terminal window
      CELLS_NO_TLS=true  # Klutch.sh handles SSL termination

    3. Enable Audit Logging

      Track all user activities and file operations:

      • Navigate to Admin Console → Logs
      • Enable audit logging
      • Configure log retention policies

    4. Implement Access Controls

      • Use role-based access control (RBAC)
      • Apply principle of least privilege
      • Regularly review and audit permissions

    5. Secure Database Connections

      Always use strong credentials and encrypted connections for external databases.

    6. Regular Security Updates

      Update your Dockerfile to use specific Cells versions:

      FROM pydio/cells:4.2.0

      Regularly update to newer stable versions and redeploy.

Performance Optimization

    1. Enable Caching

      Configure caching for better performance:

      • Enable browser caching for static assets
      • Use CDN for file delivery (if available)
      • Configure appropriate cache headers

    2. Optimize Database Performance

      • Use connection pooling
      • Add indexes for frequently queried fields
      • Regular database maintenance and optimization

    3. Monitor Resource Usage

      • Track CPU, memory, and disk usage in Klutch.sh dashboard
      • Set up alerts for resource thresholds
      • Scale vertically if needed (larger instance)

    4. Optimize File Storage

      • Implement file lifecycle policies
      • Archive old files to cold storage
      • Clean up temporary and deleted files regularly

    5. Enable Search Indexing

      Cells includes built-in search. Ensure indexing is working properly:

      • Verify search service is running
      • Monitor index size and update frequency
      • Optimize index settings for your use case

Backup and Disaster Recovery

    1. Automated Volume Snapshots

      Schedule regular snapshots of the /var/cells persistent volume.

    2. Database Backups

      Implement automated database backup schedule:

      Terminal window
      # Daily backup script
      mysqldump -h mysql-host -P 8000 -u cells_user -p cells > cells-backup-$(date +%Y%m%d).sql
      tar -czf cells-complete-backup-$(date +%Y%m%d).tar.gz cells-backup-*.sql /backups/files

    3. File System Backups

      Backup the data directory regularly:

      Terminal window
      # Incremental backup using rsync
      rsync -avz /var/cells/data/ /backup/cells-data/

    4. Test Recovery Procedures

      Regularly test restoring from backups to ensure they work correctly.

    5. Off-site Backups

      Store backups in a different geographic location using cloud storage services.

Monitoring and Logging

    1. Enable Application Logs

      Configure comprehensive logging:

      Terminal window
      CELLS_LOG_LEVEL=info

      Access logs from the persistent volume:

      Terminal window
      /var/cells/logs/

    2. Set Up Alerts

      Configure alerts for:

      • Application downtime
      • High error rates
      • Storage capacity warnings
      • Failed authentication attempts
      • Unusual file access patterns

    3. Monitor User Activity

      • Enable audit logging for compliance
      • Track file access and modifications
      • Review user activity reports regularly

    4. Performance Monitoring

      • Monitor response times
      • Track file upload/download speeds
      • Identify slow database queries
      • Watch for resource bottlenecks

Troubleshooting Common Issues

Application Won’t Start

Symptoms: Container starts but Cells UI is not accessible

Solutions:

    1. Check deployment logs in the Klutch.sh dashboard
    2. Verify all required environment variables are set correctly
    3. Ensure persistent volume is attached to /var/cells
    4. Check database connectivity if using external database
    5. Verify port 8080 is correctly configured

Database Connection Errors

Symptoms: “Unable to connect to database” errors

Solutions:

    1. Verify connection string format:

      • MySQL: user:pass@tcp(host:8000)/cells?parseTime=true
      • PostgreSQL: postgresql://user:pass@host:8000/cells?sslmode=disable

    2. Confirm TCP port configuration (use 8000 for Klutch.sh TCP traffic)

    3. Test database credentials and connectivity

    4. Ensure database service is running and accessible

    5. Check firewall rules and network connectivity

File Upload Issues

Symptoms: Files fail to upload or uploads are very slow

Solutions:

    1. Check persistent volume storage capacity
    2. Verify file size limits in configuration
    3. Monitor network bandwidth and latency
    4. Check application logs for specific errors
    5. Ensure proper file system permissions in /var/cells/data

Login Problems

Symptoms: Cannot log in to Cells

Solutions:

    1. Verify admin password is correctly set via CELLS_ADMIN_PWD
    2. Check if database contains user accounts
    3. Review authentication logs for errors
    4. Clear browser cache and cookies
    5. Try password reset via admin console

Slow Performance

Symptoms: Slow page loads, timeouts

Solutions:

    1. Check resource usage in Klutch.sh dashboard
    2. Upgrade to larger instance if CPU/memory constrained
    3. Optimize database queries and add indexes
    4. Enable caching mechanisms
    5. Review and optimize search indexes
    6. Check for disk I/O bottlenecks

Data Loss After Redeployment

Symptoms: Files or configurations missing after redeployment

Solutions:

    1. Critical: Verify persistent volume is correctly attached to /var/cells
    2. Check volume wasn’t accidentally deleted or detached
    3. Review volume mount configuration in Klutch.sh dashboard
    4. Restore from backup if data is permanently lost

Scaling Your Pydio Cells Deployment

Vertical Scaling

Increase resources for your Cells instance:

  • Small teams (< 20 users): 2 CPU, 4GB RAM, 50GB storage
  • Medium teams (20-100 users): 4 CPU, 8GB RAM, 200GB storage
  • Large organizations (100-500 users): 8 CPU, 16GB RAM, 500GB+ storage
  • Enterprise (500+ users): 16+ CPU, 32+ GB RAM, 1TB+ storage

Upgrade instance size through the Klutch.sh dashboard as your needs grow.

Database Scaling

  • Use managed MySQL or PostgreSQL with read replicas
  • Enable database connection pooling
  • Optimize database configuration for your workload
  • Consider database sharding for very large deployments

Storage Optimization

  • Implement file lifecycle policies to archive old files
  • Use object storage for cold data
  • Enable deduplication to save space
  • Regular cleanup of temporary files

Advanced Features

LDAP/Active Directory Integration

Integrate with existing directory services:

    1. Configure LDAP Connection

      Set environment variables:

      Terminal window
      CELLS_AUTH_CONNECTOR=ldap
      CELLS_LDAP_URL=ldap://ldap.example.com:389
      CELLS_LDAP_BIND_DN=cn=admin,dc=example,dc=com
      CELLS_LDAP_BIND_PASSWORD=ldap-password
      CELLS_LDAP_USER_BASE=ou=users,dc=example,dc=com

    2. Map LDAP Attributes

      Configure attribute mappings in the Cells admin console.

    3. Test Authentication

      Verify users can log in with LDAP credentials.

OAuth2/SSO Integration

Enable single sign-on with popular providers:

  • Google Workspace
  • Microsoft Azure AD
  • GitHub
  • Custom OAuth2 providers

Configure OAuth2 settings in the Cells admin console under Authentication.

Mobile and Desktop Sync

Pydio Cells provides native sync clients:

  • Download Cells Sync for Windows, macOS, and Linux
  • Mobile apps available for iOS and Android
  • Configure sync client with your Cells URL: https://example-app.klutch.sh

Migration to Klutch.sh

If migrating from an existing Pydio Cells installation:

    1. Backup Existing Data

      From your current installation:

      Terminal window
      # Backup database
      mysqldump -u cells_user -p cells > cells-migration-backup.sql
      

      # Backup files
      tar -czf cells-files-backup.tar.gz /var/cells/data

    2. Deploy New Instance on Klutch.sh

      Follow the deployment steps in this guide.

    3. Restore Database

      Import your database to the new MySQL instance:

      Terminal window
      mysql -h your-mysql-app.klutch.sh -P 8000 -u cells_user -p cells < cells-migration-backup.sql

    4. Restore Files

      Upload your files to the persistent volume:

      Terminal window
      # Extract to mounted volume
      tar -xzf cells-files-backup.tar.gz -C /var/cells/

    5. Update Configuration

      Update CELLS_EXTERNAL to point to your new Klutch.sh URL.

    6. Test Thoroughly

      • Verify all files are accessible
      • Test user authentication
      • Check workspace permissions
      • Validate sharing links

    7. Update DNS

      Point your domain to the new Klutch.sh deployment.

Cost Optimization

  • Right-size instances: Start with smaller instances and scale based on actual usage
  • Storage lifecycle: Archive infrequently accessed files to cold storage
  • Database optimization: Regularly optimize and clean up database
  • Monitor usage: Track storage consumption and user activity
  • Cleanup policies: Implement automatic cleanup of temporary and deleted files

Resources

Conclusion

Deploying Pydio Cells on Klutch.sh provides a powerful, self-hosted file sharing and collaboration platform with enterprise-grade security, scalability, and control. With automatic Dockerfile detection, persistent storage, secure environment management, and production-ready configurations, you can focus on managing your content and collaborating with your team without worrying about infrastructure complexity.

Whether you’re building a secure document repository for your team, a client file sharing portal, or an enterprise content management system, Pydio Cells on Klutch.sh offers the reliability, performance, and flexibility you need. Start deploying your file sharing platform today and take control of your data with self-hosted, open-source collaboration tools.

For additional help or questions, reach out to the Pydio community forum or Klutch.sh support.