HowtoForge

So installierst du Pydio Cells unter Debian 12

von ·

Pydio Cells ist eine selbst gehostete Plattform für den Austausch und die Zusammenarbeit von Dokumenten. Sie gibt dir die volle Kontrolle über deine Dokumentenfreigabeumgebung. Pydio Cells ist schnell, kann große Datenmengen übertragen und bietet eine fortschrittliche Workflow-Automatisierung.

In der folgenden Anleitung führe ich dich durch die Installation von Pydio Cells als Tool für die gemeinsame Nutzung von Dateien und die Zusammenarbeit auf einem Debian 12-Server. Du wirst Pydio Cells mit dem MariaDB-Datenbankserver und dem Apache2-Reverse-Proxy installieren. Außerdem sicherst du die Installation mit SSL/TLS-Zertifikaten, die du über Certbot und Letsencrypt generierst.

Voraussetzungen

Bevor du fortfährst, solltest du Folgendes besorgen:

  • Einen Debian 12 Server.
  • Einen Nicht-Root-Benutzer mit Administrator-Rechten.
  • Einen Domainnamen, der auf die IP-Adresse des Servers zeigt.

Installieren der Abhängigkeiten

Pydio Cells ist eine Open-Source-Software für Dateifreigabe, -verwaltung und -zusammenarbeit. Bevor du es installierst, musst du Abhängigkeiten wie MariaDB für den Datenbankserver und Apache2 für den Reverse Proxy installieren. Außerdem installierst du Certbot, um SSL/TLS-Zertifikate zu generieren und deine Installation zu sichern.

Aktualisiere zunächst deinen Debian-Paketindex mit dem folgenden Befehl apt update.

sudo apt update

Installiere nun die Abhängigkeiten mit dem folgenden apt install Befehl. Du installierst den MariaDB Server, der als Datenbank für Pydio Cells verwendet wird, den Apache2 Webserver als Reverse Proxy und Certbot für die Erstellung von SSL/TLS-Zertifikaten von Letsencrypt.

sudo apt install mariadb-server apache2 certbot wget

Gib y ein, um die Installation zu bestätigen und drücke ENTER.

Abhängigkeiten installieren

Sobald die Abhängigkeiten installiert sind, überprüfe den apache2-Dienst mit dem folgenden systemctl-Befehl. Stelle sicher, dass der apache2-Dienst aktiviert ist und läuft.

sudo systemctl is-enabled apache2
sudo systemctl status apache2

Die folgende Ausgabe zeigt, dass apache2 aktiviert ist und läuft.

apache2 prüfen

Überprüfe zum Schluss den Mariadb-Dienst mit dem folgenden systemctl-Befehl.

sudo systemctl is-enabled mariadb
sudo systemctl status mariadb

Die Ausgabe sollte ähnlich sein, was bedeutet, dass der mariadb-Dienst läuft und aktiviert ist.

mariadb prüfen

MariaDB Server konfigurieren

Im folgenden Schritt sicherst du deine MariaDB Serverinstallation mit dem Dienstprogramm mariadb-secure-installation. Dann erstellst du eine neue Datenbank und einen neuen Benutzer für Pydio Cells.

Führe den Befehl mariadb-secure-installation aus, um den MariaDB-Server zu konfigurieren.

sudo mariadb-secure-installation

Während des Einrichtungsprozesses musst du Y eingeben, um die neuen Einstellungen zu bestätigen, oder n für no. Im Folgenden sind einige der MariaDB-Serverkonfigurationen aufgeführt, nach denen du gefragt wirst:

  • Lokale Authentifizierung auf unix_socket umstellen? Gib n ein.
  • Das neue MariaDB Root-Passwort einrichten? Bestätige mit y und gib dann das neue Kennwort für deinen MariaDB-Servereinsatz ein.
  • Anonymen Benutzer entfernen? Gib zur Bestätigung y ein.
  • Den Standard-Datenbanktest aus dem Einsatz entfernen? Gib zur Bestätigung y ein.
  • MariaDB Root-Login von Remote-Verbindungen verbieten? Gib zur Bestätigung y ein.
  • Tabellenberechtigungen neu laden und die Änderungen übernehmen? Gib y ein und drücke ENTER.

Nachdem die MariaDB gesichert ist, erstellst du eine neue Datenbank und einen neuen Benutzer für die Installation von Pydio Cells. Dazu musst du dich am MariaDB-Server anmelden.

Führe den folgenden mariadb-Befehl aus, um dich am MariaDB-Server anzumelden. Gib dein MariaDB-Root-Passwort ein, wenn du dazu aufgefordert wirst.

sudo mariadb -u root -p

Sobald du eingeloggt bist, führe die folgenden Abfragen aus, um eine neue Datenbankzelle zu erstellen, einen Benutzer pydio mit dem Passwort p4ssw0rd. Erlaube dann dem Benutzer pydio den Zugriff auf die Datenbankzellen.

CREATE DATABASE cells;
CREATE USER 'pydio'@'localhost' IDENTIFIED BY 'p4ssw0rd';
GRANT ALL PRIVILEGES ON cells.* to 'pydio'@'localhost';
FLUSH PRIVILEGES;

Datenbank und Benutzer anlegen

Führe anschließend die folgende Abfrage aus, um sicherzustellen, dass der Benutzer pydio auf die Datenbankzellen zugreifen kann.

SHOW GRANTS FOR 'pydio'@'localhost';

Die folgende Ausgabe zeigt dir, dass der Benutzer pydio die Berechtigung hat, auf die Datenbankzellen zuzugreifen und sie zu verwalten.

Zuschüsse prüfen

Gib quit ein, um den MariaDB-Server zu verlassen.

Pydio-Zellen installieren

Nachdem du den MariaDB Server konfiguriert hast, installierst du die Pydio Cells über eine statische Binärdatei. Zuvor musst du dein System vorbereiten, indem du einen neuen Benutzer anlegst, ein Datenverzeichnis einrichtest und einige Systemumgebungsvariablen erstellst, die von Pydio Cells benötigt werden.

Benutzer und Umgebungsvariablen einrichten

Erstelle zunächst mit dem folgenden Befehl einen neuen Benutzer pydio.

sudo useradd -m -s /bin/bash pydio

Erstelle nun ein neues Datenverzeichnis /var/cells für deine Pydio Cells-Installation und ändere den Besitzer auf den Benutzer pydio.

sudo mkdir -p /opt/pydio/bin /var/cells
sudo chown -R pydio: /opt/pydio /var/cells

Als Nächstes führst du den folgenden Befehl aus, um eine neue Umgebungsvariablen-Konfiguration /etc/profile.d/cellss-env.sh zu erstellen und änderst die Berechtigung auf 0755, um sie ausführbar zu machen. Die Umgebungsvariable CELLS_WORKING_DIR für das Datenverzeichnis, CELLS_BIND, um festzulegen, mit welcher IP-Adresse und welchem Port Pydio Cells läuft, und CELLS_EXTERNAL ist der Domänenname deiner Pydio Cells Installation.

sudo tee -a /etc/profile.d/cells-env.sh << EOF
export CELLS_WORKING_DIR=/var/cells
export CELLS_BIND=https://127.0.0.1:8080
export CELLS_EXTERNAL=https://cells.hwdomain.io
EOF
sudo chmod 0755 /etc/profile.d/cells-env.sh

Setup-System

Melde dich nun als Benutzer pydio an und überprüfe die Umgebungsvariablen CELLS_WORKING_DIR, CELLS_BIND und CELLS_EXTERNAL.

su - pydio
echo $CELLS_WORKING_DIR
echo $CELLS_BIND
echo $CELLS_EXTERNAL

Wenn du erfolgreich warst, solltest du sehen, dass jede Umgebungsvariable mit der Datei /etc/profile.d/cells-env.sh abgeglichen wird.

Prüfumgebung

Herunterladen und Installieren von Pydio Cells

Führe den folgenden Befehl aus, um die binäre statische Datei von Pydio Cells nach /opt/pydio/bin/cells herunterzuladen.

export distribId=cells
wget -O /opt/pydio/bin/cells https://download.pydio.com/latest/${distribId}/release/{latest}/linux-amd64/${distribId}

Sobald die Pydio Cells heruntergeladen sind, machst du sie mit dem folgenden Befehl ausführbar. Gib dann exit ein, um dich vom Benutzer pydio abzumelden.

chmod a+x /opt/pydio/bin/cells
exit

Führe nun den folgenden Befehl aus, damit sich Cells an die privilegierten Ports binden kann. Anschließend erstellst du einen Symlink für den Befehl /opt/pydio/bin/cells nach /usr/local/bin/cells.

sudo setcap 'cap_net_bind_service=+ep' /opt/pydio/bin/cells
sudo ln -s /opt/pydio/bin/cells /usr/local/bin/cells

Melde dich nun erneut als pydio-Benutzer an und überprüfe die Binärdatei von cells. Überprüfe dann deine aktuelle Cells-Version.

su - pydio
which cells
cells version

Du solltest sehen, dass sich die Cells-Binärdatei unter /usr/local/bin/cells befindet und die Cells-Version 4.2.5 installiert wurde.

Überprüfung der Pydio-Version

Pydio Cells konfigurieren

Nachdem du die Pydio Cells Binärdatei installiert hast, kannst du mit der Konfiguration beginnen, die über die Befehlszeilenschnittstelle (CLI) oder den Webbrowser erfolgen kann. In diesem Fall konfigurierst du Pydio Cells über das Kommandozeilenterminal, richtest die Datenbank ein, legst den Benutzer admin an und erstellst eine neue systemd-Dienstdatei, um Pydio Cells im Hintergrund laufen zu lassen.

Führe den folgenden cell-Befehl aus, um mit der Konfiguration der Pydio Cells-Installation zu beginnen. Mit dem Parameter –cli kannst du Pydio Cells über dein Terminal in einer interaktiven Umgebung konfigurieren.

cells configure --cli

Im Folgenden findest du einige Konfigurationen, nach denen du gefragt wirst:

  • Für die Datenbankkonfiguration wählst du via TCP und gibst den Datenbank-Host localhost, den Port mit der Voreinstellung 3306, den Datenbanknamen cells, den Benutzer pydio und das Passwort ein.
  • Gib n ein, wenn du nach der MongoDB-Konfiguration für die hochverfügbare Cells-Installation gefragt wirst.
  • Gib den neuen Admin-Benutzer und das Passwort für deine Pydio Cells-Installation ein.
  • Für die Speicherkonfiguration wählst du die Option /var/cells/data.

Wenn der Konfigurationsprozess abgeschlossen ist, solltest du eine Ausgabe wie die folgende erhalten: Installation Finished:

Zellen konfigurieren

Nachdem du nun Pydio Cells konfiguriert hast, richtest du im nächsten Schritt Cells so ein, dass es im Hintergrund als systemd-Dienst läuft. So kannst du Cells einfacher über das Dienstprogramm systemctl verwalten.

Verwende den folgenden Befehl des Editors nano, um eine neue systemd-Dienstdatei /etc/systemd/system/cells.service zu erstellen.

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

Füge die folgende Konfiguration ein und achte darauf, dass du einige Umgebungsvariablen CELLS_WORKING_DIR, CELLS_BIND und CELLS_EXTERNAL in der unten stehenden Konfiguration änderst.

[Unit]
Description=Pydio Cells
Documentation=https://pydio.com
Wants=network-online.target
After=network-online.target
AssertFileIsExecutable=/opt/pydio/bin/cells
[Service]
User=pydio
Group=pydio
PermissionsStartOnly=true
AmbientCapabilities=CAP_NET_BIND_SERVICE
ExecStart=/opt/pydio/bin/cells start
Restart=on-failure
StandardOutput=journal
StandardError=inherit
LimitNOFILE=65536
TimeoutStopSec=5
KillSignal=INT
SendSIGKILL=yes
SuccessExitStatus=0
WorkingDirectory=/home/pydio

# Add environment variables
Environment=CELLS_WORKING_DIR=/var/cells
Environment=CELLS_BIND=https://127.0.0.1:8080
Environment=CELLS_EXTERNAL=https://cells.hwdomain.io

[Install]
WantedBy=multi-user.target

Wenn du fertig bist, speichere die Datei und beende den Editor.

Führe nun den folgenden systemctl-Befehl aus, um den systemd-Manager neu zu laden und den neuen systemd-Dienst anzuwenden.

sudo systemctl daemon-reload

Starte und aktiviere den Cells-Dienst mit dem folgenden systemctl-Befehl. Mit diesem Befehl wird der Cells-Dienst beim Systemstart automatisch gestartet.

sudo systemctl start cells
sudo systemctl enable cells

Zellen systemd

Überprüfe den Status des Cells-Dienstes mit dem unten stehenden Befehl. Die Pydio Cells sollten auf 127.0.0.1 mit Port 8080 laufen, wie in der Umgebungsvariablen CELLS_BIND definiert.

sudo systemctl status cells

Wenn er läuft, solltest du eine Ausgabe wie “ active (running)“ erhalten.

Die Zellen laufen

Apache2 als Reverse Proxy konfigurieren

Zu diesem Zeitpunkt laufen die Pydio Cells im Hintergrund auf localhost mit dem Standardport xxx. In diesem Schritt konfigurierst du Apache2 als Reverse-Proxy für deine Pydio Cells-Anwendung. Außerdem wirst du neue SSL/TLS-Zertifikate für deinen Domainnamen erstellen, also stelle sicher, dass du den Domainnamen vorbereitet hast und auf die IP-Adresse des Servers verweist.

Führe zunächst den Befehl a2enmod aus, um einige Apache2-Erweiterungen zu aktivieren, die als Reverse Proxy verwendet werden.

sudo a2enmod rewrite proxy proxy_http proxy_wstunnel http2 proxy_http2

Führe dann den folgenden Befehl aus, um ein neues Verzeichnis /var/www/html/cells/public_html zu erstellen und ändere den Eigentümer auf den Benutzer www-data. Dieses Verzeichnis wird für die Überprüfung bei der Erstellung von Letsencrypt-Zertifikaten verwendet.

sudo mkdir -p /var/www/html/cells/public_html
sudo chown -R www-data:www-data /var/www/html/cells/public_html

Danach führst du den Befehl certbot aus, um neue SSL/TLS-Zertifikate für deinen Pydio Cells-Domainnamen zu erstellen. Achte darauf, dass du die E-Mail-Adresse und den Domainnamen mit deinen Daten änderst.

sudo certbot certonly --agree-tos --email user@email.com --no-eff-email --webroot -w /var/www/html/cells/public_html -d cells.hwdomain.io

Wenn der Vorgang abgeschlossen ist, sind deine SSL/TLS-Zertifikate im Verzeichnis /etc/letsencrypt/live/domain.com verfügbar.

Als Nächstes erstellst du mit dem folgenden nano-Editor-Befehl eine neue Konfiguration für den virtuellen Apache2-Host /etc/apache2/sites-available/cells.conf.

sudo nano /etc/apache2/sites-available/cells.conf

Füge die folgende Konfiguration ein und achte darauf, dass du den Domainnamen und den Pfad der SSL/TLS-Zertifikate mit deinen Angaben änderst.

<VirtualHost *:80>
    ServerName cells.hwdomain.io
RewriteEngine On
RewriteCond %{HTTPS} off
RewriteRule (.*) https://%{HTTP_HOST}%{REQUEST_URI}

RewriteCond %{SERVER_NAME} =cells.hwdomain.io
RewriteRule ^ https://%{SERVER_NAME}%{REQUEST_URI} [END,NE,R=permanent]
</VirtualHost>

<VirtualHost *:443>
ServerName cells.hwdomain.io
AllowEncodedSlashes On
RewriteEngine On

# be aware of this
# Allow reverse proxy via self-signed certificates
SSLProxyEngine On
SSLProxyVerify none
SSLProxyCheckPeerCN off
SSLProxyCheckPeerName off
SSLProxyCheckPeerExpire off

## The order of the directives matters.
# If Cells is not running with https, consider using ws instead of wss
ProxyPassMatch "/ws/(.*)" wss://localhost:8080/ws/$1 nocanon

## This rewrite condition is required if using Cells-Sync
# RewriteCond %{HTTP:Content-Type} =application/grpc [NC]
# RewriteRule /(.*) h2://localhost:8080/$1 [P,L]

ProxyPass "/" "https://127.0.0.1:8080/"
ProxyPassReverse "/" "https://127.0.0.1:8080/"

ErrorLog ${APACHE_LOG_DIR}/error.log
CustomLog ${APACHE_LOG_DIR}/access.log combined

SSLCertificateFile /etc/letsencrypt/live/cells.hwdomain.io/fullchain.pem
SSLCertificateKeyFile /etc/letsencrypt/live/cells.hwdomain.io/privkey.pem
#Include /etc/letsencrypt/options-ssl-apache.conf
</VirtualHost>

Speichere die Datei und beende den Editor, wenn du fertig bist.

Führe nun den folgenden Befehl aus, um die virtuelle Hostdatei cells.conf zu aktivieren und die Apache-Syntax auf Fehler zu überprüfen. Wenn du eine korrekte Apache2-Syntax hast, solltest du eine Ausgabe Syntax OK erhalten.

sudo a2ensite cells.conf
sudo apachectl configtest

Zum Schluss führst du den folgenden systemctl-Befehl aus, um den Apache2-Dienst neu zu starten und die Änderungen zu übernehmen. Damit sollte dein Pydio Cells über eine sichere HTTPS-Verbindung des Apache2 Reverse Proxy erreichbar sein.

sudo systemctl restart apache2

Zugriff auf die Pydio Cells Installation

Starte deinen Webbrowser und rufe den Domainnamen der Pydio Cells Installation auf, z.B. https://cells.hwdomain.io/. Wenn alles gut geht, solltest du zur Anmeldeseite von Pydio Cells weitergeleitet werden.

Gib den Admin-Benutzer und das Passwort ein, die du während des Konfigurationsprozesses erstellt hast, und klicke dann auf Enter.

Anmeldung bei pydio

Wenn du erfolgreich warst, solltest du das Pydio Cells Benutzer-Dashboard wie folgt sehen:

pydio Dashboard

Klicke auf den Arbeitsbereich Persönliche Dateien und du solltest den Pydio Cells Dateimanager sehen. Klicke auf die Schaltfläche Neu und lade eine neue Datei hoch, um sicherzustellen, dass du Dateien in Pydio Cells hochladen kannst.

Test-Upload

Fazit

Mit dieser Anleitung hast du Pydio Cells auf dem Debian 12 Server installiert. Du hast Pydio Cells mit einem MariaDB-Datenbankserver und einem Apache2-Reverse-Proxy installiert und darüber hinaus deine Pydio Cells-Installation mit SSL/TLS-Zertifikaten von Letsencrypt gesichert. Jetzt kannst du Pydio Cells für die Verwaltung von Dokumenten und Dateien, die Zusammenarbeit und den Austausch nutzen.

Das könnte dich auch interessieren …