Wie installiere ich Standard Notes Server auf Rocky Linux 9
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 Lernprogramm lernst du, wie du deinen Standard Notes Server auf einem Rocky Linux 9 Rechner selbst hosten kannst. Außerdem erfährst du, wie du kostenpflichtige Pläne auf dem Server kostenlos aktivieren kannst und wie du Datei-Uploads aktivierst.
Voraussetzungen
- Ein Server mit Rocky Linux 9 und mindestens 2 GB RAM.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein vollqualifizierter Domainname, der auf den Server zeigt. Für unser Tutorial werden wir die Domain
standardnotes.example.comverwenden. Du brauchst zwei weitere Domänennamen, einen für den Dateiserver und den zweiten für die Webanwendung. Wir werden die Domainsnotes-files.example.comfür den Dateiserver undsnotes-web.example.comfür die Webanwendung verwenden. - Alles ist aktualisiert.
$ sudo dnf update
- Ein paar Pakete, die dein System braucht.
$ sudo dnf install -y wget nano unzip yum-utils policycoreutils-python-utils
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Bevor du die Pakete installierst, musst du zunächst die Firewall so konfigurieren, dass sie die Ports für HTTP und HTTPS öffnet. Rocky Linux verwendet die Firewalld Firewall. Überprüfe den Status der Firewall.
$ sudo firewall-cmd --state running
Die Firewall arbeitet mit verschiedenen Zonen, wobei die öffentliche Zone die Standardzone ist, die wir verwenden werden. Liste alle Dienste und Ports auf, die auf der Firewall aktiv sind.
$ sudo firewall-cmd --zone=public --list-all
Es sollte die folgende Ausgabe angezeigt werden.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Öffne die HTTP- und HTTPS-Ports in der Firewall.
$ sudo firewall-cmd --zone=public --add-service=http $ sudo firewall-cmd --zone=public --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --zone=public --list-all
Du solltest eine ähnliche Ausgabe sehen.
public target: default icmp-block-inversion: no interfaces: enp1s0 sources: services: cockpit dhcpv6-client http https ssh ports: protocols: forward: yes masquerade: no forward-ports: source-ports: icmp-blocks: rich rules:
Setze alle Änderungen dauerhaft um und lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --runtime-to-permanent $ sudo firewall-cmd --reload
Schritt 2 – Installiere Docker und Docker Compose
Installiere das offizielle Docker-Repository.
$ sudo dnf config-manager \
--add-repo \
https://download.docker.com/linux/centos/docker-ce.repo
Installiere Docker.
$ sudo dnf install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Aktiviere den Docker-Daemon und starte ihn.
$ sudo systemctl enable docker --now
Überprüfe den Status des Docker-Dienstes.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/usr/lib/systemd/system/docker.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-04-16 23:35:00 UTC; 5s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 23273 (dockerd)
Tasks: 9
Memory: 34.0M
CPU: 176ms
CGroup: /system.slice/docker.service
??23273 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Apr 16 23:35:00 standard-notes systemd[1]: Starting Docker Application Container Engine...
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.050964934Z" level=info msg="Starting up"
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.083526973Z" level=info msg="Loading containers: start."
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.654481705Z" level=info msg="Firewalld: interface docker0 already part of docker zone, returning"
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.772647844Z" level=info msg="Loading containers: done."
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.793814339Z" level=info msg="Docker daemon" commit=60b9add containerd-snapshotter=false storage-driver=overlay2 version=26.0.1
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.793962347Z" level=info msg="Daemon has completed initialization"
Apr 16 23:35:00 standard-notes dockerd[23273]: time="2024-04-16T23:35:00.827030005Z" level=info msg="API listen on /run/docker.sock"
Apr 16 23:35:00 standard-notes systemd[1]: Started Docker Application Container Engine.
Füge deinen Systembenutzer zur Docker-Gruppe hinzu, um zu vermeiden, dass du sudo zur Ausführung von Docker-Befehlen verwendest.
$ sudo usermod -aG docker $(whoami)
Melde dich nach dem Abmelden erneut an deinem Server an, um die Änderung zu aktivieren.
Überprüfe die Änderung.
$ groups navjot wheel docker
Schritt 3 – Nginx installieren
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Du musst das offizielle Nginx-Repository verwenden, um die neueste Version zu installieren.
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=0 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=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Wir werden die Mainline-Version von Nginx verwenden und haben daher in der obigen Datei das Mainline-Repositorium aktiviert, indem wir enabled=1 unter dem Mainline-Abschnitt statt dem Stable-Abschnitt verwenden. Du kannst eine der beiden Versionen wählen.
Installiere Nginx.
$ sudo dnf install nginx -y
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.25.5
Aktiviere und starte den Nginx-Serverdienst.
$ sudo systemctl enable nginx --now
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/usr/lib/systemd/system/nginx.service; enabled; preset: disabled)
Active: active (running) since Tue 2024-04-16 23:41:23 UTC; 6s ago
Docs: http://nginx.org/en/docs/
Process: 4886 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 4887 (nginx)
Tasks: 3 (limit: 10819)
Memory: 3.1M
CPU: 11ms
CGroup: /system.slice/nginx.service
??4887 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??4888 "nginx: worker process"
??4889 "nginx: worker process"
Apr 16 23:41:23 standard-notes systemd[1]: Starting nginx - high performance web server...
Apr 16 23:41:23 standard-notes systemd[1]: Started nginx - high performance web server.
Schritt 4 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Dazu verwenden wir den Snapd-Paketinstaller. Da Rocky Linux nicht mit diesem Paket ausgeliefert wird, installierst du den Snapd-Installer. Er benötigt das EPEL (Extra Packages for Enterprise Linux) Repository, um zu funktionieren.
Installiere das EPEL-Repository.
$ sudo dnf install epel-release -y
Installiere das Snapd-Paket.
$ sudo dnf install snapd -y
Aktiviere und starte den Snap-Dienst.
$ sudo systemctl enable snapd --now
Installiere das Snap-Kernpaket und stelle sicher, dass deine Snapd-Version auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh core
Erstelle die notwendigen Links, damit Snapd funktioniert.
$ sudo ln -s /var/lib/snapd/snap /snap $ echo 'export PATH=$PATH:/var/lib/snapd/snap/bin' | sudo tee -a /etc/profile.d/snapd.sh
Installiere Certbot.
$ sudo snap install --classic certbot
Stelle mit dem folgenden Befehl sicher, dass der Certbot-Befehl ausgeführt werden kann, indem du einen symbolischen Link auf das Verzeichnis /usr/bin erstellst.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Überprüfe die Certbot-Version.
$ certbot --version certbot 2.10.0
Führe den folgenden Befehl aus, um ein SSL-Zertifikat zu erzeugen.
$ sudo certbot certonly --nginx --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 dasselbe für die Subdomain Files tun.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d snotes-files.example.com
Und zum Schluss noch einmal für die Web-App.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d snotes-web.example.com
Erstelle ein Diffie-Hellman Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot Erneuerungszeitplanungsdienst.
$ systemctl list-timers
Dort findest du snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ---------------------------------------------------------------------------------------------------------------------------------- Wed 2024-04-17 00:00:00 UTC 5min left Tue 2024-04-16 23:29:44 UTC 24min ago logrotate.timer logrotate.service Wed 2024-04-17 00:31:26 UTC 36min left - - dnf-makecache.timer dnf-makecache.service Wed 2024-04-17 11:00:00 UTC 11h left - - snap.certbot.renew.timer snap.certbot.renew.service
Führe einen Probelauf des Prozesses durch, um zu prüfen, ob die SSL-Erneuerung einwandfrei funktioniert.
$ sudo certbot renew --dry-run
Wenn du keine Fehler siehst, bist du bereit. Dein Zertifikat wird automatisch erneuert.
Schritt 5 – Herunterladen und Konfigurieren von Standard Notes
Vergewissere dich, dass du dich im Home-Verzeichnis deines Systems befindest.
$ cd ~
Erstelle ein Arbeitsverzeichnis für Standard Notes Server und wechsle dorthin.
$ mkdir standardnotes $ cd ~/standardnotes
Lade die Umgebungsbeispieldatei aus dem Standard Notes GitHub Repository herunter.
$ wget https://raw.githubusercontent.com/standardnotes/server/main/.env.sample
Erstelle die Arbeitsumgebungsdatei aus der heruntergeladenen Beispieldatei.
$ cp .env.sample .env
Du brauchst drei Authentifizierungs- und Verschlüsselungsschlüssel für die Konfiguration der .env Datei. Führe den folgenden Befehl aus, um drei separate Schlüssel zu erzeugen und kopiere deren Ausgabe.
$ openssl rand -hex 32
Außerdem brauchst du ein sicheres Datenbankpasswort. Du kannst den folgenden Befehl ausführen, um ein sicheres Datenbankpasswort zu erzeugen.
$ openssl rand -hex 12
Öffne die Umgebungsdatei zur Bearbeitung.
$ nano .env
Wähle ein sicheres Datenbankpasswort und füge es der Variablen DB_PASSWORD hinzu.
###### # DB # ###### DB_HOST=db DB_PORT=3306 DB_USERNAME=std_notes_user DB_PASSWORD=changeme DB_DATABASE=standard_notes_db DB_TYPE=mysql ######### # CACHE # ######### REDIS_PORT=6379 REDIS_HOST=cache CACHE_TYPE=redis ######## # KEYS # ######## AUTH_JWT_SECRET= AUTH_SERVER_ENCRYPTION_SERVER_KEY= VALET_TOKEN_SECRET=
Füge die zuvor generierten Schlüssel hinzu und setze sie zu den drei Variablen im Abschnitt KEYS.
In der Standardeinstellung ist die Benutzerregistrierung aktiviert. Wenn du die öffentliche Benutzerregistrierung auf deinem Standard-Notes-Server deaktivieren möchtest, füge die folgende Variable in die Umgebungsdatei ein, allerdings erst, nachdem du dein erstes Konto auf dem Server erstellt hast. Wenn du die Einstellung gleich zu Beginn vornimmst, kannst du die App nicht selbst nutzen.
AUTH_SERVER_DISABLE_USER_REGISTRATION=true
Füge die folgende Variable hinzu, um die URL deiner Standard Notes Files zu definieren.
PUBLIC_FILES_SERVER_URL=https://snotes-files.example.com
Die vollständige Datei .env sollte wie folgt aussehen.
###### # DB # ###### DB_HOST=db DB_PORT=3306 DB_USERNAME=std_notes_user DB_PASSWORD=<YourDBPassword> DB_DATABASE=standard_notes_db DB_TYPE=mysql ######### # CACHE # ######### REDIS_PORT=6379 REDIS_HOST=cache CACHE_TYPE=redis ######## # KEYS # ######## AUTH_JWT_SECRET=52b354ad5d8f11c995b4eed33870a1a7afbbc84b8da61e0b583660b075d0390c AUTH_SERVER_ENCRYPTION_SERVER_KEY=fce4fe78972c3407be47127aee57d67e86b84afb628020b7ab6999edb3c905f1 VALET_TOKEN_SECRET=50aad911a283f252713139667b6475ac105280a220e009e05f733cf785630ce5 AUTH_SERVER_DISABLE_USER_REGISTRATION=true PUBLIC_FILES_SERVER_URL=https://snotes-files.example.com
Speichere die Datei, indem du die Tastenkombination Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Lade das Localstack-Bootstrap-Skript aus dem GitHub-Repository herunter.
$ wget https://raw.githubusercontent.com/standardnotes/server/main/docker/localstack_bootstrap.sh
Gib dem Skript Ausführungsrechte.
$ chmod +x localstack_bootstrap.sh
Lade die Docker Compose Datei für den Standard Notes Server aus dem GitHub Repository herunter.
$ wget https://raw.githubusercontent.com/standardnotes/server/main/docker-compose.example.yml
Erstelle eine funktionierende Docker-Compose-Datei aus der heruntergeladenen Beispiel-Compose-Datei.
$ cp docker-compose.example.yml docker-compose.yml
Öffne sie zur Bearbeitung.
$ nano docker-compose.yml
Ändere den Wert für MYSQL_ROOT_PASSWORD und MYSQL_PASSWORD auf das Datenbankpasswort, das du zuvor in der Datei .env ausgewählt hast. Deine Docker Compose-Datei sollte wie die folgende aussehen.
services:
server:
image: standardnotes/server
env_file: .env
container_name: server_self_hosted
restart: unless-stopped
ports:
- 3000:3000
- 3125:3104
volumes:
- ./logs:/var/lib/server/logs
- ./uploads:/opt/server/packages/files/dist/uploads
networks:
- standardnotes_self_hosted
localstack:
image: localstack/localstack:3.0
container_name: localstack_self_hosted
expose:
- 4566
restart: unless-stopped
environment:
- SERVICES=sns,sqs
- HOSTNAME_EXTERNAL=localstack
- LS_LOG=warn
volumes:
- ./localstack_bootstrap.sh:/etc/localstack/init/ready.d/localstack_bootstrap.sh
networks:
- standardnotes_self_hosted
db:
image: mysql:8
container_name: db_self_hosted
environment:
- MYSQL_DATABASE=standard_notes_db
- MYSQL_USER=std_notes_user
- MYSQL_ROOT_PASSWORD=<YourDBPassword>
- MYSQL_PASSWORD=<YourDBPassword>
expose:
- 3306
restart: unless-stopped
command: --default-authentication-plugin=mysql_native_password --character-set-server=utf8mb4 --collation-server=utf8mb4_general_ci
volumes:
- ./data/mysql:/var/lib/mysql
- ./data/import:/docker-entrypoint-initdb.d
networks:
- standardnotes_self_hosted
cache:
image: redis:6.0-alpine
container_name: cache_self_hosted
volumes:
- ./data/redis/:/data
expose:
- 6379
restart: unless-stopped
networks:
- standardnotes_self_hosted
networks:
standardnotes_self_hosted:
name: standardnotes_self_hosted
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Damit ist der Download und die Konfiguration des Standard Notes Server-Setups abgeschlossen.
Schritt 6 – Standard Notes Server starten
Führe den folgenden Befehl aus, um den Server zu starten.
$ docker compose up -d
Es wird einige Minuten dauern, bis dieser Befehl ausgeführt wird. 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. Die CPU-Auslastung kann für ein paar Minuten in die Höhe schießen, aber sie sollte bald wieder sinken.
Die Protokolle für den Standard Notes Server findest du im Verzeichnis logs. Du kannst die Prozessprotokolle mit dem folgenden Befehl überprüfen.
$ tail -f logs/*.log
Drücke Strg + C, um die Protokolle zu verlassen. Den Status der laufenden Container kannst du mit einem der folgenden Befehle überprüfen.
$ docker compose ps OR $ docker ps
Du wirst eine ähnliche Ausgabe erhalten.
NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS cache_self_hosted redis:6.0-alpine "docker-entrypoint.s…" cache 16 minutes ago Up 5 minutes 6379/tcp db_self_hosted mysql:8 "docker-entrypoint.s…" db 16 minutes ago Up 5 minutes 3306/tcp, 33060/tcp localstack_self_hosted localstack/localstack:3.0 "docker-entrypoint.sh" localstack 16 minutes ago Up 5 minutes (healthy) 4510-4559/tcp, 4566/tcp, 5678/tcp server_self_hosted standardnotes/server "docker-entrypoint.sh" server 16 minutes ago Up 5 minutes 0.0.0.0:3000->3000/tcp, :::3000->3000/tcp, 0.0.0.0:3125->3104/tcp, :::3125->3104/tcp
Du kannst den Zustand des Servers mit dem folgenden Befehl überprüfen.
$ curl http://localhost:3000/healthcheck OK
Standard Notes verwendet standardmäßig Port 3000. Wenn du in der Datei .env einen anderen Port konfiguriert hast, solltest du diesen im obigen Befehl aktualisieren.
Schritt 7 – Standard Notes Web App installieren
Du kannst entweder die vorhandene Standard Notes Web App verwenden oder deine eigene hosten. Für unser Tutorial werden wir die Standard Notes Web App selbst hosten.
Git installieren
Bevor wir weitermachen, müssen wir ein paar Dinge installieren, unter anderem Git. Installiere Git.
$ sudo dnf install git -y
NodeJS installieren
Der nächste Schritt ist die Installation von NodeJS. Wir werden dafür die Version Node 18.x LTS installieren. Gib die folgenden Befehle ein, um NodeJS zu installieren.
$ curl -fsSL https://rpm.nodesource.com/setup_18.x | sudo bash - $ sudo dnf install -y nodejs
Bestätige die Installation.
$ node --version v18.20.2
Yarn installieren
Wir brauchen auch den Yarn-Paketmanager. Installiere ihn mit Node.
$ sudo npm install --global yarn
Installiere den PM2-Paketmanager.
Wir brauchen PM2, um die Standard Notes Web-App als Hintergrunddienst laufen zu lassen.
$ sudo npm install --global pm2
Installiere die Webanwendung
Erstelle ein Verzeichnis für die Web-App und wechsle dorthin.
$ cd ~ $ mkdir snotes-app $ cd ~/snotes-app
Lade die Standard Notes App von GitHub herunter.
$ git clone https://github.com/standardnotes/app.git .
Verwende Yarn, um die Abhängigkeiten zu installieren. Ignoriere alle Warnungen.
$ yarn install
Erstelle die Pakete für die Web-App.
$ yarn build:web
Wechsle in das Webverzeichnis.
$ cd packages/web
Starte die Webanwendung mit PM2.
$ pm2 start "yarn start" --name api
Du kannst den Status des Dienstes mit dem folgenden Befehl überprüfen.
$ pm2 status [PM2] Starting /usr/bin/bash in fork_mode (1 instance) [PM2] Done. ???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????? ? id ? name ? namespace ? version ? mode ? pid ? uptime ? ? ? status ? cpu ? mem ? user ? watching ? ???????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????? ? 0 ? api ? default ? N/A ? fork ? 15090 ? 0s ? 0 ? online ? 0% ? 26.2mb ? navjot ? disabled ? ????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????????
Die App wird gestartet und ist über Port 3001 erreichbar. Diese Informationen nutzen wir, um eine Nginx-Konfiguration für die Web-App zu erstellen.
PM2 startet die Anwendung beim Neustart nicht neu. Dafür müssen wir ein Startup-Skript erstellen.
$ pm2 startup
Du solltest eine ähnliche Ausgabe erhalten.
[PM2] Init System found: systemd [PM2] To setup the Startup Script, copy/paste the following command: sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot
Führe den in der Ausgabe angegebenen Befehl aus.
$ sudo env PATH=$PATH:/usr/bin /usr/lib/node_modules/pm2/bin/pm2 startup systemd -u navjot --hp /home/navjot
Dadurch wird eine systemd-Dienstdatei erstellt und aktiviert.
Speichere den Prozess, damit er beim Neustart automatisch gestartet wird.
$ pm2 save
Schritt 8 – 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;
listen [::]:443 ssl;
http2 on;
http3 on;
quic_retry on;
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 off;
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;
resolver 8.8.8.8;
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;
listen [::]:443 ssl;
http2 on;
http3 on;
quic_retry on;
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 off;
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;
resolver 8.8.8.8;
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;
}
Schließlich müssen wir noch eine Konfigurationsdatei für die Web-App erstellen.
$ sudo nano /etc/nginx/conf.d/web-standardnotes.conf
Füge den folgenden Code in die Datei ein.
server {
listen 443 ssl;
listen [::]:443 ssl;
http2 on;
http3 on;
quic_retry on;
server_name snotes-web.example.com;
client_max_body_size 50M;
access_log /var/log/nginx/standardnotes-web.access.log;
error_log /var/log/nginx/standardnotes-web.error.log;
ssl_certificate /etc/letsencrypt/live/snotes-web.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/snotes-web.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/snotes-web.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 off;
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;
resolver 8.8.8.8;
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-web.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 9 – SELinux konfigurieren
Wende die Richtlinie an, um Verbindungen zu externen Hosts zuzulassen.
$ sudo setsebool -P httpd_can_network_connect 1
Wende die Richtlinie an, um Nginx den Zugriff auf PostgreSQL zu erlauben.
$ sudo setsebool -P httpd_can_network_connect_db 1
Schritt 10 – Standardhinweise verwenden
Wenn du die URL https://standardnotes.example.com in deinem Browser öffnest, solltest du die folgende Ausgabe sehen.
Das bedeutet, dass dein Server betriebsbereit 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 Mobile-Apps gleich.
Öffne die URL https://snotes-web.example.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.
Klicke auf die Schaltfläche Weiter, um fortzufahren. Du wirst erneut nach deinem Passwort gefragt.
Sobald du angemeldet bist, kannst du anfangen, Notizen zu erstellen und die Anwendung zu nutzen.
Schritt 11 – Kostenpflichtige Funktionen freischalten
Bisher haben wir die Grundfunktionen der Standard-Notizanwendung aktiviert. Du kannst jedoch einige kostenpflichtige serverseitige Funktionen aktivieren, und Standard Notes erlaubt dir, diese kostenlos zu nutzen. Die clientseitigen Premium-Funktionen wie Super Notes und Nested Tags werden dadurch nicht aktiviert. Um sie zu aktivieren, kannst du ein stark vergünstigtes Abonnement über den Standard Notes Offline-Plan erwerben.
Um die serverseitigen Premium-Funktionen in der selbst gehosteten Anwendung zu aktivieren, musst du den folgenden Befehl aus dem Standard Notes-Verzeichnis ausführen.
$ cd ~/standardnotes
$ docker compose exec db sh -c "MYSQL_PWD=\$MYSQL_ROOT_PASSWORD mysql \$MYSQL_DATABASE -e \
'INSERT INTO user_roles (role_uuid , user_uuid) VALUES ((SELECT uuid FROM roles WHERE name=\"PRO_USER\" ORDER BY version DESC limit 1) ,(SELECT uuid FROM users WHERE email=\"EMAIL@ADDR\")) ON DUPLICATE KEY UPDATE role_uuid = VALUES(role_uuid);' \
"
$ docker compose exec db sh -c "MYSQL_PWD=\$MYSQL_ROOT_PASSWORD mysql \$MYSQL_DATABASE -e \
'INSERT INTO user_subscriptions SET uuid=UUID(), plan_name=\"PRO_PLAN\", ends_at=8640000000000000, created_at=0, updated_at=0, user_uuid=(SELECT uuid FROM users WHERE email=\"EMAIL@ADDR\"), subscription_id=1, subscription_type=\"regular\";' \
"
Lade die Webanwendung neu und die kostenpflichtigen Funktionen sollten für dein Konto aktiviert sein. Um die clientseitigen Funktionen zu aktivieren, öffnest du deine App-Einstellungen, wählst das Menü Allgemein >> Offline-Aktivierung und gibst den Aktivierungscode ein, den du beim Kauf des Offline-Tarifs erhalten hast.
Schritt 12 – Konfiguriere den Server für den Datei-Upload
Der Datei-Upload ist eine kostenpflichtige Funktion von Standard Notes und funktioniert nicht ohne den Kauf des Offline-Plans. 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/uploads gespeichert. Führe die folgenden Befehle aus, um die Berechtigungen zu ändern.
$ sudo chmod -R 775 data $ sudo chmod -R 755 uploads $ sudo chown -R 1001.1001 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 | | performance_schema | | standard_notes_db | +--------------------+ 3 rows in set (0.01 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 zuzuweisen.
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 13 – Upgrade des Standard Notes Servers und der Web-Applikation
Der erste Schritt beim Upgrade des Standard Notes Servers ist das Beenden und Entfernen der vorhandenen Container.
$ cd ~/standardnotes $ docker compose stop $ docker compose remove --orphans
Hol dir die neuesten .env, localstack_bootstrap.sh und die Docker Compose Dateien aus dem GitHub Repository. Nimm die erforderlichen Änderungen vor und ersetze deine bestehenden Dateien durch die aktualisierten.
Starte die Server-Container erneut.
$ docker compose up -d
Dein aktualisierter Sync-Server läuft jetzt.
Wechsle in das Verzeichnis der Web-App.
$ cd ~/snotes-app
Wechsle in das Stammverzeichnis der Web-App.
$ cd packages/web
Halte den bestehenden Prozess an.
$ pm2 stop api
Wechsle zurück in das Hauptverzeichnis der App.
$ cd ~/snotes-app
Ziehe die neuesten Änderungen aus dem GitHub-Repository.
$ git pull
Gehe zurück in das Webverzeichnis.
$ cd packages/web
Starte den Prozess.
$ pm2 start api
Deine Web-App sollte nun aktualisiert sein.
Fazit
Damit ist unsere Anleitung zur Installation und Konfiguration des Standard Notes Servers auf einem Rocky Linux 9 Rechner abgeschlossen. Wenn du Fragen hast, schreibe sie unten in die Kommentare.