Storage

Install Pydio Cells File Sharing on Ubuntu 24.04

Josphat Mutai Updated Mar 22, 2026 · 7 min read

Pydio Cells is a modern, open-source file sharing and synchronization platform built on a microservices architecture. It replaces the older Pydio 8 (now end-of-life) and provides document management, file sharing, collaboration workspaces, and fine-grained access controls – all through a clean web interface. Written in Go, Cells is fast and resource-efficient compared to PHP-based alternatives.

Original content from computingforgeeks.com - post 5261

This guide walks through installing Pydio Cells on Ubuntu 24.04 LTS with MariaDB as the database backend, Nginx as a reverse proxy, and Let’s Encrypt for SSL. By the end, you will have a production-ready file sharing server with HTTPS access and proper systemd management.

Prerequisites

  • A server running Ubuntu 24.04 LTS with at least 4 GB RAM and 2 CPU cores
  • Root or sudo access
  • A domain name pointed to your server IP (used throughout as cells.example.com)
  • Ports 80 and 443 open for HTTP/HTTPS traffic
  • At least 20 GB of available disk space for files and database

Step 1: Install Dependencies

Pydio Cells needs a MySQL-compatible database. MariaDB is the recommended choice on Ubuntu. Install it along with other required packages.

Update the package index and install dependencies:

sudo apt update && sudo apt install -y mariadb-server wget curl

Verify that MariaDB is running:

systemctl status mariadb

The output should show the service as active and running:

● mariadb.service - MariaDB 10.11.8 database server
     Loaded: loaded (/usr/lib/systemd/system/mariadb.service; enabled; preset: enabled)
     Active: active (running)

Secure the MariaDB installation by setting a root password and removing test databases:

sudo mariadb-secure-installation

Accept the defaults and set a strong root password when prompted. Answer Y to remove anonymous users, disallow remote root login, and remove the test database.

Step 2: Create Pydio Cells Database

Cells stores metadata, user accounts, and workspace configuration in a MySQL/MariaDB database. Create a dedicated database and user for it.

Log into the MariaDB shell:

sudo mariadb -u root -p

Run the following SQL commands to create the database and grant privileges:

CREATE DATABASE cellsdb CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;
CREATE USER 'cellsuser'@'localhost' IDENTIFIED BY 'StrongPassword123!';
GRANT ALL PRIVILEGES ON cellsdb.* TO 'cellsuser'@'localhost';
FLUSH PRIVILEGES;
EXIT;

Replace StrongPassword123! with a secure password of your choice. Keep these credentials handy – you will need them during the Cells configuration step.

Step 3: Download Pydio Cells Binary

Pydio Cells ships as a single Go binary – no PHP, no Composer, no runtime dependencies. Download the latest stable release directly from the official Pydio repository.

Create a dedicated system user and the required directories:

sudo useradd -m -s /bin/bash pydio
sudo mkdir -p /opt/pydio/bin /var/cells
sudo chown -R pydio:pydio /opt/pydio /var/cells

Download the Cells binary:

sudo wget -O /opt/pydio/bin/cells https://download.pydio.com/latest/cells/release/{latest}/linux-amd64/cells
sudo chmod +x /opt/pydio/bin/cells

Allow the binary to bind to privileged ports (80, 443) without running as root:

sudo setcap 'cap_net_bind_service=+ep' /opt/pydio/bin/cells

Create a symlink so the cells command is available system-wide:

sudo ln -s /opt/pydio/bin/cells /usr/local/bin/cells

Verify the binary works by checking the version:

cells version

You should see output showing the installed Pydio Cells version:

Pydio Cells Home Edition
  Version:       4.4.17
  Built:         2025-01-08T00:00:00
  Git commit:    ...

Step 4: Run Initial Setup with Cells Configure

Pydio Cells uses an interactive CLI wizard to configure the database connection, admin account, and server binding. Set the required environment variables first.

Create an environment file that Cells will use:

sudo vi /etc/profile.d/cells-env.sh

Add the following environment variables. Replace cells.example.com with your actual domain:

export CELLS_WORKING_DIR=/var/cells
export CELLS_BIND=127.0.0.1:8080
export CELLS_EXTERNAL=https://cells.example.com

Load the variables and switch to the pydio user:

source /etc/profile.d/cells-env.sh
sudo -u pydio -E bash

Run the configuration wizard:

cells configure

The wizard prompts you for:

  • Database connection – select TCP, enter 127.0.0.1, port 3306, database name cellsdb, user cellsuser, and the password you set earlier
  • Admin credentials – create the initial admin username and password
  • Advanced settings – accept defaults unless you have specific storage requirements

Once configuration completes, exit the pydio user shell:

exit

Step 5: Configure Pydio Cells as a Systemd Service

Running Cells as a systemd service ensures it starts automatically on boot and restarts on failure. Create a unit file for it.

Create the service file:

sudo vi /etc/systemd/system/cells.service

Add the following configuration:

[Unit]
Description=Pydio Cells File Sharing
Documentation=https://pydio.com
After=network-online.target mariadb.service
Wants=network-online.target
AssertFileIsExecutable=/opt/pydio/bin/cells

[Service]
User=pydio
Group=pydio
WorkingDirectory=/var/cells
PermissionsStartOnly=true

ExecStart=/opt/pydio/bin/cells start
Restart=on-failure
RestartSec=5

Environment=CELLS_WORKING_DIR=/var/cells
Environment=CELLS_BIND=127.0.0.1:8080
Environment=CELLS_EXTERNAL=https://cells.example.com

StandardOutput=journal
StandardError=journal
LimitNOFILE=65536

[Install]
WantedBy=multi-user.target

Replace cells.example.com with your actual domain name. Enable and start the service:

sudo systemctl daemon-reload
sudo systemctl enable --now cells

Check that the service started successfully:

systemctl status cells

The output should confirm the service is active:

● cells.service - Pydio Cells File Sharing
     Loaded: loaded (/etc/systemd/system/cells.service; enabled; preset: disabled)
     Active: active (running)
     Main PID: 12345 (cells)
     CGroup: /system.slice/cells.service

Step 6: Access the Pydio Cells Web Interface

With Cells running on port 8080, you can test local access before setting up the reverse proxy. Use curl from the server itself to confirm it responds:

curl -sI http://127.0.0.1:8080

A successful response returns HTTP 200 or a redirect to the login page:

HTTP/1.1 200 OK
Content-Type: text/html; charset=utf-8

At this point, Cells is listening on localhost only. The next steps configure Nginx to proxy external traffic to it with SSL termination.

Step 7: Configure Nginx Reverse Proxy for Pydio Cells

Nginx handles SSL termination and proxies requests to the Cells backend. This is the recommended production setup – it keeps Cells running as an unprivileged user while Nginx handles TLS and client connections.

Install Nginx:

sudo apt install -y nginx

Create a new server block for Pydio Cells:

sudo vi /etc/nginx/sites-available/cells.conf

Add the following configuration. Replace cells.example.com with your domain:

server {
    listen 80;
    server_name cells.example.com;

    client_max_body_size 200M;

    location / {
        proxy_pass http://127.0.0.1:8080;
        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;
    }

    location /ws/ {
        proxy_pass http://127.0.0.1:8080;
        proxy_http_version 1.1;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
        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;
        proxy_read_timeout 86400;
    }
}

The /ws/ location block handles WebSocket connections that Cells uses for real-time updates. The client_max_body_size directive allows file uploads up to 200 MB – adjust this based on your needs.

Enable the site and test the configuration:

sudo ln -s /etc/nginx/sites-available/cells.conf /etc/nginx/sites-enabled/
sudo nginx -t

If the syntax test passes, restart Nginx:

sudo systemctl restart nginx

Step 8: Configure SSL with Let’s Encrypt

Production file sharing must use HTTPS. Certbot automates Let’s Encrypt certificate issuance and automatically modifies the Nginx configuration to enable SSL.

Install Certbot and the Nginx plugin:

sudo apt install -y certbot python3-certbot-nginx

Request a certificate for your domain. Replace cells.example.com with your actual domain and provide a valid email for renewal notifications:

sudo certbot --nginx -d cells.example.com --agree-tos -m [email protected]

Certbot obtains the certificate, updates the Nginx config to redirect HTTP to HTTPS, and sets up automatic renewal via a systemd timer. Verify the timer is active:

systemctl status certbot.timer

The timer should show as active, handling automatic renewals before certificates expire:

● certbot.timer - Run certbot twice daily
     Loaded: loaded (/usr/lib/systemd/system/certbot.timer; enabled; preset: enabled)
     Active: active (waiting)

Test that renewal works without issues:

sudo certbot renew --dry-run

Step 9: Configure Firewall

If UFW is active on your server, allow HTTP, HTTPS, and SSH traffic. Port 8080 does not need to be opened externally since Nginx proxies to it on localhost.

sudo ufw allow OpenSSH
sudo ufw allow 'Nginx Full'
sudo ufw enable

Verify the rules are applied:

sudo ufw status

The output should list the allowed services:

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
Nginx Full                 ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
Nginx Full (v6)            ALLOW       Anywhere (v6)

Step 10: Create Users and Workspaces

Open your browser and navigate to https://cells.example.com. Log in with the admin credentials you created during the cells configure step.

To create additional users:

  • Go to Cells Console (admin panel) from the top-right menu
  • Navigate to Identity Management > People
  • Click the + button to add new users
  • Assign each user a login, display name, and password

To create shared workspaces:

  • Navigate to Data Management > Workspaces
  • Click + Workspace and give it a name
  • Assign the root path and select which data source to use
  • Set permissions – choose which users or groups can read, write, or manage files in the workspace

Workspaces are how Cells organizes shared folders. Each workspace can have different access policies, making it straightforward to set up team folders, project shares, or public upload areas. Users can also share individual files and folders via links, similar to how Nextcloud and Seafile handle sharing.

Conclusion

You now have Pydio Cells running on Ubuntu 24.04 behind Nginx with Let’s Encrypt SSL. The setup includes MariaDB for metadata storage, systemd for process management, and a properly configured reverse proxy with WebSocket support.

For production hardening, consider enabling MariaDB automated backups, setting up monitoring for the Cells service, and configuring log rotation for /var/cells/logs. If your team grows beyond a handful of users, evaluate the Pydio Cells Enterprise edition for features like LDAP integration, audit logs, and advanced sharing policies.

Josphat Mutai

Founder of Computingforgeeks. Expertise in Virtualization, Cloud, Linux/UNIX Administration, Automation,Storage Systems, Containers, Server Clustering e.t.c.

Related Articles

Ubuntu Disable systemd-networkd on Ubuntu Linux Automation How to add Grafana Data Source using Ansible Debian Install Ajenti Control Panel on Debian 13/12 and Ubuntu 24.04 Ubuntu Install PHP 8.5 on Ubuntu 24.04 with Nginx and PHP-FPM

Press ESC to close