So installierst du den Reddit-ähnlichen Content Aggregator Lemmy auf Ubuntu 22.04
Lemmy ist ein quelloffener Reddit-ähnlicher Content-Aggregator und eine Microblogging-Plattform für das Fediversum. Mit Lemmy kannst du Communities erstellen und moderieren und mit anderen ActivityPub-Diensten wie Mastodon, Pleroma und Peertube kommunizieren.
Es gibt beliebte Instanzen von Lemmy, denen du beitreten und die du nutzen kannst, aber du kannst auch deine eigene Lemmy-Instanz für deine Freunde und Familie betreiben. In diesem Lernprogramm erfährst du, wie du Lemmy auf einem Ubuntu 22.04 Server installierst.
Voraussetzungen
- Ein Server, auf dem Ubuntu 22.04 läuft.
- Ein sudo-Benutzer ohne Root-Rechte.
- Ein vollständig qualifizierter Domainname (FQDN) wie
example.com. - Stelle sicher, dass alles auf dem neuesten Stand ist.
$ sudo apt update $ sudo apt upgrade
- Ein paar Pakete, die dein System benötigt.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-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. Ubuntu 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 – Installiere Docker und Docker Compose
Ubuntu 22.04 wird mit einer älteren Version von Docker ausgeliefert. Um die neueste Version zu installieren, importiere zunächst den Docker GPG-Schlüssel.
$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo gpg --dearmor -o /usr/share/keyrings/docker.gpg
Erstelle eine Docker-Repository-Datei.
$ echo \ "deb [arch="$(dpkg --print-architecture)" signed-by=/usr/share/keyrings/docker.gpg] https://download.docker.com/linux/ubuntu \ "$(. /etc/os-release && echo "$VERSION_CODENAME")" stable" | \ sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
Aktualisiere die Liste der System-Repositorys.
$ sudo apt update
Installiere die neueste Version von Docker.
$ sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
Überprüfe, ob sie läuft.
$ sudo systemctl status docker
? docker.service - Docker Application Container Engine
Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
Active: active (running) since Fri 2023-08-04 07:48:20 UTC; 4min 29s ago
TriggeredBy: ? docker.socket
Docs: https://docs.docker.com
Main PID: 2372 (dockerd)
Tasks: 8
Memory: 23.9M
CPU: 295ms
CGroup: /system.slice/docker.service
??2372 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock
Standardmäßig benötigt Docker Root-Rechte. Wenn du vermeiden willst, dass du jedes Mal sudo verwendest, wenn du den Befehl docker ausführst, füge deinen Benutzernamen der Gruppe docker hinzu.
$ sudo usermod -aG docker $(whoami)
Um diese Änderung zu aktivieren, musst du dich vom Server abmelden und als derselbe Benutzer wieder anmelden oder den folgenden Befehl verwenden.
$ su - ${USER}
Bestätige, dass dein Benutzer der Docker-Gruppe hinzugefügt wurde.
$ groups navjot wheel docker
Schritt 3 – Lemmy-Dateien erstellen und herunterladen
Erstelle einen Ordner für Lemmy.
$ mkdir ~/lemmy
Wechsle in das Verzeichnis.
$ cd ~/lemmy
Nimm die benutzerdefinierte Nginx-Datei, um mit Docker zu arbeiten.
$ wget https://raw.githubusercontent.com/LemmyNet/lemmy-ansible/main/templates/nginx_internal.conf
Nimm die Docker compose Datei.
$ wget https://raw.githubusercontent.com/LemmyNet/lemmy-ansible/main/templates/docker-compose.yml
Erstelle einen Ordner für die Pictrs-Anwendung.
$ mkdir -p volumes/pict-rs
Setze die richtigen Berechtigungen für das Verzeichnis.
$ sudo chown -R 991:991 volumes/pict-rs
Schritt 4 – Lemmy konfigurieren
Bevor wir mit der Installation fortfahren, müssen wir die Dateien, die wir heruntergeladen haben, bearbeiten.
Öffne die Docker compose Datei zum Bearbeiten.
$ nano docker-compose.yml
Nimm die folgenden Änderungen in der Datei vor:
- Ersetze in der Datei die Variable
{{ lemmy_port }}durch8536. - Ersetze in der Datei die Variable
{{ lemmy_docker_image }}durchdessalines/lemmy:0.18.3. Du kannst die neueste Version des Docker-Images von Lemmy von der Docker Hub Seite herunterladen. Für die Seite musst du ein Docker-Konto haben. Alternativ kannst du die Version auch von der Github-Releaseseite abrufen. - Ersetze die Variable
{{ lemmy_docker_ui_image }}durchdessalines/lemmy-ui:0.18.3in der Datei. Achte darauf, dass die Version mit Lemmys Docker-Image übereinstimmt, sonst wird es nicht funktionieren. - Erstelle einen API-Schlüssel für pict-rs mit dem folgenden Befehl.
$ openssl rand -base64 32 lRLcaM5rovxzmztlDvtkGijJyBtg4KlEKC6HRb3dn7s=
Der Schlüssel
PICTRS__API_KEYunter dem Umgebungsattribut unter dem Dienstpictrsist falsch konfiguriert, so dass er das PostgreSQL-Passwort sein sollte. Ersetze die Variable{{ postgres_password }}über die API-Schlüsselvariable mit dem Schlüssel, der mit dem obigen Befehl erzeugt wurde. - Ersetze die Variable
{{ domain }}in der Datei durch deinen voll qualifizierten Domainnamen für deine Lemmy-Instanz. - Ersetze die Variable
{{ postgres_password }}durch ein sicheres Passwort deiner Wahl für den PostgreSQL-Server. - Ersetze die bestehende Umgebungsvariable
RUST_LOGdurch die folgende.- RUST_LOG="warn,lemmy_server=debug,lemmy_api=debug,lemmy_api_common=debug,lemmy_api_crud=debug,lemmy_apub=debug,lemmy_db_schema=debug,lemmy_db_views=debug,lemmy_db_views_actor=debug,lemmy_db_views_moderator=debug,lemmy_routes=debug,lemmy_utils=debug,lemmy_websocket=debug" - RUST_BACKTRACE=full
- Füge den folgenden Abschnitt unter der Eigenschaft
hostnamefür den PostgreSQL-Dienst hinzu.command: [ "postgres", "-c", "session_preload_libraries=auto_explain", "-c", "auto_explain.log_min_duration=5ms", "-c", "auto_explain.log_analyze=true", "-c", "track_activity_query_size=1048576", ] ports: # use a different port so it doesnt conflict with potential postgres db running on the host - "5433:5432"
Speichere die Datei, indem du die Tastenkombination Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst. Als Nächstes erstellst du die Datei lemmy.hjson und öffnest sie zur Bearbeitung.
$ nano lemmy.hjson
Füge den folgenden Code ein.
{
# for more info about the config, check out the documentation
# https://join-lemmy.org/docs/en/administration/configuration.html
database: {
host: "postgres"
user: "lemmy"
password: "yourpsqlpassword"
database: "lemmy"
port: 5432
}
hostname: "example.com"
pictrs: {
url: "http://pictrs:8080/"
# Set a custom pictrs API key. ( Required for deleting images )
api_key: "lRLcaM5rovxzmztlDvtkGijJyBtg4KlEKC6HRb3dn7s="
}
email: {
smtp_server: "email-smtp.us-west-2.amazonaws.com:465"
smtp_login: "AmazonSESUserID"
smtp_password:"AmazonSESPassword"
smtp_from_address: "noreply@example.com"
# Whether or not smtp connections should use tls. Can be none, tls, or starttls
tls_type: "tls"
}
setup: {
# Username for the admin user
admin_username: "admin"
# Password for the admin user. It must be at least 10 characters.
admin_password: "tf6HHDS4RolWfFhk4Rq9"
# Name of the site (can be changed later)
site_name: "Howtoforge Lemmy"
# Email for the admin user (optional, can be omitted and set later through the website)
admin_email: "navjot@example.com"
}
}
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Im nächsten Schritt musst du eine benutzerdefinierte PostgreSQL-Konfigurationsdatei erstellen, um die Datenbank zu optimieren. Besuche die PGTune-Website, um Werte zu generieren, die von deiner Servergröße abhängen.
Gib die Serverwerte ein und klicke auf die Schaltfläche Generieren, um die benutzerdefinierte Konfiguration zu erstellen.
Erstelle und öffne die Datei customPostgresql.conf zum Bearbeiten.
$ nano customPostgresql.conf
Füge den Code ein, den du von PGTune erhalten hast.
# DB Version: 15 # OS Type: linux # DB Type: web # Total Memory (RAM): 2 GB # CPUs num: 2 # Connections num: 100 # Data Storage: ssd max_connections = 100 shared_buffers = 512MB effective_cache_size = 1536MB maintenance_work_mem = 128MB checkpoint_completion_target = 0.9 wal_buffers = 16MB default_statistics_target = 100 random_page_cost = 1.1 effective_io_concurrency = 200 work_mem = 2621kB min_wal_size = 1GB max_wal_size = 4GB
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 5 – Lemmy installieren
Jetzt, da alle Dateien konfiguriert sind, ist es an der Zeit, Lemmy zu starten. Führe den folgenden Befehl aus, um die Docker-Container zu starten.
$ docker compose up -d
Überprüfe den Status der Container.
$ docker ps CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES 75443bb3db3e nginx:1-alpine "/docker-entrypoint.…" 32 seconds ago Up 29 seconds 80/tcp, 0.0.0.0:8536->8536/tcp, :::8536->8536/tcp lemmy-proxy-1 8393c8d625af dessalines/lemmy-ui:0.18.1 "docker-entrypoint.s…" 32 seconds ago Up 30 seconds 1234/tcp lemmy-lemmy-ui-1 ea743c8279f7 dessalines/lemmy:0.18.1 "/app/lemmy" 32 seconds ago Up 26 seconds lemmy-lemmy-1 78855ae7871e postgres:15-alpine "docker-entrypoint.s…" 33 seconds ago Up 31 seconds 5432/tcp lemmy-postgres-1 9556b57afdb9 asonix/pictrs:0.4.0 "/sbin/tini -- /usr/…" 33 seconds ago Up 31 seconds 6669/tcp, 8080/tcp lemmy-pictrs-1
Du kannst den Status auch mit Docker Compose überprüfen.
$ docker compose ps NAME IMAGE COMMAND SERVICE CREATED STATUS PORTS lemmy-lemmy-1 dessalines/lemmy:0.18.1 "/app/lemmy" lemmy About a minute ago Up About a minute lemmy-lemmy-ui-1 dessalines/lemmy-ui:0.18.1 "docker-entrypoint.s…" lemmy-ui About a minute ago Up About a minute 1234/tcp lemmy-pictrs-1 asonix/pictrs:0.4.0 "/sbin/tini -- /usr/…" pictrs About a minute ago Up About a minute 6669/tcp, 8080/tcp lemmy-postgres-1 postgres:15-alpine "docker-entrypoint.s…" postgres About a minute ago Up About a minute 5432/tcp lemmy-proxy-1 nginx:1-alpine "/docker-entrypoint.…" proxy About a minute ago Up About a minute 80/tcp, 0.0.0.0:8536->8536/tcp, :::8536->8536/tcp
Du kannst es testen, indem du die URL http://<server_IP>:8536/ öffnest. Dann solltest du die Homepage von Lemmy sehen. Damit ist alles in Ordnung. Der nächste Schritt besteht darin, Nginx und Certbot zu installieren, um Lemmy über einen Domainnamen zu bedienen.
Schritt 6 – 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.24.0
Starte Nginx.
$ 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; vendor preset: enabled)
Active: active (running) since Fri 2023-08-04 09:01:56 UTC; 3s ago
Docs: https://nginx.org/en/docs/
Process: 5297 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 5298 (nginx)
Tasks: 2 (limit: 2308)
Memory: 1.9M
CPU: 7ms
CGroup: /system.slice/nginx.service
??5298 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??5299 "nginx: worker process" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" "" ""
Schritt 7 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erstellen. 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 && 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
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 example.com
Mit dem obigen Befehl wird ein Zertifikat in das Verzeichnis /etc/letsencrypt/live/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 Fri 2023-08-04 09:50:30 UTC 46min left Fri 2023-08-04 01:49:37 UTC 7h ago apt-daily.timer apt-daily.service Sat 2023-08-05 00:00:00 UTC 14h left Wed 2023-06-28 04:41:28 UTC 5h 7min ago dpkg-db-backup.timer dpkg-db-backup.service Fri 2023-08-04 18:54:00 UTC 9h left n/a n/a 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 8 – Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/lemmy.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/lemmy.conf
Füge den folgenden Code in die Datei ein.
limit_req_zone $binary_remote_addr zone=example.com_ratelimit:10m rate=1r/s;
server {
listen 80;
listen [::]:80;
server_name example.com;
# Hide nginx version
server_tokens off;
location / {
return 301 https://$host$request_uri;
}
}
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name example.com;
access_log /var/log/nginx/lemmy.access.log;
error_log /var/log/nginx/lemmy.error.log;
ssl_certificate /etc/letsencrypt/live/example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/example.com/chain.pem;
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:DHE-RSA-CHACHA20-POLY1305;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_session_timeout 1d;
ssl_session_cache shared:SSL:10m;
ssl_session_tickets off;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# use https://blog.cloudflare.com/announcing-1111 Cloudfare+Apnic labs, It is free and secure
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] valid=300s;
# Hide nginx version
server_tokens off;
# Enable compression for JS/CSS/HTML bundle, for improved client load times.
# It might be nice to compress JSON, but leaving that out to protect against potential
# compression+encryption information leak attacks like BREACH.
gzip on;
gzip_types text/css application/javascript image/svg+xml;
gzip_vary on;
# Various content security headers
add_header Referrer-Policy "same-origin";
add_header X-Content-Type-Options "nosniff";
add_header X-Frame-Options "DENY";
add_header X-XSS-Protection "1; mode=block";
location / {
proxy_pass http://localhost:8536;
proxy_http_version 1.1;
proxy_set_header Upgrade $http_upgrade;
proxy_set_header Connection "upgrade";
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header Host $host;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
Beachte, dass das Stammverzeichnis, das in der Nginx-Konfiguration verwendet werden soll, /var/www/html/Lemmy/public/ ist.
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du danach gefragt wirst.
Ö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.
Ü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.
$ sudo systemctl restart nginx
Schritt 9 – Zugriff auf Lemmy
Öffne die URL https://example.com und du erhältst die folgende Lemmy-Homepage.
Klicke oben auf den Link Login, um die Anmeldeseite aufzurufen.
Gib die in Schritt 4 verwendeten Anmeldedaten ein und klicke auf die Schaltfläche Login, um fortzufahren. Du gelangst zurück zur Lemmy-Startseite. Von nun an kannst du Lemmy benutzen.
Schritt 10 – Upgrade von Lemmy
Um Lemmy zu aktualisieren, öffne die Datei docker-compose.yml im Ordner ~/lemmy.
$ cd ~/lemmy $ nano docker-compose.yml
Ändere die Versionsnummern der Apps, Lemmy, Lemmy-UI und Pictrs in der Datei. Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schalte die Lemmy-Container aus.
$ docker compose down --remove-orphan
Starte die Container wieder mit der neuen Konfiguration.
$ docker compose up -d
Schritt 11 – Lemmy sichern und wiederherstellen
Um Lemmy zu sichern, müssen wir einen Dump der Datenbank und des Volume-Ordners erstellen. Führe die folgenden Befehle aus, um ein Backup der Datenbank zu erstellen.
$ cd ~/lemmy $ docker compose exec postgres pg_dumpall -c -U lemmy | gzip > lemmy_dump_`date +%Y-%m-%d"_"%H_%M_%S`.sql.gz
Im obigen Befehl ist postgres der Dienstname für PostgreSQL in der Compose-Datei.
Als Nächstes erstellst du mit dem folgenden Befehl ein Backup des Volumes-Ordners.
$ sudo rsync -avP volumes ~/backup/lemmy
Du kannst das folgende Backup-Skript verwenden und es von deinem lokalen System aus ausführen, um das Backup aus der Ferne zu erstellen.
#!/bin/sh # DB Backup ssh USERNAME@SERVER_IP "docker-compose exec postgres pg_dumpall -c -U lemmy" | gzip > ~/BACKUP_LOCATION/INSTANCE_NAME_dump_`date +%Y-%m-%d"_"%H_%M_%S`.sql.gz # Volumes folder Backup rsync -avP -zz --rsync-path="sudo rsync" USERNAME@SERVER_IP:/LEMMY_LOCATION/volumes ~/BACKUP_LOCATION/FOLDERNAME
Lemmy-Datenbank wiederherstellen
Um die Datenbank bei einer neuen Lemmy-Installation wiederherzustellen, führe die folgenden Befehle aus.
# Start only the PostgreSQL container first $ docker compose up -d postgres # Restore from the .sql.gz backup $ gunzip < db_dump.sql | docker-compose exec -T postgres psql -U lemmy # Note: You may need to change the permissions on the postgres directory, depending on your system. $ chown -R $USER volumes $ docker compose restart postgres # Continue with the startup $ docker compose up -d
Wenn du Lemmy versehentlich zuerst gestartet hast, musst du die bestehende Datenbank mit den folgenden Befehlen löschen.
# Drop the existing DB docker exec -i FOLDERNAME-postgres-1 psql -U lemmy -c "DROP SCHEMA public CASCADE; CREATE SCHEMA public;" # This also might be necessary when doing a db import with a different password. docker exec -i FOLDERNAME-postgres-1 psql -U lemmy -c "alter user lemmy with password 'bleh'"
Jetzt kannst du die oben genannten Wiederherstellungsbefehle ausführen.
Fazit
Damit ist unsere Anleitung zur Installation des Reddit-ähnlichen Content Aggregators Lemmy auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.