So installierst du den Etherpad Collaborative Web Editor auf Rocky Linux 8

Etherpad ist ein Open-Source-Online-Editor, der kollaborative Bearbeitung in Echtzeit im Browser ermöglicht. Er ist in Node.js geschrieben und kann selbst gehostet werden, um mit verschiedenen Plattformen wie WordPress, Drupal, Odoo, Discourse, Joomla usw. zu arbeiten.

In diesem Lernprogramm werden wir Etherpad auf einem Rocky Linux 8 Server installieren und die MariaDB-Datenbank zum Speichern unserer Daten verwenden. Außerdem verwenden wir Nginx als Reverse Proxy für die Anwendung und installieren ein SSL-Zertifikat mit Let’s Encrypt, um HTTPS-Verbindungen zu unserer Etherpad-Instanz zu ermöglichen.

Voraussetzungen

  1. Ein System, auf dem Rocky Linux 8 läuft.
  2. Ein Nicht-Root-Benutzer mit sudo-Rechten.
  3. Ein Domainname, der auf den Server zeigt.
  4. Nodejs ist installiert. Befolge unsere Anleitung zur Installation von Nodejs auf dem Rocky Linux 8 Server. Verwende eine der beiden angegebenen Methoden.
  5. Stelle sicher, dass alles auf dem neuesten Stand ist.
    $ sudo dnf update
    

Schritt 1 – Firewall konfigurieren

Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.

$ sudo firewall-cmd --state
running

Dieser zeigt an, dass sie erfolgreich läuft.

Die Firewall arbeitet mit verschiedenen Zonen und die öffentliche Zone ist die Standardzone, die wir verwenden werden. Zeige alle aktiven Dienste und Ports der Firewall an.

$ sudo firewall-cmd --permanent --list-services

Sie sollte die folgende Ausgabe zeigen.

cockpit dhcpv6-client ssh

Lasse HTTP- und HTTPS-Ports zu.

$ sudo firewall-cmd --permanent --add-service=http
$ sudo firewall-cmd --permanent --add-service=https

Öffne den Port 9001, der von der Etherpad-Anwendung verwendet wird.

$ sudo firewall-cmd --permanent --add-port=9001/tcp

Überprüfe erneut den Status der Firewall.

$ sudo firewall-cmd --permanent --list-services

Du solltest eine ähnliche Ausgabe sehen.

cockpit dhcpv6-client http https ssh

Lade die Firewall neu, um die Änderungen zu aktivieren.

$ sudo firewall-cmd --reload

Schritt 2 – Git installieren

Bevor wir Etherpad installieren, müssen wir Git installieren. Führe den folgenden Befehl aus, um Git zu installieren.

$ sudo dnf install git

Überprüfe die Installation.

$ git --version
git version 2.27.0

Füge die Anfangskonfiguration hinzu.

$ git config --global user.name "YourName"
$ git config --global user.email "[email protected]"

Liste die Konfiguration auf, die du gerade eingestellt hast.

$ git config --list
user.name=YourName
[email protected]

Schritt 3 – MariaDB installieren

Da wir die MariaDB-Datenbank verwenden werden, um die Daten von Etherpad zu speichern, müssen wir sie zuerst installieren und konfigurieren.

Das Rocky Linux AppStream Repository wird mit MariaDB geliefert. Um alle verfügbaren Versionen von MariaDB aufzulisten, führe den folgenden Befehl aus.

$ sudo dnf module list mariadb
Last metadata expiration check: 1:15:26 ago on Thu 21 Oct 2021 10:20:01 AM UTC.
Rocky Linux 8 - AppStream
Name                          Stream                         Profiles                                         Summary
mariadb                       10.3 [d]                       client, galera, server [d]                       MariaDB Module
mariadb                       10.5                           client, galera, server [d]                       MariaDB Module

Hint: [d]efault, [e]nabled, [x]disabled, [i]nstalled

Die Standardversion ist auf 10.3 eingestellt. Du kannst jedoch die neueste Version mit dem folgenden Befehl installieren.

$ sudo dnf module enable mariadb:10.5

Installiere MariaDB.

$ sudo dnf install mariadb-server

Aktiviere und starte den MariaDB-Dienst.

$ sudo systemctl enable mariadb --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status mariadb

Sichere den MariaDB-Server.

$ sudo mysql_secure_installation

Du wirst verschiedene Eingabeaufforderungen sehen. Beantworte sie wie folgt.

Enter current password for root (enter for none): Press Enter
Switch to unix_socket authentication [Y/n] Type y
Change the root password? [Y/n] Type n
Remove anonymous users? [Y/n] Type y
Disallow root login remotely? [Y/n] Type y
Remove test database and access to it? [Y/n] Type y
Reload privilege tables now? [Y/n] Type y

Du kannst dich jetzt mit dem folgenden Befehl mit dem MariaDB-Server verbinden.

$ sudo mysql 

Schritt 4 – MariaDB konfigurieren

Melde dich in der MariaDB-Shell an.

$ sudo mysql

Erstelle eine neue Datenbank für Etherpad.

$ create database `etherpad_lite_db`;

Lege einen neuen Datenbankbenutzer an.

$ CREATE USER 'etherpaduser'@'localhost' identified by 'password';

Verwende ein sicheres Passwort.

Erteile dem Benutzer Berechtigungen für die Datenbank.

$ grant CREATE,ALTER,SELECT,INSERT,UPDATE,DELETE on `etherpad_lite_db`.* to '<etherpaduser>'@'localhost';

Beende die MySQL-Shell.

$ exit

Schritt 5 – Etherpad herunterladen und installieren

Um Etherpad zu installieren, laden wir den Quellcode herunter und bauen ihn.

Der erste Schritt ist die Erstellung eines neuen etherpad Benutzers mit dem folgenden Befehl.

$ sudo adduser --system --home /opt/etherpad --create-home --user-group etherpad

Dieser Befehl erstellt einen --system Benutzer, das heißt, er kann sich nicht anmelden und hat kein Passwort. Außerdem geben wir ihm ein Heimatverzeichnis /opt/etherpad, in das wir Etherpad herunterladen werden. Mit dem Flag --create-home wird das Home-Verzeichnis mit den richtigen Berechtigungen erstellt. Das Flag --user-group erstellt eine Gruppe mit demselben Namen wie der Benutzername.

Wechsle zum Benutzer etherpad, um die Anwendung herunterzuladen und zu installieren.

$ sudo -u etherpad bash

Wechsle in das Verzeichnis /opt/etherpad.

[[email protected] user] cd /opt/etherpad

Klone das Etherpad-Repository in das Verzeichnis /opt/etherpad.

[[email protected] ~]$ git clone --branch master git://github.com/ether/etherpad-lite.git

Wechsle in das neu heruntergeladene Verzeichnis.

[[email protected] ~]$ cd etherpad-lite

Führe das run.sh Skript von Etherpad aus, um Abhängigkeiten einzurichten und zu installieren.

[[email protected] etherpad-lite]$ src/bin/run.sh

Du kannst die URL http://YOURSERVERIP:9001 im Browser aufrufen, um Etherpad zu starten. Du wirst den folgenden Bildschirm erhalten.

Etherpad Startseite

Es gibt ein Problem mit der obigen Installation. Sie erfordert, dass du die aktuelle Shell geöffnet hältst und Node im Vordergrund läuft. Um eine dauerhafte Installation zu ermöglichen, müssen wir Etherpad als Dienst ausführen. Drücke Strg + C in deinem Terminal, um die Ausführung von Etherpad zu beenden.

Schritt 6 – Etherpad konfigurieren

Bevor wir fortfahren, müssen wir einige Einstellungen vornehmen und unsere Installation nach unseren Bedürfnissen konfigurieren. Etherpad speichert seine Einstellungen in der Datei settings.json im Installationsverzeichnis.

Öffne die Datei, um sie zu bearbeiten.

[[email protected] etherpad-lite]$ nano settings.json

Die Einstellungsdatei ist als JSON formatiert. Das erste, was du konfigurieren musst, sind die Datenbankeinstellungen.

Suche den folgenden Code und kommentiere ihn aus, indem du // davor stellst.

//  "dbType": "dirty",
//  "dbSettings": {
//    "filename": "var/dirty.db"
//  },

Dann suchst du den folgenden Code und änderst die Werte wie folgt. Achte darauf, dass du /* und */ am Anfang und am Ende entfernst.

  "dbType" : "mysql",
  "dbSettings" : {
    "user":     "etherpaduser",
    "host":     "localhost",
    "port":     3306,
    "password": "password",
    "database": "etherpad_lite_db",
    "charset":  "utf8mb4"
  },

Scrolle ein wenig nach unten, um die Einstellung trustProxy zu finden und ändere ihren Wert von false in true.

  "trustProxy": true,

Diese Einstellung wird benötigt, damit Etherpad zusammen mit Nginx funktioniert.

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Beende die Etherpad-Benutzershell.

[[email protected] etherpad-lite]$ exit

Schritt 7 – Etherpad-Dienst einrichten

Um Etherpad beim Booten zu starten und den Prozess mit systemctl zu verwalten, müssen wir eine Servicedatei erstellen.

Erstelle und öffne die Servicedatei.

$ sudo nano /etc/systemd/system/etherpad.service

Füge den folgenden Code in die Datei ein.

[Unit]
Description=Etherpad, a collaborative web editor.
After=syslog.target network.target

[Service]
Type=simple
User=etherpad
Group=etherpad
WorkingDirectory=/opt/etherpad
Environment=NODE_ENV=production
ExecStart=/usr/bin/node --experimental-worker /opt/etherpad/etherpad-lite/node_modules/ep_etherpad-lite/node/server.js
Restart=always

[Install]
WantedBy=multi-user.target

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Lade den Service-Daemon neu, um die neue Konfiguration zu übernehmen.

$ sudo systemctl daemon-reload

Aktiviere den Dienst Etherpad starten.

$ sudo systemctl enable etherpad --now

Überprüfe den Status des Dienstes.

$ sudo systemctl status etherpad
? etherpad.service - Etherpad, a collaborative web editor.
   Loaded: loaded (/etc/systemd/system/etherpad.service; disabled; vendor preset: disabled)
   Active: active (running) since Thu 2021-10-21 15:06:53 UTC; 6s ago
 Main PID: 47228 (node)
    Tasks: 13 (limit: 11411)
   Memory: 102.8M
   CGroup: /system.slice/etherpad.service
           ??47228 /usr/bin/node --experimental-worker /opt/etherpad/etherpad-lite/node_modules/ep_etherpad-lite/node/server.js
.......

Schritt 8 – Installiere SSL mit Let’s Encrypt

Um ein SSL-Zertifikat mit Let’s Encrypt zu installieren, müssen wir das Tool Certbot installieren.

Als erstes musst du das EPEL-Repository herunterladen und installieren.

$ sudo dnf install epel-release

Führe die folgenden Befehle aus, um Certbot zu installieren.

$ sudo dnf install certbot

Erstelle das SSL-Zertifikat.

$ sudo certbot certonly --standalone --agree-tos --preferred-challenges http -m [email protected] -d example.com

Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/etherpad.example.com auf deinem Server heruntergeladen.

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

$ sudo openssl dhparam -out /etc/ssl/certs/dhparam.pem 2048

Erstelle ein Challenge-Webroot-Verzeichnis für die automatische Erneuerung von Let’s Encrypt.

$ sudo mkdir -p /var/lib/letsencrypt

Erstelle einen Cron Job zur Erneuerung des SSL-Zertifikats. Er wird jeden Tag ausgeführt, um das Zertifikat zu überprüfen und bei Bedarf zu erneuern. Erstelle dazu zunächst die Datei /etc/cron.daily/certbot-renew und öffne sie zur Bearbeitung.

$ sudo nano /etc/cron.daily/certbot-renew

Füge den folgenden Code ein.

#!/bin/sh
certbot renew --cert-name etherpad.example.com --webroot -w /var/lib/letsencrypt/ --post-hook "systemctl reload nginx"

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Ändere die Berechtigungen für die Aufgabendatei, um sie ausführbar zu machen.

$ sudo chmod +x /etc/cron.daily/certbot-renew

Schritt 9 – Nginx installieren und konfigurieren

Rocky Linux wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das Nginx-Repository hinzufügen.

Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.

$ sudo nano /etc/yum.repos.d/nginx.repo

Füge den folgenden Code in die Datei ein.

[nginx-stable]
name=nginx stable repo
baseurl=http://nginx.org/packages/centos/$releasever/$basearch/
gpgcheck=1
enabled=1
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

[nginx-mainline]
name=nginx mainline repo
baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/
gpgcheck=1
enabled=0
gpgkey=https://nginx.org/keys/nginx_signing.key
module_hotfixes=true

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Installiere Nginx.

$ sudo dnf install nginx

Aktiviere den Nginx-Dienst.

$ sudo systemctl enable nginx

Als Nächstes erstellst du die Datei /etc/nginx/conf.d/etherpad.conf und öffnest sie zur Bearbeitung.

$ sudo nano /etc/nginx/conf.d/etherpad.conf

Füge den folgenden Code in die Datei ein.

server {
    listen       443 ssl http2;
    listen       [::]:443 ssl http2;
    server_name  etherpad.example.com;

    access_log  /var/log/nginx/etherpad.access.log;
    error_log   /var/log/nginx/etherpad.error.log;
    
    ssl_certificate      /etc/letsencrypt/live/etherpad.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/etherpad.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/etherpad.example.com/chain.pem;

    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;  # about 40000 sessions
    ssl_session_tickets off;

    ssl_protocols TLSv1.2 TLSv1.3;
    ssl_prefer_server_ciphers on;
    ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
    ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
    ssl_stapling on;
    ssl_stapling_verify on;
    ssl_dhparam /etc/ssl/certs/dhparam.pem;

    location / {
        rewrite  ^/$ / break;
        rewrite  ^/locales/(.*) /locales/$1 break;
        rewrite  ^/locales.json /locales.json break;
        rewrite  ^/admin(.*) /admin/$1 break;
        rewrite  ^/p/(.*) /p/$1 break;
        rewrite  ^/static/(.*) /static/$1 break;
        rewrite  ^/pluginfw/(.*) /pluginfw/$1 break;
        rewrite  ^/javascripts/(.*) /javascripts/$1 break;
        rewrite  ^/socket.io/(.*) /socket.io/$1 break;
        rewrite  ^/ep/(.*) /ep/$1 break;
        rewrite  ^/minified/(.*) /minified/$1 break;
        rewrite  ^/api/(.*) /api/$1 break;
        rewrite  ^/ro/(.*) /ro/$1 break;
        rewrite  ^/error/(.*) /error/$1 break;
        rewrite  ^/jserror(.*) /jserror$1 break;
        rewrite  ^/redirect(.*) /redirect$1 break;
        rewrite  /favicon.ico /favicon.ico break;
        rewrite  /robots.txt /robots.txt break;
        rewrite  /(.*) /p/$1;
        
        proxy_pass         http://127.0.0.1:9001;
        proxy_buffering    off;
        proxy_set_header   Host $host;
        proxy_pass_header  Server;

        # proxy headers
        proxy_set_header    X-Real-IP $remote_addr;
        proxy_set_header    X-Forwarded-For $remote_addr;
        proxy_set_header    X-Forwarded-Proto $scheme;
        proxy_http_version  1.1;

        # websocket proxying
        proxy_set_header  Upgrade $http_upgrade;
        proxy_set_header  Connection $connection_upgrade;
    }
}

# we're in the http context here
map $http_upgrade $connection_upgrade {
    default upgrade;
    ''      close;
}

# enforce HTTPS
server {
    listen       80;
    listen       [::]:80;
    server_name  etherpad.example.com;
    return 301   https://$host$request_uri;
}

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.

Überprüfe die Syntax der Nginx-Konfigurationsdatei.

$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful

Wenn du die folgende Fehlermeldung erhältst, musst du die Datei /etc/nginx/nginx.conf bearbeiten, um die Größe der Variable server_names_hash_bucket_size hinzuzufügen/anzupassen.

nginx: [emerg] could not build the server_names_hash, you should increase server_names_hash_bucket_size

Öffne die Datei /etc/nginx/nginx.conf zum Bearbeiten.

$ sudo nano /etc/nginx/nginx.conf

Füge die folgende Zeile vor der Zeile include /etc/nginx/conf.d/*.conf; ein.

server_names_hash_bucket_size  64;

Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Bestätige Nginx erneut.

Starte schließlich den Nginx-Dienst, um die neue Konfiguration zu aktivieren.

$ sudo systemctl start nginx

Starte die URL https://etherpad.example.com in deinem Browser und Etherpad home wird geöffnet. Dort kannst du jetzt Dokumente bearbeiten und Mitstreiter einladen.

Etherpad aktualisieren

Die Aktualisierung von Etherpad ist einfach. Der erste Schritt besteht darin, in die Etherpad-Benutzershell zu wechseln.

$ sudo -u etherpad bash

Wechsle in das Verzeichnis /opt/etherpad/etherpad-lite.

[[email protected] user] cd /opt/etherpad/etherpad-lite

Ziehe das neueste Etherpad-Repository in das Verzeichnis /opt/etherpad/etherpad-lite.

[[email protected] ~]$ git pull origin

Führe das run.sh Skript von Etherpad aus, um die neueste Version von Etherpad einzurichten.

[[email protected] etherpad-lite]$ src/bin/run.sh

Fazit

In diesem Lernprogramm haben wir den Etherpad Collaborative Editor mit dem Nginx-Server eingerichtet und mit Let’s Encrypt SSL-Zertifikaten gesichert. Deine Etherpad-Installation ist nun einsatzbereit und du kannst sie um weitere Funktionen wie authentifizierte Benutzer, Plugins und Anpassungen der Benutzeroberfläche erweitern.

Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …