Skip to content
Klutch.sh Docs

Deploying Pydio Cells

Introduction

Pydio Cells is an open-source, enterprise-grade file sharing and synchronization platform. It’s designed to help organizations securely manage, share, and collaborate on files while maintaining complete control over their data. Pydio Cells combines the simplicity of consumer cloud storage with the security and compliance features enterprises require.

Built with Go and React, Pydio Cells offers exceptional performance and a modern user experience. Its microservices architecture allows for flexible deployment and horizontal scaling to accommodate organizations of any size.

Key highlights of Pydio Cells:

  • Secure File Sharing: Share files with granular permissions and expiration dates
  • Real-Time Collaboration: Edit documents simultaneously with team members
  • Advanced Access Control: Role-based permissions and security policies
  • Audit Logging: Complete audit trail for compliance
  • Workflow Automation: Automate file processing and approvals
  • Desktop Sync: Native sync clients for Windows, Mac, and Linux
  • Mobile Apps: iOS and Android apps for mobile access
  • S3 Compatible: Works with any S3-compatible storage
  • LDAP/SSO Integration: Enterprise identity management
  • Open Source: Licensed under AGPL-3.0

This guide walks through deploying Pydio Cells on Klutch.sh using Docker.

Why Deploy Pydio Cells on Klutch.sh

Deploying Pydio Cells on Klutch.sh provides several advantages:

Simplified Deployment: Klutch.sh automatically detects your Dockerfile and builds Pydio Cells without complex configuration.

Persistent Storage: Attach persistent volumes for file storage and database.

HTTPS by Default: Klutch.sh provides automatic SSL certificates for secure access.

GitHub Integration: Connect your repository directly from GitHub for automatic deployments.

Scalable Resources: Allocate CPU and memory based on user count and file volume.

Custom Domains: Assign a custom domain for your file sharing platform.

Prerequisites

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

  • A Klutch.sh account
  • A GitHub account with a repository for your Pydio Cells configuration
  • A MySQL or MariaDB database
  • Basic familiarity with Docker and containerization concepts
  • (Optional) A custom domain for your Pydio Cells instance
  • (Optional) S3-compatible storage for scalable file storage

Understanding Pydio Cells Architecture

Pydio Cells uses a microservices architecture:

Gateway: Handles HTTP/HTTPS traffic and routing.

Microservices: Specialized services for auth, data, scheduler, etc.

Data Sources: Configurable storage backends (local, S3, etc.).

Database: MySQL/MariaDB for metadata and configuration.

Message Broker: NATS for internal service communication.

Preparing Your Repository

Create a GitHub repository containing your Dockerfile for Pydio Cells deployment.

Repository Structure

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

Creating the Dockerfile

Create a Dockerfile in the root of your repository:

FROM pydio/cells:latest


# Set environment variables
ENV CELLS_EXTERNAL=${EXTERNAL_URL}
ENV CELLS_BIND=0.0.0.0:8080


# Create data directory
RUN mkdir -p /var/cells /var/cells/data


EXPOSE 8080


CMD ["cells", "start"]

Creating the .dockerignore File

Create a .dockerignore file:

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

Deploying Pydio Cells on Klutch.sh

    Push Your Repository to GitHub

    Initialize your repository and push to GitHub:

    Terminal window
    git init
    git add Dockerfile .dockerignore
    git commit -m "Initial Pydio Cells deployment configuration"
    git remote add origin https://github.com/yourusername/pydio-deploy.git
    git push -u origin main

    Create a New Project on Klutch.sh

    Navigate to the Klutch.sh dashboard and create a new project. Give it a descriptive name like “pydio” or “file-sharing”.

    Create a New App

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

    Configure HTTP Traffic

    In the deployment settings:

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

    Set Environment Variables

    Add the following environment variables:

    VariableValue
    CELLS_EXTERNALhttps://your-app-name.klutch.sh
    CELLS_BIND0.0.0.0:8080
    CELLS_DB_HOSTYour database host
    CELLS_DB_NAMEcells
    CELLS_DB_USERYour database user
    CELLS_DB_PASSWORDYour database password

    Attach Persistent Volumes

    Add the following volumes:

    Mount PathRecommended SizePurpose
    /var/cells10 GBConfiguration and cache
    /var/cells/data500+ GBFile storage

    Deploy Your Application

    Click Deploy to start the build process. Klutch.sh will:

    • Detect your Dockerfile automatically
    • Build the container image
    • Attach the persistent volumes
    • Start the Pydio Cells container
    • Provision an HTTPS certificate

    Complete Installation

    Access your Pydio Cells instance at https://your-app-name.klutch.sh and follow the installation wizard:

    1. Accept license agreement
    2. Configure database connection
    3. Create admin account
    4. Set up initial workspace

    Access Pydio Cells

    Log in with your admin credentials to start managing files and users.

Initial Configuration

Creating Workspaces

Workspaces organize files and access:

  1. Go to Cells Console > Workspaces
  2. Click “Create Workspace”
  3. Select data source
  4. Configure access policies
  5. Save workspace

Adding Users

  1. Go to Cells Console > Users
  2. Click “Add User”
  3. Enter user details
  4. Assign roles and workspaces
  5. Send invitation email

Configuring Data Sources

Connect additional storage:

  1. Go to Cells Console > Data Sources
  2. Click “Add Datasource”
  3. Select type (Local, S3, etc.)
  4. Configure connection
  5. Create workspace from source

File Sharing

Internal Sharing

Share files with team members:

  1. Right-click file or folder
  2. Select “Share”
  3. Add users or groups
  4. Set permissions (view, edit, download)
  5. Send notification

External Sharing

Share with external users via links:

  1. Right-click file or folder
  2. Select “Public Link”
  3. Configure options:
    • Password protection
    • Expiration date
    • Download limit
    • Permissions
  4. Copy and share link

Share Permissions

PermissionDescription
PreviewView files in browser
DownloadDownload files
UploadAdd files to folder
EditModify files
DeleteRemove files

Collaboration Features

Real-Time Editing

Collaborate on documents:

  1. Open a compatible file
  2. Click “Open in Editor”
  3. Multiple users can edit simultaneously
  4. Changes sync in real-time

Comments and Metadata

Add context to files:

  1. Select a file
  2. Open info panel
  3. Add comments
  4. Set custom metadata

Activity Feed

Track file activity:

  1. View workspace activity feed
  2. See who accessed what
  3. Monitor changes over time

Security Configuration

Access Policies

Create security policies:

  1. Go to Cells Console > Security Policies
  2. Define conditions and rules
  3. Apply to workspaces or users

Audit Logs

Monitor activity:

  1. Go to Cells Console > Audit
  2. Filter by user, action, or date
  3. Export logs for compliance

Encryption

Configure encryption at rest:

  1. Go to Cells Console > Encryption
  2. Enable master encryption
  3. Configure key management

Desktop Sync

Installing Sync Client

Download from Pydio Downloads.

Configuring Sync

  1. Install sync client
  2. Enter server URL
  3. Authenticate
  4. Select workspaces to sync
  5. Choose local folder

Sync Settings

OptionDescription
Selective SyncChoose specific folders
Conflict ResolutionHandle sync conflicts
Bandwidth LimitsControl sync speed

Troubleshooting Common Issues

Cannot Access Files

Solutions:

  • Verify workspace permissions
  • Check data source connectivity
  • Review access policies

Sync Not Working

Solutions:

  • Check network connectivity
  • Verify credentials
  • Review sync logs

Performance Issues

Solutions:

  • Increase allocated resources
  • Optimize database
  • Enable caching

Additional Resources

Conclusion

Deploying Pydio Cells on Klutch.sh gives you an enterprise-grade file sharing platform with the flexibility of self-hosting. With advanced access controls, real-time collaboration, and comprehensive audit logging, Pydio Cells provides the security and features organizations need for professional file management.

Whether you’re a small team needing secure file sharing or an enterprise requiring compliance-ready document management, Pydio Cells on Klutch.sh delivers a powerful, customizable solution.