So installierst du BookWyrm auf einem Rocky Linux 9 Server mit Docker
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 auf einem Rocky Linux 9 Server installierst.
Voraussetzungen
- Ein Server mit Rocky Linux 9 mit mindestens 2 GB RAM und 2 CPU-Kernen.
- 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 dnf update
- Ein paar Pakete, die dein System braucht.
$ sudo dnf install wget curl nano unzip yum-utils policycoreutils-python-utils -y
Einige dieser Pakete sind vielleicht schon auf deinem System installiert.
Schritt 1 – Firewall konfigurieren
Der erste Schritt besteht darin, die Firewall zu konfigurieren. 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 --permanent --list-services
Es sollte die folgende Ausgabe angezeigt werden.
cockpit dhcpv6-client ssh
Lasse HTTP- und HTTPS-Ports zu.
$ sudo firewall-cmd --permanent --add-service=http $ sudo firewall-cmd --permanent --add-service=https
Überprüfe erneut den Status der Firewall.
$ sudo firewall-cmd --permanent --list-services
Du solltest eine ähnliche Ausgabe sehen.
cockpit dhcpv6-client http https ssh
Lade die Firewall neu, um die Änderungen zu aktivieren.
$ sudo firewall-cmd --reload
Schritt 2 – Installiere Docker und Docker Compose
Dieser Schritt ist sowohl auf dem Server als auch auf den Client-Rechnern erforderlich.
Installiere das offizielle Docker-Repository.
$ sudo dnf install yum-utils
$ sudo yum-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 Wed 2023-09-13 09:15:08 UTC; 6s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 6425 (dockerd)
Tasks: 9
Memory: 33.2M
CPU: 282ms
CGroup: /system.slice/docker.service
??6425 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Füge deinen Systembenutzer zur Docker-Gruppe hinzu, um zu vermeiden, dass sudo zum Ausführen von Docker-Befehlen verwendet wird.
$ sudo usermod -aG docker $(whoami)
Melde dich nach dem Abmelden erneut an deinem Server an, um die Änderung zu aktivieren.
Schritt 3 – Git installieren
BookWyrm benötigt Git, um die Dateien herunterzuladen, und das ist auf Rocky Linux standardmäßig nicht verfügbar. Führe den folgenden Befehl aus, um Git zu installieren.
$ sudo dnf install git
Überprüfe die Installation.
$ git --version git version 2.39.3
Du kannst Git mit deinem Namen und deiner E-Mail-Adresse für die weitere Verwendung konfigurieren. Dieser Schritt ist jedoch optional.
$ git config --global user.name "Your Name" $ git config --global user.email "youremail@domain.com"
Schritt 4 – Nginx installieren
Rocky Linux 9 wird mit einer älteren Version von Nginx ausgeliefert. Um die neueste Version zu installieren, musst du das offizielle Nginx-Repository herunterladen.
Erstelle und öffne die Datei /etc/yum.repos.d/nginx.repo zum Bearbeiten.
$ sudo nano /etc/yum.repos.d/nginx.repo
Füge den folgenden Code in die Datei ein.
[nginx-stable] name=nginx stable repo baseurl=http://nginx.org/packages/centos/$releasever/$basearch/ gpgcheck=1 enabled=1 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true [nginx-mainline] name=nginx mainline repo baseurl=http://nginx.org/packages/mainline/centos/$releasever/$basearch/ gpgcheck=1 enabled=0 gpgkey=https://nginx.org/keys/nginx_signing.key module_hotfixes=true
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Installiere Nginx.
$ sudo dnf install nginx
Überprüfe die Installation.
$ nginx -v nginx version: nginx/1.24.0
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 Wed 2023-09-13 09:16:59 UTC; 8s ago
Docs: http://nginx.org/en/docs/
Process: 8786 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 8787 (nginx)
Tasks: 3 (limit: 22979)
Memory: 2.8M
CPU: 12ms
CGroup: /system.slice/nginx.service
??8787 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??8788 "nginx: worker process"
??8789 "nginx: worker process"
Schritt 5 – 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
Installiere Snapd.
$ sudo dnf install -y snapd
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
Gib den folgenden Befehl ein, um Certbot zu installieren.
$ sudo snap install --classic certbot
Stelle mit folgendem 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 Installation.
$ 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-Erneuerungsplanerdienst.
$ 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 ------------------------------------------------------------------------------------------------------------------ Wed 2023-09-13 10:45:51 UTC 1h 25min left Wed 2023-09-13 09:19:00 UTC 1min 13s ago dnf-makecache.timer dnf-makecache.service Wed 2023-09-13 18:33:00 UTC 9h left - - snap.certbot.renew.timer snap.certbot.renew.service Thu 2023-09-14 00:00:00 UTC 14h left Wed 2023-09-13 08:32:04 UTC 48min ago logrotate.timer logrotate.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.
$ mkdir ~/bookwyrm
Wechsle in das Verzeichnis.
$ cd ~/bookwyrm
Klone den Produktionszweig der BookWyrm-Anwendung von GitHub.
$ git clone https://github.com/bookwyrm-social/bookwyrm.git .
Wechsle in den Produktionszweig.
$ git checkout production
Erstelle die Umgebungsdatei, indem du die Beispieldatei kopierst.
$ cp .env.example .env
Schritt 7 – BookWyrm-Umgebungsdatei konfigurieren
Erstelle einen geheimen Schlüssel für BookWyrm.
$ openssl rand 60 | openssl base64 -A kahYlt56TI2fZQwj0oX054u2aJE7bptHyInK4RXQadLLmXwGSDm8N1vW9uacA9N6FHoXPINPwOFTmnaT
Öffne die Umgebungsdatei zur Bearbeitung.
$ sudo nano .env
Konfiguriere die folgenden Variablen.
SECRET_KEY="kahYlt56TI2fZQwj0oX054u2aJE7bptHyInK4RXQadLLmXwGSDm8N1vW9uacA9N6FHoXPINPwOFTmnaT" 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– aufdbgesetzt, das ist der Servicename von PostgreSQL in der Dateidocker-compose.yml.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 – BookWyrm-Docker-Datei konfigurieren
Öffne die Docker-Kompositionsdatei zur Bearbeitung.
$ nano docker-compose.yml
Wie du sehen kannst, besteht die Docker-Datei sowohl aus Nginx- als auch aus Certbot-Diensten. Für unser Tutorial werden wir Nginx jedoch extern als Reverse-Proxy-Server verwenden. Daher werden wir den Certbot-Dienst nicht in der Datei verwenden. Außerdem müssen wir den Nginx-Dienst entsprechend ändern.
Unter Dienste >> Nginx >> Ports kommentierst du die Standard-Ports aus und fügst die Zeile ` – „8001:8001“ wie unten gezeigt ein. Kommentiere auch die certbot-Volumes unter dem Nginx-Dienst aus. Der Nginx-Dienst sollte wie folgt aussehen. Und schließlich kommentierst du den gesamten Abschnitt des certbot-Dienstes aus.
services:
nginx:
image: nginx:latest
logging: *default-logging
restart: unless-stopped
ports:
# - "80:80"
# - "443:443"
- "8001:8001"
depends_on:
- web
networks:
- main
volumes:
- ./nginx:/etc/nginx/conf.d
# - ./certbot/conf:/etc/nginx/ssl
# - ./certbot/data:/var/www/certbot
- static_volume:/app/static
- media_volume:/app/images
#certbot:
# image: certbot/certbot:latest
# command: certonly --webroot --webroot-path=/var/www/certbot --email ${EMAIL} --agree-tos --no-eff-email -d ${DOMAIN} -d www.${DOMAIN}
#command: renew --webroot --webroot-path /var/www/certbot
# logging: *default-logging
# volumes:
# - ./certbot/conf:/etc/letsencrypt
# - ./certbot/logs:/var/log/letsencrypt
# - ./certbot/data:/var/www/certbot
Es sind keine weiteren Änderungen erforderlich. Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 8 – Nginx und Nginx-Dateien konfigurieren
Erstelle eine Kopie der Nginx-Produktionsvorlagendatei und richte sie so ein, dass sie mit dem Nginx-Dockerdienst verwendet werden kann.
$ cp nginx/production nginx/default.conf
Öffne die default.conf zum Bearbeiten.
$ nano nginx/default.conf
Ersetze your-domain.com durch deinen tatsächlichen BookWyrm-Domainnamen im ersten und dritten Serverblock. In unserem Fall ist es bookwyrm.example.com. Wenn du nicht die www-your-domain.com Version deiner Domain verwendest, entferne sie aus dem server_name. Kommentiere auch den location ~ /.well-known/acme-challenge Block unter dem ersten Serverblock aus.
So sollte deine default.conf aussehen.
include /etc/nginx/conf.d/server_config;
upstream web {
server web:8000;
}
server {
listen [::]:80;
listen 80;
server_name bookwyrm.example.com;
# location ~ /.well-known/acme-challenge {
# allow all;
# root /var/www/certbot;
# }
# # redirect http to https
# return 301 https://your-domain.com$request_uri;
}
# server {
....
}
# Reverse-Proxy server
server {
listen [::]:8001;
listen 8001;
server_name bookwyrm.example.com;
location / {
proxy_pass http://web;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
proxy_redirect off;
}
location /images/ {
alias /app/images/;
}
location /static/ {
alias /app/static/;
}
}
Wenn du fertig bist, 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/bookwyrm.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/bookwyrm.conf
Füge den folgenden Code in die Datei ein.
server {
server_name bookwyrm.example.com;
listen [::]:80;
listen 80;
# redirect http to https
return 301 https://bookwyrm.example.com$request_uri;
}
server {
access_log /var/log/nginx/bookwyrm.access.log;
error_log /var/log/nginx/bookwyrm.error.log;
listen [::]:443 ssl http2;
listen 443 ssl http2;
server_name bookwyrm.example.com;
# 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;
location / {
proxy_pass http://localhost:8001;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
}
location /images/ {
proxy_pass http://localhost:8001;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
}
location /static/ {
proxy_pass http://localhost:8001;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
}
}
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
Wechsle in das Bookwyrm-Verzeichnis.
$ cd ~/bookwyrm
Initialisiere die Datenbank. Die Ausführung des Befehls wird einige Minuten in Anspruch nehmen.
$ ./bw-dev migrate
Sobald er abgeschlossen ist, wirst du eine ähnliche Ausgabe sehen.
.............................. Applying django_celery_beat.0005_add_solarschedule_events_choices... OK Applying django_celery_beat.0006_auto_20180322_0932... OK Applying django_celery_beat.0007_auto_20180521_0826... OK Applying django_celery_beat.0008_auto_20180914_1922... OK Applying django_celery_beat.0006_auto_20180210_1226... OK Applying django_celery_beat.0006_periodictask_priority... OK Applying django_celery_beat.0009_periodictask_headers... OK Applying django_celery_beat.0010_auto_20190429_0326... OK Applying django_celery_beat.0011_auto_20190508_0153... OK Applying django_celery_beat.0012_periodictask_expire_seconds... OK Applying django_celery_beat.0013_auto_20200609_0727... OK Applying django_celery_beat.0014_remove_clockedschedule_enabled... OK Applying django_celery_beat.0015_edit_solarschedule_events_choices... OK Applying django_celery_beat.0016_alter_crontabschedule_timezone... OK Applying sessions.0001_initial... OK
Führe die Anwendung aus, indem du das Docker-Image für BookWyrm, Celery und Flower kompilierst.
$ docker compose up --build
Dieser Vorgang dauert mindestens 10-15 Minuten, je nach den Ressourcen deines Servers. Warte, bis die Kompilierung aller Images abgeschlossen ist. Deine endgültige Ausgabe sollte ungefähr so aussehen wie die folgende.
Sobald der Vorgang abgeschlossen ist, beende ihn mit der Tastenkombination Strg + C.
Du solltest etwas Ähnliches sehen, wenn der Prozess abgeschlossen ist.
bookwyrm-nginx-1 | 2023/09/13 10:20:33 [notice] 30#30: http file cache: /var/cache/nginx/bookwyrm_cache 0.000M, bsize: 4096 bookwyrm-nginx-1 | 2023/09/13 10:20:33 [notice] 1#1: signal 17 (SIGCHLD) received from 30 bookwyrm-nginx-1 | 2023/09/13 10:20:33 [notice] 1#1: cache loader process 30 exited with code 0 bookwyrm-nginx-1 | 2023/09/13 10:20:33 [notice] 1#1: signal 29 (SIGIO) received bookwyrm-redis_broker-1 | 1:M 13 Sep 2023 10:24:32.018 * 100 changes in 300 seconds. Saving... bookwyrm-redis_broker-1 | 1:M 13 Sep 2023 10:24:32.018 * Background saving started by pid 21 bookwyrm-redis_broker-1 | 21:C 13 Sep 2023 10:24:32.022 * DB saved on disk bookwyrm-redis_broker-1 | 21:C 13 Sep 2023 10:24:32.023 * Fork CoW for RDB: current 0 MB, peak 0 MB, average 0 MB bookwyrm-redis_broker-1 | 1:M 13 Sep 2023 10:24:32.119 * Background saving terminated with success ^CGracefully stopping... (press Ctrl+C again to force) Aborting on container exit... canceled
Initialisiere die Anwendung.
$ ./bw-dev setup
Dieser Prozess wird mit deinem Admin-Code abgeschlossen.
******************************************* Use this code to create your admin account: 299f3181-e57e-4f16-94c9-51cfc427b8df *******************************************
Du kannst den Code jederzeit abrufen, indem du den folgenden Befehl ausführst.
$ ./bw-dev admin_code ******************************************* Use this code to create your admin account: 299f3181-e57e-4f16-94c9-51cfc427b8df *******************************************
Der letzte Schritt bei der Installation von BookWyrm besteht darin, alle übrigen Container zu starten.
$ docker compose up -d
Du kannst den Status deiner Container mit folgendem Befehl überprüfen.
$ docker ps
Du solltest eine ähnliche Ausgabe erhalten.
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 083c2dfc81f4 nginx:latest "/docker-entrypoint.…" 26 hours ago Up 26 hours 80/tcp, 0.0.0.0:8001->8001/tcp, :::8001->8001/tcp bookwyrm-nginx-1 8618c3a7b460 bookwyrm-web "gunicorn bookwyrm.w…" 26 hours ago Up 26 hours 0.0.0.0:32768->8000/tcp, :::32768->8000/tcp bookwyrm-web-1 3e67c639e21f bookwyrm-celery_beat "celery -A celerywyr…" 26 hours ago Up 26 hours bookwyrm-celery_beat-1 86a774a5bb6d bookwyrm-flower "celery -A celerywyr…" 26 hours ago Up 26 hours bookwyrm-flower-1 ac2ff1e91bb4 bookwyrm-celery_worker "celery -A celerywyr…" 26 hours ago Up 26 hours bookwyrm-celery_worker-1 bc6a64fac55c redis "docker-entrypoint.s…" 26 hours ago Up 26 hours 6379/tcp bookwyrm-redis_activity-1 ef78760b967b bookwyrm-db "/bookwyrm-entrypoin…" 26 hours ago Up 26 hours 5432/tcp bookwyrm-db-1 5ededaed00ab redis "docker-entrypoint.s…" 26 hours ago Up 26 hours 6379/tcp bookwyrm-redis_broker-1
Du kannst den Status auch mit dem folgenden Befehl überprüfen.
$ docker compose ps
Die Ausgabe ist dann allerdings ein wenig anders.
Der nächste Schritt besteht darin, BookWyrm aufzurufen und deine Instanz einzurichten.
Schritt 10 – Zugriff auf BookWyrm
Öffne die URL https://bookwyrm.example.com in deinem Browser und du erhältst die folgende Seite.
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 für seine Docker-Installation ausgeliefert. Es enthält auch ein Dienstprogramm zum automatischen Löschen von Backups, das den Backup-Ordner automatisch bereinigt.
Die Backups werden im Verzeichnis backups des Datenbank-Containers erstellt. Die Sicherungen werden täglich um Mitternacht UTC erstellt. Führe den folgenden Befehl aus, um die SSH-Shell des Containers zu öffnen.
$ docker exec -it bookwyrm-db-1 bash
Sobald du dich im Container befindest, überprüfe den Inhalt des Backup-Verzeichnisses. Dieser Befehl zeigt die Sicherungen erst an, wenn seit der Erstellung des Containers 24 Stunden vergangen sind.
$ ls backups -al total 252 drwxr-xr-x. 2 root root 56 Sep 12 00:00 . drwxr-xr-x. 1 root root 39 Sep 11 11:47 .. -rw-r--r--. 1 root root 250380 Sep 12 00:00 backup_bookwyrm_2023-09-12.sql -rw-r--r--. 1 root root 44 Sep 11 11:47 .env
Verlasse die Shell.
$ exit
Du kannst die Backups auf deinen lokalen Rechner kopieren, indem du den folgenden Befehl ausführst.
$ docker cp bookwyrm-db-1:/backups <host machine path>
Die Funktion zur automatischen Bereinigung der Datenbank ist standardmäßig deaktiviert. Um sie zu aktivieren, öffne die Datei ~/bookwyrm/postgres-docker/cronfile zur Bearbeitung.
$ nano ~/bookwyrm/postgres-docker/cronfile
Hebe die Kommentare in der letzten Zeile auf, indem du die Raute (#) vor der Zeile entfernst. Deine cronfile sollte nun wie folgt aussehen.
0 0 * * * /usr/local/bin/bookwyrm-backup.sh # If uncommented, 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
Wenn du fertig bist, speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Das obige Skript speichert die letzten 14 Backups.
Baue deine Instanz neu auf.
$ cd ~/bookwyrm $ docker compose up --build
Schritt 12 – BookWyrm aktualisieren
Die Aktualisierung deiner BookWyrm-Instanz erfordert einige Schritte. Zuerst ziehst du die neuesten Änderungen aus dem BookWyrm GitHub Repository.
$ cd ~/bookwyrm $ git pull
Wenn es Konflikte gibt, musst du zuerst git pull separat ausführen.
Baue die Images neu.
$ docker compose rebuild
Führe Datenbankmigrationen mit den neu erstellten Docker-Images durch.
$ docker compose run --rm web python manage.py migrate
Kompiliere die BookWyrm Themes.
$ docker compose run --rm web python manage.py compile_themes
Lade alle aktualisierten statischen Dateien.
$ docker compose run --rm web python manage.py collectstatic --no-input
Schließe die vorhandenen Container.
$ docker compose down --remove-orphans
Starte die Container mit den neu erstellten Images neu.
$ docker compose up -d
Die Feeds für jeden Nutzer werden in der Redis-Datenbank gespeichert. Um einen Stream neu zu befüllen, führe den folgenden Befehl aus.
$ ./bw-dev populate_streams
Oder du kannst den folgenden Befehl verwenden, um die Streams neu zu befüllen.
$ docker compose run --rm web python manage.py populate_streams
Wenn das nicht funktioniert oder etwas kaputt geht, kannst du die Stream-Daten mit dem folgenden Befehl löschen.
$ docker compose run --rm web python manage.py erase_streams
Schritt 13 – BookWyrm Command Line Tool
Bis jetzt hast du gesehen, wie wir das bw-dev Kommandozeilen-Tool für BookWyrm verwenden. Dieses Tool kann viele nützliche Aufgaben erledigen und sogar Docker-Befehle ausführen. Einige der beliebten Anwendungen des Tools sind folgende.
Manuelles Bestätigen eines Benutzerkontos
Mit dem folgenden Befehl bestätigst du die E-Mail eines Benutzers (Benutzernamen) manuell und markierst ihn als aktiv.
$ ./bw-dev confirm_email <username>
Vorschaubilder generieren
Wenn du die Option Vorschaubilder später aktivierst, musst du sie für die zuvor hochgeladenen Daten aktualisieren. Führe den folgenden Befehl aus, um dies zu tun.
$ ./bw-dev generate_preview_images --all
Vorschaubilder für Buchcover generieren
Der folgende Befehl erzeugt Miniaturbilder für die Buchumschläge.
$ ./bw-dev generate_thumbnails
Dies sind nur einige der Optionen. Eine vollständige Liste findest du im BookWyrm CLI-Handbuch.
Fazit
Damit ist unser Tutorium zur Installation des sozialen Netzwerks BookWyrm auf einem Rocky Linux 9 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.