Wie installiere ich Standard Notes Server unter Ubuntu 22.04

Standard Notes ist eine quelloffene und vollständig verschlüsselte Notizen-App. Sie ist sowohl kostenlos als auch kostenpflichtig und bietet sowohl Cloud-Hosting als auch die Option, sie auf deinem Server zu hosten. Du kannst deinen Server nutzen, um die gespeicherten Notizen zwischen verschiedenen Geräten zu synchronisieren. Standard Notes bietet Apps für alle Desktop-Betriebssysteme und mobilen Plattformen.

In diesem Tutorial lernst du, wie du deinen Standard Notes Server auf einem Ubuntu 22.04 Rechner selbst hosten kannst. Außerdem erfährst du, wie du die Funktionen des kostenpflichtigen Plans und das Hochladen von Dateien auf deiner selbst gehosteten Instanz aktivierst.

Voraussetzungen

  • Ein Server mit Ubuntu 22.04 und mindestens 2 GB RAM.
  • Ein Nicht-Root-Benutzer mit sudo-Rechten.
  • Die Uncomplicated Firewall (UFW) ist aktiviert und läuft.
  • Ein voll qualifizierter Domainname, der auf den Server zeigt. Für unser Tutorial werden wir die Domain standardnotes.example.com verwenden. Du brauchst einen anderen Domänennamen für deinen Dateiserver. Wir werden die Domain snotes-files.example.com verwenden.
  • Alles ist aktualisiert.
    $ sudo apt update && sudo apt upgrade
    

Schritt 1 – Firewall konfigurieren

Der erste Schritt vor der Installation der Pakete besteht darin, die Firewall so zu konfigurieren, dass HTTP- und HTTPS-Verbindungen zugelassen werden.

Überprüfe den Status der Firewall.

$ sudo ufw status

Du solltest etwas wie das Folgende sehen.

Status: active

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

Erlaube HTTP- und HTTPs-Ports.

$ sudo ufw allow http
$ sudo ufw allow https

Überprüfe den Status zur Bestätigung noch einmal.

$ sudo ufw status
Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere
80/tcp                     ALLOW       Anywhere
443/tcp                    ALLOW       Anywhere
OpenSSH (v6)               ALLOW       Anywhere (v6)
80/tcp (v6)                ALLOW       Anywhere (v6)
443/tcp (v6)               ALLOW       Anywhere (v6)

Schritt 2 – Installiere Docker und Docker Compose

Füge den offiziellen GPG-Schlüssel von Docker hinzu.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg

Führe den folgenden Befehl aus, um das Docker-Repository hinzuzufügen.

$ echo \
  "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \
  $(lsb_release -cs) stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null

Aktualisiere das System, um das Docker-Repository aufzunehmen.

$ sudo apt update

Installiere Docker.

$ sudo apt-get install docker-ce docker-ce-cli containerd.io docker-compose-plugin

In diesem Lehrgang wird das Docker Compose v2 Plugin anstelle des älteren Legacy Binary verwendet. Daher hat sich der Befehl zum Ausführen von docker-compose zu docker compose geändert, was sich hier widerspiegelt.

Docker läuft mit erhöhten Rechten, daher musst du sudo häufig verwenden, um Befehle auszuführen. Die bessere Option ist, dein Linux-Benutzerkonto zur Benutzergruppe docker hinzuzufügen.

$ sudo usermod -aG docker ${USER}

Die Variable ${USER} nimmt das aktuell eingeloggte Systemkonto auf. Wenn du nicht mit dem Benutzer eingeloggt bist, dem du Privilegien geben willst, ersetze ${USER} durch den Benutzernamen.

Um die neue Gruppenmitgliedschaft zu beantragen, melde dich vom Server ab und wieder an oder verwende den folgenden Befehl. Du wirst aufgefordert, das Passwort des Benutzers einzugeben.

$ su - $(USER)

Schritt 3 – Nginx installieren

Ubuntu 22.04 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.

Importiere den Signierschlüssel von Nginx.

$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null

Füge das Repository für die stabile Version von Nginx hinzu.

$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg arch=amd64] \
http://nginx.org/packages/ubuntu `lsb_release -cs` nginx" \
| sudo tee /etc/apt/sources.list.d/nginx.list

Aktualisiere die System-Repositories.

$ sudo apt update

Installiere Nginx.

$ sudo apt install nginx

Überprüfe die Installation.

$ nginx -v
nginx version: nginx/1.22.0

Schritt 4 – SSL installieren

Wir müssen Certbot installieren, um das SSL-Zertifikat zu erzeugen. Du kannst Certbot entweder über das Repository von Ubuntu installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.

Bei Ubuntu 22.04 ist Snapd standardmäßig installiert. Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.

$ sudo snap install core

Installiere Certbot.

$ sudo snap install --classic certbot

Verwende den folgenden Befehl, um sicherzustellen, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link zum Verzeichnis /usr/bin erstellst.

$ sudo ln -s /snap/bin/certbot /usr/bin/certbot

Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.

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

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

Wir müssen das Gleiche für die Subdomain Files tun.

$ sudo certbot certonly --standalone --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d snotes-files.example.com

Erstelle ein Diffie-Hellman-Gruppenzertifikat.

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

Öffne die Datei /etc/letsencrypt/renewal/standardnotes.example.com.conf zur Bearbeitung.

$ sudo nano /etc/letsencrypt/renewal/standardnotes.example.com.conf

Füge den folgenden Code am Ende der Datei ein.

pre_hook = systemctl stop nginx
post_hook = systemctl start nginx

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

Wiederhole den gleichen Schritt für die Subdomain der Dateien, indem du die Datei /etc/letsencrypt/renewal/snotes-files.example.com.conf bearbeitest.

Wir haben das SSL-Zertifikat mit der Standalone-Option von Certbot erstellt. Es lässt seinen Webserver laufen, um das Zertifikat zu erstellen, was bedeutet, dass Nginx während der Erneuerung abgeschaltet werden sollte. Die Befehle pre_hook und post_hook werden vor und nach der Erneuerung ausgeführt, um den Nginx-Server automatisch abzuschalten und neu zu starten, sodass kein manuelles Eingreifen erforderlich ist.

Um zu überprüfen, ob die SSL-Erneuerung einwandfrei funktioniert, führe einen Probelauf des Prozesses durch.

$ sudo certbot renew --dry-run

Wenn du keine Fehler siehst, ist alles in Ordnung. Dein Zertifikat wird automatisch erneuert.

Schritt 5 – Herunterladen und Konfigurieren der Standardhinweise

Vergewissere dich, dass du dich im Home-Verzeichnis deines Systems befindest.

$ cd ~

Klone das Standard Notes Standalone Repository.

$ git clone --single-branch --branch main https://github.com/standardnotes/standalone.git

Wechsle in das heruntergeladene Verzeichnis.

$ cd standalone

Erstelle die Standardkonfigurationsdateien für den Server.

$ ./server.sh setup

Dadurch werden die Standard-Umgebungsdateien erstellt, die wir konfigurieren müssen. Du musst sechs verschiedene geheime Schlüssel erzeugen. Verwende die folgenden Befehle, um sie zu erzeugen.

$ openssl rand -hex 32

Zuerst müssen wir die Datei .env im Hauptordner bearbeiten. Öffne sie zur Bearbeitung.

$ nano .env

Ändere die Werte der folgenden Variablen.

NODE_ENV=production
..
AUTH_JWT_SECRET=c0f5bcf6f0f0dcca5b9078c3095e4255a055dfd6376b376733af0e50483cc629
..
DB_USERNAME=std_notes_user
DB_PASSWORD=changeme123
..
VALET_TOKEN_SECRET=977c978ca1d5ea22fe2fda65058905b191f724e33db6e47d0a41e034a082cb3b
..
FILES_SERVER_URL=https://snotes-files.example.com

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

Öffne als nächstes die Datei docker/auth.env.

$ nano  docker/auth.env

Ändere die Werte der folgenden Variablen.

JWT_SECRET=54deb1b0b2499e8d875b0d5266dabef9003e13c1787a959a94e339363c10e56e
LEGACY_JWT_SECRET=c36aae01803a616213f22422b6d3f998a2beb2cb53af8b95bf578a8a3d046cec
..
PSEUDO_KEY_PARAMS_KEY=ea09d3f9122b49c653524cd2285a45fee88beb94f9b76d4d25420b521b080fcd
..
ENCRYPTION_SERVER_KEY=04decf379fbe3bb48cf95dbb5997031418b308e724a25d88cb0b2ed6da725efe

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

Schritt 6 – Standard Notes Server starten

Führe den folgenden Befehl aus, um den Server zu starten.

$ ./server.sh start

Die Ausführung dieses Befehls wird einige Minuten in Anspruch nehmen. Während dieser Zeit werden alle relevanten Docker-Images geladen und Container für alle Dienste erstellt. Er füllt auch die Datenbank auf und führt die entsprechenden Migrationen durch.

Du kannst die Protokolle des Prozesses mit dem folgenden Befehl überprüfen.

$ ./server.sh logs

Drücke Strg + C, um die Protokolle zu verlassen. Du kannst den Status der laufenden Container mit dem folgenden Befehl überprüfen.

$ ./server.sh status

Du wirst eine ähnliche Ausgabe erhalten.

Services State:
NAME                                  COMMAND                  SERVICE                    STATUS              PORTS
api-gateway-standalone                "./wait-for.sh auth …"   api-gateway                running             0.0.0.0:3000->3000/tcp, :::3000->3000/tcp
auth-standalone                       "./wait-for.sh db 33…"   auth                       running
auth-worker-standalone                "./wait-for.sh db 33…"   auth-worker                running
cache-standalone                      "docker-entrypoint.s…"   cache                      running             6379/tcp
db-standalone                         "docker-entrypoint.s…"   db                         running             3306/tcp
files-standalone                      "./wait-for.sh db 33…"   files                      running             0.0.0.0:3125->3000/tcp, :::3125->3000/tcp
syncing-server-js-standalone          "./wait-for.sh db 33…"   syncing-server-js          running
syncing-server-js-worker-standalone   "./wait-for.sh db 33…"   syncing-server-js-worker   running

Du kannst den Zustand des Servers mit dem folgenden Befehl überprüfen.

$ curl http://localhost:3000/healthcheck
OK

Standardmäßig verwendet Notes den Port 3000. Wenn du in der Datei .env einen anderen Port konfiguriert hast, solltest du diesen im obigen Befehl aktualisieren.

Schritt 7 – Nginx konfigurieren

Ö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.

Erstelle und öffne die Datei /etc/nginx/conf.d/standardnotes.conf zum Bearbeiten.

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

Füge den folgenden Code in die Datei ein. Ersetze standardnotes.example.com durch deinen Domainnamen. Wir haben den Wert von client_max_body_size auf 50 MB festgelegt. Du kannst ihn nach deinen Bedürfnissen ändern.

server {

    listen 443 ssl http2;
    listen [::]:443 ssl http2;

    server_name standardnotes.example.com;

    client_max_body_size 50M;

    access_log  /var/log/nginx/standardnotes.access.log;
    error_log   /var/log/nginx/standardnotes.error.log;

    ssl_certificate      /etc/letsencrypt/live/standardnotes.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/standardnotes.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/standardnotes.example.com/chain.pem;
    
    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    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 / {
        proxy_pass http://127.0.0.1:3000;
        proxy_cache off;
    }
}
# enforce HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name  standardnotes.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.

Die obige Datei ist für die Hauptanwendung Standard Notes. Als Nächstes müssen wir eine weitere Datei für die Subdomäne Dateien konfigurieren.

$ sudo nano /etc/nginx/conf.d/files-standardnotes.conf

Füge den folgenden Code in die Datei ein. Ersetze snotes-files.example.com durch deinen Domänennamen. Wir haben den Wert der Variable client_max_body_size auf 50 MB festgelegt. Du kannst ihn nach deinen Bedürfnissen ändern.

server {

    listen 443 ssl http2;
    listen [::]:443 ssl http2;

    server_name snotes-files.example.com;

    client_max_body_size 50M;

    access_log  /var/log/nginx/files-standardnotes.access.log;
    error_log   /var/log/nginx/files-standardnotes.error.log;

    ssl_certificate      /etc/letsencrypt/live/snotes-files.example.com/fullchain.pem;
    ssl_certificate_key  /etc/letsencrypt/live/snotes-files.example.com/privkey.pem;
    ssl_trusted_certificate /etc/letsencrypt/live/snotes-files.example.com/chain.pem;
    
    ssl_session_timeout  5m;
    ssl_session_cache shared:MozSSL:10m;
    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 / {
        proxy_pass http://127.0.0.1:3125;
        proxy_cache off;
    }
}
# enforce HTTPS
server {
    listen 80;
    listen [::]:80;
    server_name  snotes-files.example.com;
    return 301   https://$host$request_uri;
}

Überprüfe deine Nginx-Konfiguration.

$ sudo nginx -t

Starte den Nginx-Server neu, um die Konfigurationsdateien zu aktivieren.

$ sudo systemctl restart nginx

Schritt 8 – Standard-Notizen verwenden

Wenn du die URL https://standardnotes.example.com in deinem Browser öffnest, solltest du die folgende Ausgabe sehen.

Standard Notes URL home

Das bedeutet, dass dein Server in Betrieb ist und läuft. Um Standard Notes zu nutzen, musst du die offiziellen Apps verwenden. Für unser Tutorial werden wir die Web-App verwenden, aber die Methode bleibt für die Desktop- und die Mobile-App gleich.

Öffne die URL https://app.standardnotes.com, um die Web-App aufzurufen. Klicke auf den Link Kostenloses Konto erstellen unten links auf der Seite und gib deine E-Mail-Adresse und dein Passwort ein. Klicke auf die Schaltfläche Erweiterte Funktionen, entferne das Häkchen bei der Option Benutzerdefinierter Sync-Server und gib die URL https://standardnotes.example.com in das Feld ein.

Standard-Notizen Konto erstellen

Sobald du angemeldet bist, kannst du anfangen, Notizen zu erstellen und die Anwendung zu nutzen.

Schritt 9 – Bezahlte Funktionen aktivieren

Bisher haben wir die Grundfunktionen für die Anwendung Standard Notizen aktiviert. Die Anwendung bietet einige fortgeschrittene Funktionen wie mehrere Notizformate, verschlüsselten Cloud-Speicher, eine längere Änderungshistorie und mehr.

Für die in der Cloud gehostete Anwendung kannst du direkt bezahlen, um erweiterte Funktionen zu aktivieren. Bei der selbst gehosteten Anwendung kannst du jedoch nicht für die erweiterten Funktionen bezahlen, da die Zahlungsanwendung nicht funktioniert. Du kannst sie aber spenden. Um bezahlte Funktionen in einer selbst gehosteten Anwendung zu aktivieren, musst du den folgenden Befehl aus dem Verzeichnis Standard Notes ausführen.

$ cd ~/standardnotes
$ bash ./server.sh create-subscription [email protected]

Lade die Webanwendung neu und die bezahlten Funktionen sollten für dein Konto aktiviert sein.

Schritt 10 – Den Server für den Datei-Upload konfigurieren

Der Datei-Upload ist eine kostenpflichtige Funktion von Standard Notes. Wir haben die benutzerdefinierte API-URL für die Datei-Uploads aktiviert. Aber sie funktionieren trotzdem nicht. Damit sie funktionieren, müssen wir dem Uploads-Verzeichnis die richtigen Berechtigungen geben. Die Uploads werden im Verzeichnis ~/standardnotes/data/uploads gespeichert. Führe die folgenden Befehle aus, um die Berechtigungen zu ändern.

$ chmod -R 775 data
$ mkdir -p data/uploads
$ sudo chmod -R 755 data/uploads
$ sudo chown -R 1001.1001 data/uploads

Jetzt setzt Standard Notes das Upload-Limit für jeden Benutzer auf Null. Das bedeutet, dass kein Benutzer Dateien hochladen kann, es sei denn, er erhält manuell eine Quote. Der letzte Schritt, damit der Datei-Upload funktioniert, besteht also darin, die Dateiquote für das bezahlte Benutzerkonto zu aktivieren. Dazu führen wir eine SQL-Abfrage innerhalb des Datenbank-Containers durch.

Melde dich in der MySQL-Shell innerhalb des Datenbank-Containers an.

$ docker exec -it db-standalone mysql -u std_notes_user -p
Enter password:

In der MySQL-Shell sehen wir uns die Liste der Datenbanken an.

mysql > show databases;
+--------------------+
| Database           |
+--------------------+
| information_schema |
| standard_notes_db  |
+--------------------+
2 rows in set (0.00 sec)

Wechsle zur Datenbank Standard Notes.

mysql > use standard_notes_db;

Führe den folgenden SQL-Befehl aus, um dem oben aktivierten bezahlten Benutzer ein Dateikontingent von 10 GB hinzuzufügen.

mysql> INSERT INTO subscription_settings(uuid, name, value, created_at, updated_at, user_subscription_uuid) VALUES (UUID(), "FILE_UPLOAD_BYTES_LIMIT", 10737418240, FLOOR(UNIX_TIMESTAMP(NOW(6))*1000000), FLOOR(UNIX_TIMESTAMP(NOW(6))*1000000), (SELECT us.uuid FROM user_subscriptions us INNER JOIN users u ON us.user_uuid=u.uuid WHERE u.email="[email protected]"));

10737418240 bezieht sich hier auf die Gesamtanzahl der Bytes, was 10 GB entspricht. Du kannst diese Zahl nach Belieben ändern.

Beende die MySQL-Shell und den Datenbank-Container.

mysql > exit

Schritt 11 – Testen der Dateiuploads

Melde dich in der Standard Notes Web-App an und klicke auf das Anhangssymbol in der oberen Zeile.

Standard-Notizen Anhänge-Symbol

Klicke auf die Schaltfläche Dateien hochladen und wähle die Datei aus, die du hochladen möchtest. Die Datei wird erfolgreich hochgeladen und du kannst sie in der Liste sehen, wenn du erneut auf das Symbol klickst.

Standard-Notizen Angehängte Datei

Klicke auf die drei Punkte neben dem Dateinamen, um weitere Optionen für die Datei aufzurufen.

Standard Notes File Options

Klicke auf den Link An Notiz anhängen, um das Bild zur Notiz hinzuzufügen. Die übrigen Optionen sind selbsterklärend.

Fazit

Damit ist unsere Anleitung zur Installation und Konfiguration des Standard Notes Servers auf einem Ubuntu 22.04 Rechner abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.

Das könnte dich auch interessieren …