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.comverwenden. Du brauchst einen anderen Domänennamen für deinen Dateiserver. Wir werden die Domainsnotes-files.example.comverwenden. - 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 name@example.com -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 name@example.com -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 curl 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.
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.
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 name@example.com
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="name@example.com"));
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.
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.
Klicke auf die drei Punkte neben dem Dateinamen, um weitere Optionen für die Datei aufzurufen.
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.