Pydio Cells is a modern, open-source file sharing and synchronization platform built on a microservices architecture in Go. It gives teams a self-hosted alternative to cloud storage services like Dropbox or Google Drive – with full control over data, fine-grained access policies, and built-in collaboration tools.
This guide walks through installing Pydio Cells v4.4.17 on RHEL 10 or Rocky Linux 10 with MariaDB, Nginx reverse proxy, and Let’s Encrypt SSL. By the end, you will have a production-ready file sharing server accessible over HTTPS.
Prerequisites
Before starting, make sure you have the following in place:
- A server running RHEL 10 or Rocky Linux 10 with at least 4GB RAM and 2 CPU cores
- Root or sudo access to the server
- A registered domain name (e.g.
cells.example.com) pointing to your server IP - Ports 80 and 443 open for HTTP/HTTPS traffic
- Port 8080 open internally for the Pydio Cells application
Step 1: Install MariaDB Database Server
Pydio Cells uses MariaDB (or MySQL) as its backend database. Install MariaDB from the default RHEL 10 / Rocky Linux 10 repositories. If you need a specific version, see our guide on how to install MariaDB 11.4 LTS on Rocky Linux 10 / AlmaLinux 10.
sudo dnf install mariadb-server -yStart and enable the MariaDB service so it runs on boot:
sudo systemctl enable --now mariadbVerify MariaDB is running:
systemctl status mariadbThe service should show active (running). Run the security hardening script to set a root password and remove test databases:
sudo mariadb-secure-installationAnswer the prompts: set a strong root password, remove anonymous users, disable remote root login, and remove the test database.
Step 2: Create a Database for Pydio Cells
Pydio Cells requires a dedicated database with utf8mb4 character encoding. Connect to the MariaDB shell and create the database and user.
sudo mariadb -u root -pRun the following SQL statements to create the database, user, and grant privileges:
CREATE DATABASE cells DEFAULT CHARACTER SET utf8mb4 COLLATE utf8mb4_bin;
CREATE USER 'cells'@'localhost' IDENTIFIED BY 'StrongPassword123';
GRANT ALL PRIVILEGES ON cells.* TO 'cells'@'localhost';
FLUSH PRIVILEGES;
EXIT;Replace StrongPassword123 with a secure password of your choice. Keep this password handy – you will need it during the Pydio Cells configuration step.
For production workloads, increase the MariaDB max_connections setting. Open the MariaDB configuration:
sudo vi /etc/my.cnf.d/cells.cnfAdd the following configuration to allow enough concurrent database connections:
[mysqld]
max_connections = 500Restart MariaDB to apply the change:
sudo systemctl restart mariadbStep 3: Download and Install Pydio Cells Binary
Pydio Cells ships as a single Go binary. Download the latest stable release (v4.4.17 at the time of writing) from the official GitHub releases page.
First, create a dedicated system user to run Pydio Cells. The application must not run as root:
sudo useradd -r -m -d /opt/cells -s /bin/bash cellsDownload the Pydio Cells binary and place it in the system path:
wget https://download.pydio.com/pub/cells/release/4.4.17/linux-amd64/cells -O /tmp/cells
sudo mv /tmp/cells /usr/local/bin/cells
sudo chmod +x /usr/local/bin/cellsVerify the binary is executable by checking the version:
cells versionThe command outputs the installed Pydio Cells version confirming the download was successful.
Create the data and log directories that Pydio Cells needs:
sudo mkdir -p /opt/cells/data /var/log/cells
sudo chown -R cells:cells /opt/cells /var/log/cellsSet the open file limit for the cells user. Pydio Cells requires at least 8192 open file descriptors in production:
sudo vi /etc/security/limits.d/cells.confAdd these lines to raise the file descriptor limits:
cells soft nofile 8192
cells hard nofile 16384Step 4: Run Pydio Cells Configuration Wizard
Pydio Cells has an interactive configuration wizard that sets up the database connection, data directories, and admin account. Switch to the cells user and run the configuration:
sudo -u cells bash
export CELLS_WORKING_DIR=/opt/cells
cells configureThe wizard prompts you for:
- Bind Address – set to
0.0.0.0:8080to listen on all interfaces - External URL – your full domain URL, e.g.
https://cells.example.com - Database connection – select MySQL/MariaDB, enter
cells:StrongPassword123@tcp(localhost:3306)/cells - Admin username and password – create your initial admin account
After the wizard completes, exit the cells user shell:
exitStep 5: Create a Systemd Service for Pydio Cells
Running Pydio Cells as a systemd service ensures it starts automatically on boot and can be managed with standard systemctl commands. Create the service file:
sudo vi /etc/systemd/system/cells.serviceAdd the following service configuration:
[Unit]
Description=Pydio Cells File Sharing Platform
Documentation=https://pydio.com
After=network.target mariadb.service
Requires=mariadb.service
[Service]
User=cells
Group=cells
Type=idle
WorkingDirectory=/opt/cells
Environment=CELLS_WORKING_DIR=/opt/cells
ExecStart=/usr/local/bin/cells start
ExecStop=/usr/local/bin/cells stop
Restart=on-failure
RestartSec=10
StandardOutput=journal
StandardError=journal
LimitNOFILE=16384
[Install]
WantedBy=multi-user.targetReload systemd, then enable and start the Pydio Cells service:
sudo systemctl daemon-reload
sudo systemctl enable --now cellsVerify the service started correctly:
systemctl status cellsThe service should show active (running). If it fails, check the logs for errors:
journalctl -u cells -fStep 6: Configure Firewall Rules for Pydio Cells
RHEL 10 and Rocky Linux 10 use firewalld as the default firewall manager. Open ports 80 (HTTP), 443 (HTTPS), and 8080 (Pydio Cells direct access) through the firewall.
sudo firewall-cmd --permanent --add-service=http
sudo firewall-cmd --permanent --add-service=https
sudo firewall-cmd --permanent --add-port=8080/tcp
sudo firewall-cmd --reloadConfirm the rules are active:
sudo firewall-cmd --list-allYou should see http, https, and 8080/tcp listed under services and ports. At this point, Pydio Cells is accessible directly at http://your-server-ip:8080. The next steps set up Nginx as a reverse proxy and add SSL encryption.
Step 7: Set Up Nginx Reverse Proxy
Nginx acts as a reverse proxy, forwarding HTTPS traffic to Pydio Cells running on port 8080. This is the recommended production setup. Install Nginx from the system repositories:
sudo dnf install nginx -yCreate a virtual host configuration for Pydio Cells:
sudo vi /etc/nginx/conf.d/cells.confAdd the following Nginx configuration. Replace cells.example.com with your actual domain name:
server {
listen 80;
server_name cells.example.com;
client_max_body_size 0;
proxy_request_buffering off;
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 client_max_body_size 0 directive disables the upload size limit on the Nginx side, letting Pydio Cells handle file size restrictions. The WebSocket location block at /ws/ is required for real-time features like file sync notifications.
Test the Nginx configuration for syntax errors and start the service:
sudo nginx -t
sudo systemctl enable --now nginxIf you already have Nginx running with other virtual hosts, reload instead of restart to avoid downtime. For a detailed Nginx setup, check our guide on installing WordPress with Nginx on Rocky Linux 10.
Step 8: Secure Pydio Cells with Let’s Encrypt SSL
Encrypt traffic to your Pydio Cells instance with a free SSL certificate from Let’s Encrypt. Install Certbot and the Nginx plugin:
sudo dnf install certbot python3-certbot-nginx -yRequest the SSL certificate. Certbot automatically modifies your Nginx configuration to serve traffic over HTTPS:
sudo certbot --nginx -d cells.example.comFollow the prompts: enter your email, agree to the terms, and choose whether to redirect HTTP to HTTPS (recommended). After completion, Certbot updates your Nginx config with SSL directives and sets up automatic certificate renewal.
Verify the renewal timer is active:
sudo systemctl status certbot-renew.timerThe timer should be active and enabled. Certificates renew automatically before expiration. Test the renewal process with a dry run:
sudo certbot renew --dry-runYour Pydio Cells instance is now accessible at https://cells.example.com with valid SSL encryption.
Step 9: Create Users and Workspaces in Pydio Cells
Open your browser and navigate to https://cells.example.com. Log in with the admin credentials you created during the configuration wizard.
To create a new user, go to Cells Console (admin dashboard) and navigate to Identity Management > Users. Click the + User button and fill in the username, email, and password for the new account.
Workspaces define shared folders and access policies. Navigate to Data Management > Workspaces and click + Workspace. Give the workspace a name and select which data source (folder path) it maps to. You can then assign users or groups with read, write, or admin permissions on that workspace.
Key features to explore after the initial setup:
- Cells – create shared spaces with granular per-user permissions
- Public Links – share files or folders with external users via password-protected links
- Activity Tracking – monitor file uploads, downloads, and modifications
- Desktop Sync – install the Pydio Cells Sync client on workstations for automatic file synchronization
Conclusion
You now have Pydio Cells running on RHEL 10 / Rocky Linux 10 behind Nginx with Let’s Encrypt SSL. The setup includes MariaDB as the database backend, a systemd service for automatic startup, and firewall rules for secure access.
For a production environment, consider setting up regular database backups, configuring log rotation for /var/log/cells/, and enabling SELinux policies for the cells service. Monitor disk usage on the data directory as file uploads grow over time.