So installierst du BookWyrm auf einem Debian 12 Server
BookWyrm ist ein quelloffenes, föderiertes soziales Netzwerk für Buchleser. Es ist eine werbefreie Alternative zu Goodreads. Es nutzt das ActivityPub-Protokoll, um Nutzeraktivitäten zwischen anderen BookWyrm-Instanzen und anderen Diensten, die dieses Protokoll nutzen, wie Mastodon, zu senden und zu empfangen. Es bietet viele Funktionen wie Buchrezensionen, Bewertungen, Leseaktivitäten, Bücherregale wie „zu lesen“, „gerade gelesen“ und „gelesen“, Buchlisten und die Möglichkeit, anderen Nutzern und deren Lesefortschritt zu folgen. Außerdem bietet es Funktionen zur Benutzermoderation, wie das Sperren oder manuelle Freigeben von Followern, und mehrere Datenschutzstufen für Status, Regale und Listen.
In diesem Tutorial lernst du, wie du BookWyrm, das föderierte soziale Netzwerk für Buchleser, auf einem Debian 12 Server installierst.
Voraussetzungen
- Ein Server, auf dem Debian 12 läuft.
- Ein Nicht-Root-Benutzer mit sudo-Rechten.
- Ein Fully Qualified Domain Name (FQDN) wie
bookwyrm.example.com, der auf deinen Server zeigt. - Ein SMTP-Konto bei einem E-Mail-Dienst wie Amazon SES oder Mailgun.
- Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update $ sudo apt upgrade
- Ein paar Pakete, die dein System braucht.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. Debian wird standardmäßig mit ufw (Uncomplicated Firewall) ausgeliefert.
Überprüfe, ob die Firewall aktiv ist.
$ sudo ufw status
Du wirst die folgende Ausgabe erhalten.
Status: inactive
Erlaube den SSH-Port, damit die Firewall die aktuelle Verbindung nicht unterbricht, wenn du sie aktivierst.
$ sudo ufw allow OpenSSH
Lasse auch HTTP- und HTTPS-Ports zu.
$ sudo ufw allow http $ sudo ufw allow https
Aktiviere die Firewall
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Überprüfe den Status der Firewall erneut.
$ sudo ufw status
Du solltest eine ähnliche Ausgabe sehen.
Status: active To Action From -- ------ ---- OpenSSH ALLOW Anywhere 80/tcp ALLOW Anywhere 443 ALLOW Anywhere OpenSSH (v6) ALLOW Anywhere (v6) 80/tcp (v6) ALLOW Anywhere (v6) 443 (v6) ALLOW Anywhere (v6)
Schritt 2 – PostgreSQL installieren und konfigurieren
Ubuntu 22.04 wird standardmäßig mit PostgreSQL 14 ausgeliefert. Wir werden stattdessen PostgreSQL 15 verwenden.
Führe den folgenden Befehl aus, um den PostgreSQL GPG-Schlüssel hinzuzufügen.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Füge das APT-Repository zu deiner Quellenliste hinzu.
$ sudo sh -c 'echo "deb [signed-by=/usr/share/keyrings/postgresql-key.gpg arch=amd64] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/pgdg.list'
Aktualisiere das System-Repository.
$ sudo apt update
Jetzt kannst du PostgreSQL mit dem unten stehenden Befehl installieren.
$ sudo apt install postgresql postgresql-contrib
Das Paket postgresql-contrib enthält einige zusätzliche Hilfsprogramme.
Überprüfe den Status des PostgreSQL-Dienstes.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; preset: enabled)
Active: active (exited) since Sat 2023-09-09 07:39:21 UTC; 16s ago
Main PID: 3653 (code=exited, status=0/SUCCESS)
CPU: 1ms
Sep 09 07:39:21 bookwyrm systemd[1]: Starting postgresql.service - PostgreSQL RDBMS...
Sep 09 07:39:21 bookwyrm systemd[1]: Finished postgresql.service - PostgreSQL RDBMS.
Du kannst sehen, dass der Dienst aktiviert ist und standardmäßig läuft.
Starte die PostgreSQL-Shell.
$ sudo -i -u postgres psql
Erstelle die BookWyrm-Datenbank.
postgres=# CREATE DATABASE bookwyrm TEMPLATE template0 ENCODING 'UNICODE';
Erstelle den BookWyrm-Benutzer und wähle ein sicheres Passwort.
postgres-# CREATE USER bookwyrmuser WITH PASSWORD 'Your_Password';
Ändere den Eigentümer der Datenbank auf den BookWyrm-Benutzer.
postgres-# ALTER DATABASE bookwyrm OWNER TO bookwyrmuser;
Erteile dem BookWyrm-Benutzer alle Rechte für die Datenbank.
postgres-# GRANT ALL PRIVILEGES ON DATABASE bookwyrm TO bookwyrmuser;
Beende die Shell.
postgres-# \q
Überprüfe, ob deine Anmeldedaten funktionieren.
$ psql --username bookwyrmuser --password --host localhost bookwyrm Password: psql (15.4 (Debian 15.4-1.pgdg120+1)) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off) Type "help" for help. bookwyrm=>
Beende die Shell, indem du \q eingibst.
Schritt 3 – Redis installieren
Magento verwendet Redis für den Sitzungs- und Cache-Speicher. Das ist völlig optional und du kannst auch die Datenbank für die Sitzungsspeicherung verwenden. Aber Redis macht einen besseren Job. Die neueste Version von Magento arbeitet mit Redis 7.0. Ubuntu wird mit Redis 6.0 ausgeliefert, also werden wir das Redis-Repository für die Installation verwenden.
Importiere den offiziellen Redis GPG-Schlüssel.
$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
Füge das APT-Repository zu deiner Quellenliste hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/redis-archive-keyring.gpg] https://packages.redis.io/deb $(lsb_release -cs) main" | sudo tee /etc/apt/sources.list.d/redis.list
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Gib den folgenden Befehl ein, um den Redis-Server zu installieren.
$ sudo apt install redis
Bestätige die Redis-Version.
$ redis-server -v Redis server v=7.2.1 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=95712a67f5005c28
Überprüfe die Verbindung zum Dienst mit dem folgenden Befehl.
$ redis-cli
Du wirst auf die Redis-Shell umgeschaltet.
Der erste Schritt besteht darin, das Passwort für den Redis-Standardbenutzer festzulegen. Ersetze Your_Redis_Password durch ein sicheres Passwort deiner Wahl. Achte darauf, dass du dem Passwort das Zeichen > voranstellst.
127.0.0.1:6379> acl setuser default >Your_Redis_Password
Teste die Redis-Authentifizierung.
127.0.0.1:6379> AUTH Your_Redis_Password OK
Pinge den Dienst an.
127.0.0.1:6379> ping PONG
Beende den Dienst, indem du exit eingibst.
Wenn du möchtest, kannst du den folgenden Befehl verwenden, um das Redis-Passwort zu generieren.
$ openssl rand 60 | openssl base64 -A OaYOuq6J9HhxMV0sGCeZbaGecphCl4GBfVkCOPkNjkQE1FX9DKpGSCJcDb8UV+AuFKA8tR1PgjGequn1
Schritt 4 – Nginx installieren
Debian 12 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] \
http://nginx.org/packages/debian `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. Auf Debian-Systemen funktioniert der folgende Befehl nur mit sudo.
$ sudo nginx -v nginx version: nginx/1.24.0
Starten Sie den Nginx-Server.
$ sudo systemctl start nginx
Überprüfe den Status des Dienstes.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Sat 2023-09-09 08:40:27 UTC; 1s ago
Docs: https://nginx.org/en/docs/
Process: 6946 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 6947 (nginx)
Tasks: 2 (limit: 1107)
Memory: 1.7M
CPU: 8ms
CGroup: /system.slice/nginx.service
??6947 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??6948 "nginx: worker process"
Schritt 5 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. Du kannst Certbot entweder über das Repository von Debian installieren oder die neueste Version mit dem Snapd-Tool herunterladen. Wir werden die Snapd-Version verwenden.
Bei Debian 12 ist Snapd noch nicht installiert. Installiere das Snapd-Paket.
$ sudo apt install snapd
Führe die folgenden Befehle aus, um sicherzustellen, dass deine Version von Snapd auf dem neuesten Stand ist.
$ sudo snap install core && sudo snap refresh 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
Überprüfe, ob Certbot korrekt funktioniert.
$ certbot --version certbot 2.6.0
Erstelle das SSL-Zertifikat.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m name@example.com -d bookwyrm.example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/bookwyrm.example.com auf deinem Server heruntergeladen.
Erstelle ein Diffie-Hellman-Gruppenzertifikat.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Überprüfe den Certbot-Erneuerungszeitplanungsdienst.
$ sudo systemctl list-timers
Du findest snap.certbot.renew.service als einen der Dienste, die für die Ausführung vorgesehen sind.
NEXT LEFT LAST PASSED UNIT ACTIVATES ---------------------------------------------------------------------------------------------------------------- Sat 2023-09-09 23:49:00 UTC 15h left - - snap.certbot.renew.timer snap.certbot.renew.service Sun 2023-09-10 00:00:00 UTC 15h left - - dpkg-db-backup.timer dpkg-db-backup.service Sun 2023-09-10 00:00:00 UTC 15h left Sat 2023-09-09 06:42:47 UTC 2h 1min ago exim4-base.timer exim4-base.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 6 – BookWyrm herunterladen
Erstelle ein Verzeichnis für BookWyrm.
$ sudo mkdir /opt/bookwyrm
Wechsle in das Verzeichnis.
$ cd /opt/bookwyrm
Klone den Produktionszweig der BookWyrm-Anwendung von GitHub.
$ sudo git clone https://github.com/bookwyrm-social/bookwyrm.git --branch production --single-branch ./
Erstelle die Umgebungsdatei, indem du die Beispieldatei kopierst.
$ sudo cp .env.example .env
Schritt 7 – BookWyrm konfigurieren
Erstelle einen geheimen Schlüssel für BookWyrm.
$ openssl rand 60 | openssl base64 -A wcMjI1FW0mL9RfyxYDNZE/8bQP88kVIAUh7ekcSNAOUQCVfNeuMeW3und4BO5WbyCYy+9KpHqoEHWCkl
Öffne die Umgebungsdatei zur Bearbeitung.
$ sudo nano .env
Konfiguriere die folgenden Variablen.
SECRET_KEY="wcMjI1FW0mL9RfyxYDNZE/8bQP88kVIAUh7ekcSNAOUQCVfNeuMeW3und4BO5WbyCYy+9KpHqoEHWCkl" DOMAIN=bookwyrm.example.com EMAIL=user@example.com POSTGRES_PASSWORD=Your_Password POSTGRES_USER=bookwyrmuser POSTGRES_DB=bookwyrm POSTGRES_HOST=localhost REDIS_ACTIVITY_HOST=localhost REDIS_ACTIVITY_PORT=6379 REDIS_ACTIVITY_PASSWORD=Your_Redis_Password REDIS_ACTIVITY_DB_INDEX=0 REDIS_BROKER_HOST=localhost REDIS_BROKER_PORT=6379 REDIS_BROKER_PASSWORD=Your_Redis_Password REDIS_BROKER_DB_INDEX=1 FLOWER_USER=username FLOWER_PASSWORD=flowerpassword EMAIl_HOST= EMAIL_PORT=587 EMAIL_HOST_USER=AmazonSESUSER EMAIL_HOST_PASSWORD=AmazonSESPASSWORD EMAIL_USE_TLS=true EMAIL_USE_SSL=false EMAIL_SENDER_NAME=HowtoForge EMAIL_SENDER_DOMAIN=example.com ## only enable it if you have a fairly powered server with a minimum of 2 CPU Cores and 2GB of RAM ENABLE_PREVIEW_IMAGES=true
Gehen wir alle Variablen in der Umgebungsdatei durch.
SECRET_KEY– den Schlüssel, den du oben erzeugt hastDOMAIN– den vollqualifizierten Domainnamen (FQDN) für deine BookWyrn-Instanz. In unserem Fall wäre dasbookwyrm.example.com.POSTGRES_PASSWORD– Das in Schritt 2 konfigurierte PostgreSQL-Passwort.POSTGRES_HOST– auflocalhostgesetzt, wenn du ihn auf demselben Rechner hostest.POSTGRES_USER– aufbookwyrmusergesetzt, das du in Schritt 2 gewählt hast.POSTGRES_DB– aufbookwyrmsetzen, wie in Schritt 2 gewählt.REDIS_ACTIVITY_HOSTundREDIS_BROKER_HOST– setze sie auf localhost, wenn du den Redis-Server auf demselben Rechner hostest.REDIS_ACTIVITY_PORTundREDIS_BROKER_PORT– setze sie auf den Standard-Redis-Port 6379.REDIS_ACTIVITY_DBundREDIS_BROKER_DB– setze sie auf 0 bzw. 1. Wir werden für beide unterschiedliche Datenbanken verwenden.REDIS_ACTIVITY_PASSWORDundREDIS_BROKER_PASSWORD– setze sie auf das Redis-Passwort, das du in Schritt 3 gewählt hast.FLOWER_USER– Wähle einen Benutzernamen für den Flower-Dienst, der von BookWyrm benötigt wird.FLOWER_PASSWORD– wähle ein Passwort für den Flower-Dienst.EMAIL_HOST– setze den SMTP-Host des E-Mail-Dienstes, den du verwendest.EMAIL_PORT– Setze den SMTP-Port des E-Mail-Dienstes ein.EMAIL_HOST_USER– auf den SMTP-Benutzernamen setzen.EMAIL_HOST_PASSWORD– auf das SMTP-Passwort setzen.EMAIL_USE_TLS– setze sie auf true, wenn dein E-Mail-Dienst TLS verwendet.EMAIL_USE_SSL– Setze sie auf true, wenn dein E-Mail-Dienst SSL verwendet.EMAIL_SENDER_NAME– wähle den Namen des Absenders für die von deiner Instanz versendeten E-Mails.EMAIL_SENDER_DOMAIN– Setze ihn auf den vom E-Mail-Dienst verwendeten Domainnamen.ENABLE_PREVIEW_IMAGES– Setze ihn auf true, wenn du möchtest, dass deine Instanz automatisch Vorschaubilder erzeugt. Vergewissere dich jedoch, dass dein Server über ausreichend CPU und RAM verfügt, da dies ein intensiver Prozess ist.
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 8 – Nginx konfigurieren
Kopiere die Datei /opt/bookwyrm/nginx/server_config in das Nginx-Konfigurationsverzeichnis.
$ sudo cp /opt/bookwyrm/nginx/server_config /etc/nginx/conf.d/server_config
Erstelle und öffne die Datei /etc/nginx/conf.d/bookwyrm.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/bookwyrm.conf
Füge den folgenden Code in die Datei ein.
include /etc/nginx/conf.d/server_config;
upstream web {
server localhost:8000;
}
server {
listen [::]:80;
listen 80;
server_name bookwyrm.example.com;
# redirect http to https
return 301 https://bookwyrm.example.com$request_uri;
}
server {
access_log /var/log/nginx/bookwyrm.access.log cache_log;
error_log /var/log/nginx/bookwyrm.error.log;
listen [::]:443 ssl http2;
listen 443 ssl http2;
server_name bookwyrm.example.com;
client_max_body_size 3M;
if ($host != "bookwyrm.example.com") {
return 301 $scheme://bookwyrm.example.com$request_uri;
}
# SSL code
ssl_certificate /etc/letsencrypt/live/bookwyrm.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/bookwyrm.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/bookwyrm.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers off;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;
ssl_protocols TLSv1.2 TLSv1.3;
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;
tcp_nopush on;
types_hash_max_size 2048;
gzip on;
proxy_read_timeout 1800s;
# store responses to anonymous users for up to 1 minute
proxy_cache bookwyrm_cache;
proxy_cache_valid any 1m;
add_header X-Cache-Status $upstream_cache_status;
# ignore the set cookie header when deciding to
# store a response in the cache
proxy_ignore_headers Cache-Control Set-Cookie Expires;
# PUT requests always bypass the cache
# logged in sessions also do not populate the cache
# to avoid serving personal data to anonymous users
proxy_cache_methods GET HEAD;
proxy_no_cache $cookie_sessionid;
proxy_cache_bypass $cookie_sessionid;
# tell the web container the address of the outside client
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
proxy_redirect off;
location ~ ^/(login[^-/]|password-reset|resend-link|2fa-check) {
limit_req zone=loginlimit;
proxy_pass http://web;
}
# do not log periodic polling requests from logged in users
location /api/updates/ {
access_log off;
proxy_pass http://web;
}
location / {
proxy_pass http://web;
}
# directly serve images and static files from the
# bookwyrm filesystem using sendfile.
# make the logs quieter by not reporting these requests
location ~ ^/(images|static)/ {
root /opt/bookwyrm;
try_files $uri =404;
add_header X-Cache-Status STATIC;
access_log off;
}
# monitor the celery queues with flower, no caching enabled
location /flower/ {
proxy_pass http://localhost:8888;
proxy_cache_bypass 1;
}
}
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Öffne die Datei /etc/nginx/nginx.conf und bearbeite sie.
$ 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.
Ü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
Starte den Nginx-Dienst neu, um die neue Konfiguration zu aktivieren.
$ sudo systemctl restart nginx
Schritt 9 – BookWyrm installieren
Bevor wir BookWyrm installieren können, müssen wir einige Python-Pakete installieren.
$ sudo apt install python3-venv python3-pip python3-dev libpq-dev
Wechsle in das Bookwyrm-Verzeichnis.
$ cd /opt/bookwyrm
Ändere die Eigentümerschaft des Ordners auf den aktuell eingeloggten Benutzer.
$ sudo chown -R $USER:$USER .
Erstelle das Python-Verzeichnis venv.
$ python3 -m venv ./venv
Installiere die Python-Abhängigkeiten von BookWyrm mit dem Pip-Paketmanager.
$ ./venv/bin/pip3 install -r requirements.txt
Migriere das Datenbankschema.
$ venv/bin/python3 manage.py migrate
Initialisiere die Datenbank.
$ venv/bin/python3 manage.py initdb
Kompiliere die Themes.
$ venv/bin/python3 manage.py compile_themes
Erstelle die statischen Dateien.
$ venv/bin/python3 manage.py collectstatic --no-input
Erstelle und richte den BookWyrm-Systembenutzer ein.
$ sudo useradd bookwyrm -r
Ändere den Besitzer des Installationsverzeichnisses auf den BookWyrm-Benutzer.
$ sudo chown -R bookwyrm:bookwyrm /opt/bookwyrm
Von nun an musst du alle BookWyrm-bezogenen Befehle als BookWyrm-Benutzer ausführen.
$ sudo -u bookwyrm echo I am the ${whoami} user
I am the bookwyrm user
BookWyrm-Service-Unit-Datei erstellen
BookWyrm wird mit den Service-Unit-Dateien für den Service, den Worker und den Scheduler ausgeliefert. Kopiere sie in das Verzeichnis /etc/systemd/system.
$ sudo cp /opt/bookwyrm/contrib/systemd/*.service /etc/systemd/system/
Aktiviere und starte die Dienste mit dem folgenden Befehl.
$ sudo systemctl enable bookwyrm bookwyrm-worker bookwyrm-scheduler --now
Überprüfe den Status des BookWyrm-Dienstes.
$ sudo systemctl status bookwyrm
? bookwyrm.service - BookWyrm
Loaded: loaded (/etc/systemd/system/bookwyrm.service; enabled; preset: enabled)
Active: active (running) since Mon 2023-09-11 00:05:54 UTC; 7s ago
Main PID: 28583 (gunicorn)
Tasks: 2 (limit: 1107)
Memory: 99.2M
CPU: 1.254s
CGroup: /system.slice/bookwyrm.service
??28583 /opt/bookwyrm/venv/bin/python3 /opt/bookwyrm/venv/bin/gunicorn bookwyrm.wsgi:application --bind 0.0.0.0:8000
??28603 /opt/bookwyrm/venv/bin/python3 /opt/bookwyrm/venv/bin/gunicorn bookwyrm.wsgi:application --bind 0.0.0.0:8000
Auf ähnliche Weise kannst du den Status der beiden anderen Dienste überprüfen.
Der letzte Schritt der Installation ist die Generierung des Admin-Codes, der für die Erstellung des Administratorkontos benötigt wird.
$ sudo -u bookwyrm /opt/bookwyrm/venv/bin/python3 /opt/bookwyrm/manage.py admin_code
Du kannst den Code jederzeit abrufen, indem du denselben Befehl erneut ausführst.
Du solltest eine ähnliche Ausgabe erhalten.
******************************************* Use this code to create your admin account: 299f3181-e57e-4f16-94c9-51cfc427b8df *******************************************
Der nächste Schritt besteht darin, auf BookWyrm zuzugreifen und deine Instanz einzurichten.
Schritt 10 – Zugriff auf BookWyrm
Öffne die URL https://bookwyrm.example.com in deinem Browser und du wirst die folgende Seite erhalten.
Wenn alles in Ordnung zu sein scheint, klicke auf die Schaltfläche Weiter, um zur nächsten Seite zu gelangen.
Gib den Admin-Schlüssel, den du im vorherigen Schritt erhalten hast, zusammen mit den Anmeldedaten für das Administratorkonto ein. Wenn du fertig bist, klicke auf die Schaltfläche Anmelden, um die nächste Seite aufzurufen.
Hier wirst du aufgefordert, deine Seite zu konfigurieren und Informationen und Richtlinien für die Seite hinzuzufügen.
Als Nächstes überprüfst du deine E-Mail-Einstellungen, indem du in der linken Seitenleiste auf System >> E-Mail-Konfiguration klickst. Bestätige deine E-Mail-Einstellungen auf der Seite und klicke auf die Schaltfläche Test-E-Mail senden, um dir eine Test-E-Mail zu senden.
Wenn die E-Mail erfolgreich gesendet wurde, solltest du die folgende E-Mail erhalten.
Du kannst auch die restlichen Einstellungen konfigurieren, indem du sie in der linken Seitenleiste aufrufst. Wenn du das alles getan hast, ist deine BookWyrm-Instanz einsatzbereit.
Schritt 11 – BookWyrm sichern
BookWyrm wird mit einem Backup-Dienstprogramm ausgeliefert, das jedoch für die Docker-Installation angepasst ist. Außerdem wird es mit einem Dienstprogramm ausgeliefert, das den Backup-Ordner automatisch bereinigt. Wir werden das Backup-Dienstprogramm an unsere Installationsmethode anpassen und das mitgelieferte Dienstprogramm zur Backup-Bereinigung verwenden.
Erstelle die Datei ~/bookwyrm-backup.sh und öffne sie zum Bearbeiten.
$ nano ~/bookwyrm-backup.sh
Füge den folgenden Code in die Datei ein.
#!/bin/bash
POSTGRES_DB=bookwyrm
POSTGRES_USER=bookwyrmuser
if [ -z "$POSTGRES_DB" ]; then
echo "Database not specified, defaulting to bookwyrm"
fi
if [ -z "$POSTGRES_USER" ]; then
echo "Database user not specified, defaulting to bookwyrm"
fi
BACKUP_DB=${POSTGRES_DB:-bookwyrm}
BACKUP_USER=${POSTGRES_USER:-bookwyrm}
filename=backup_${BACKUP_DB}_$(date +%F)_$(date +%T)
PGPASSWORD="Your_Password" pg_dump -h localhost -U $BACKUP_USER $BACKUP_DB > ~/backups/$filename.sql
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Ändere die Werte der Variablen POSTGRES_DB, POSTGRES_USER und PGPASSWORD entsprechend den Werten, die du in Schritt 2 eingestellt hast.
Kopiere die Datei in das Verzeichnis /usr/local/bin.
$ sudo cp ~/bookwyrm-backup.sh /usr/local/bin/bookwyrm-backup.sh
Mache die Sicherungsdatei ausführbar.
$ sudo chmod +x /usr/local/bin/bookwyrm-backup.sh
Erstelle das Sicherungsverzeichnis.
$ mkdir ~/backups
Kopiere die Datei /opt/bookwyrm/postgres-docker/weed.sh in das Verzeichnis /usr/local/bin.
$ sudo cp /opt/bookwyrm/postgres-docker/weed.sh /usr/local/bin/bookwyrm-weed.sh
Erstelle und öffne die Datei cronfile zur Bearbeitung.
$ nano cronfile
Füge den folgenden Code in die Datei ein.
0 0 * * * /usr/local/bin/bookwyrm-backup.sh # This script will weed the backups directory. It will keep the 14 # most-recent backups, then one backup/week for the next four backups, then one # backup/month after that. 0 5 * * * /usr/local/bin/bookwyrm-weed.sh -d 14 -w 4 -m -1 ~/backups
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Kopiere die Datei cronfile in das Verzeichnis /etc/cron.d.
$ sudo cp ~/cronfile /etc/cron.d/cronfile
Setze die richtigen Berechtigungen für die cronfile.
$ sudo chmod 0644 /etc/cron.d/cronfile
Übermittle die Datei an das crontab.
$ sudo crontab /etc/cron.d/cronfile
Erstelle die Datei cron.log.
$ sudo touch /var/log/cron.log
Teste die Erstellung des Backups.
$ bookwyrm-backup.sh
Überprüfe das Verzeichnis der Backups.
$ ls ~/backups -al total 764 drwxr-xr-x 2 navjot navjot 4096 Sep 11 01:31 . drwx------ 7 navjot navjot 4096 Sep 11 01:31 .. -rw-r--r-- 1 navjot navjot 257577 Sep 11 01:21 backup_bookwyrm_2023-09-11.sql -rw-r--r-- 1 navjot navjot 257577 Sep 11 01:27 backup_bookwyrm_2023-09-11_01:27:35.sql -rw-r--r-- 1 navjot navjot 257577 Sep 11 01:31 backup_bookwyrm_2023-09-11_01:31:45.sql
Schritt 12 – BookWyrm aktualisieren
Die Aktualisierung deiner BookWyrm-Instanz erfordert einige Schritte. Zuerst ziehst du die neuesten Änderungen aus dem BookWyrm GitHub Repository.
$ cd /opt/bookwyrm $ sudo -u bookwyrm git pull
Installiere neue Python-Abhängigkeiten.
$ sudo -u bookwyrm venv/bin/pip install -r requirements.txt
Kompiliere die Themes.
$ sudo -u bookwyrm venv/bin/python3 manage.py compile_themes
Sammle alle statischen Dateien.
$ sudo -u bookwyrm venv/bin/python3 manage.py collectstatic --no-input
Migriere die Datenbank. Erstelle zunächst ein Backup mit dem vorherigen Schritt.
$ sudo -u bookwyrm venv/bin/python3 manage.py migrate
Starte die BookWyrm-Dienste neu.
$ sudo systemctl restart bookwyrm bookwyrm-worker bookwyrm-scheduler
Fazit
Damit ist unsere Anleitung zur Installation des sozialen Netzwerks BookWyrm auf einem Debian 12-Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.