So installierst du den Reddit-ähnlichen Fediverse Content Aggregator Kbin auf Ubuntu 22.04
Kbin ist ein quelloffener Reddit-ähnlicher Content-Aggregator und eine Microblogging-Plattform für das Fediversum. Mit Kbin kannst du Communities erstellen und moderieren und mit anderen ActivityPub-Diensten wie Mastodon, Pleroma und Peertube kommunizieren.
Es gibt beliebte Instanzen von Kbin, denen du beitreten und die du nutzen kannst, aber du kannst auch deine eigene Kbin-Instanz für deine Freunde und Familie betreiben. In dieser Anleitung lernst du, wie du Kbin 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.
- Unsere Installation benötigt außerdem eine Zugriffskontrollliste (Access Control List, ACL), um zu funktionieren. Installiere sie.
$ sudo apt install acl
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 läuft.
$ 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 – Git installieren
Git wird normalerweise mit dem Ubuntu-Server installiert, aber wenn nicht, solltest du es mit dem folgenden Befehl installieren.
$ sudo apt install git
Überprüfe die Installation.
$ git --version git version 2.34.1
Konfiguriere Git mit den grundlegenden Informationen.
$ git config --global user.name "Your Name" $ git config --global user.email "youremail@example.com"
Schritt 3 – Nginx installieren
Ubuntu 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 den Nginx-Server.
$ sudo systemctl start nginx
Schritt 4 – Installiere PHP und konfiguriere PHP
Ubuntu 22.04 wird mit der Version PHP 8.1.2 ausgeliefert, die ein wenig veraltet ist. Wir werden die neueste Version von PHP 8.2 mit Hilfe von Ondrejs PHP-Repository installieren.
$ sudo add-apt-repository ppa:ondrej/php
Als Nächstes installierst du PHP und die von Kbin benötigten Erweiterungen.
$ sudo apt install php8.2-common php8.2-fpm php8.2-cli php8.2-amqp php8.2-pgsql php8.2-gd php8.2-curl php8.2-simplexml php8.2-dom php8.2-xml php8.2-redis php8.2-mbstring php8.2-intl unzip
Überprüfe die Installation.
$ php --version
PHP 8.2.7 (cli) (built: Jun 8 2023 15:27:40) (NTS)
Copyright (c) The PHP Group
Zend Engine v4.2.7, Copyright (c) Zend Technologies
with Zend OPcache v8.2.7, Copyright (c), by Zend Technologies
Öffne die Datei /etc/php/8.2/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf
Wir müssen den Unix-Benutzer/die Unix-Gruppe der PHP-Prozesse auf nginx setzen. Finde die Zeilen user=www-data und group=www-data in der Datei und ändere sie in nginx.
... ; Unix user/group of processes ; Note: The user is mandatory. If the group is not set, the default user's group ; will be used. ; RPM: apache user chosen to provide access to the same directories as httpd user = nginx ; RPM: Keep a group allowed to write in log dir. group = nginx ...
Finde die Zeilen listen.owner = www-data und listen.group = www-data in der Datei und ändere sie in nginx.
; Set permissions for unix socket, if one is used. In Linux, read/write ; permissions must be set in order to allow connections from a web server. Many ; BSD-derived systems allow connections regardless of permissions. The owner ; and group can be specified either by name or by their numeric IDs. ; Default Values: user and group are set as the running user ; mode is set to 0660 listen.owner = nginx listen.group = nginx
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Erhöhe das Speicherlimit für PHP-FPM von 128 MB auf 512 MB.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php/8.2/fpm/php.ini
Erhöhe die Datei-Upload-Größe auf 8 MB.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 8M/' /etc/php/8.2/fpm/php.ini
Starte den PHP-FPM-Dienst neu.
$ sudo systemctl restart php8.2-fpm
Ändere die Gruppe des PHP-Sessions-Verzeichnisses auf Nginx.
$ sudo chgrp -R nginx /var/lib/php/sessions
Schritt 5 – Installiere Composer
Composer ist ein Tool zur Verwaltung von Abhängigkeiten für PHP und wird für die Installation von Kbin benötigt. Hol dir die Composer-Setup-Datei.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Führe das Installationsprogramm aus, um die Composer-Binärdatei zu erzeugen.
$ php composer-setup.php
Entferne die Setup-Datei.
$ php -r "unlink('composer-setup.php');"
Verschiebe die Binärdatei composer.phar in das Verzeichnis /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Überprüfe die Installation des Composers.
$ composer --version Composer version 2.5.8 2023-06-09 17:13:21
Schritt 6 – 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; vendor preset: enabled)
Active: active (exited) since Sat 2023-06-17 09:15:50 UTC; 3h 40min ago
Main PID: 26989 (code=exited, status=0/SUCCESS)
CPU: 1ms
Jun 17 09:15:50 nspeaks systemd[1]: Starting PostgreSQL RDBMS...
Jun 17 09:15:50 nspeaks systemd[1]: Finished 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 Kbin-Datenbank.
postgres=# CREATE DATABASE kbin;
Erstelle den Benutzer Kbin und wähle ein sicheres Passwort.
postgres-# CREATE USER kbinuser WITH PASSWORD 'Your_Password';
Ändere den Eigentümer der Datenbank auf den Benutzer Kbin.
postgres-# ALTER DATABASE kbin OWNER TO kbinuser;
Beende die Shell.
postgres-# \q
Überprüfe, ob deine Anmeldedaten funktionieren.
$ psql --username kbinuser --password --host localhost kbin Password: psql (15.3 (Ubuntu 15.3-1.pgdg22.04+1)) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off) Type "help" for help. kbin=>
Beende die Shell, indem du \q eingibst.
Schritt 7 – Installiere Nodejs und Yarn
Ubuntu 22.04 wird mit Node v12 ausgeliefert, das nicht mehr aktuell ist. Wir werden die neueste LTS-Version von Node installieren, die zum Zeitpunkt der Erstellung dieses Tutorials v18 ist.
Hol dir den Node v18 Installer von NodeSource.
$ curl -sL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh
Führe das Installer-Skript aus.
$ sudo bash nodesource_setup.sh
Installiere Node.js.
$ sudo apt install nodejs
Überprüfe die Node.js-Version.
$ node -v v18.16.1
Lösche die Installer-Datei.
$ rm nodesource_setup.sh
Schritt 8 – Yarn installieren
Importiere den GPG-Schlüssel für Yarn.
$ curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | gpg --dearmor | sudo tee /usr/share/keyrings/yarnkey.gpg >/dev/null
Füge die Yarn-Quelle zur Liste der System-Repositories hinzu.
$ echo "deb [signed-by=/usr/share/keyrings/yarnkey.gpg] https://dl.yarnpkg.com/debian stable main" | sudo tee /etc/apt/sources.list.d/yarn.list
Aktualisiere die Liste deiner System-Repositories.
$ sudo apt update
Installiere Yarn
$ sudo apt install yarn
Überprüfe die Installation.
$ yarn --version 1.22.19
Schritt 8 – Redis installieren
Magento verwendet Redis als Session- 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.0.11 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=3af367a78d5e21e9
Ü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 9 – RabbitMQ installieren und konfigurieren
Kbin benötigt RabbitMQ für das Message Queuing. Wir werden es aus dem Ubuntu-Repository installieren.
$ sudo apt install rabbitmq-server
Erstelle einen Rabbit-Benutzer. Wähle ein sicheres Passwort.
$ sudo rabbitmqctl add_user kbin StrongPassword
Erstelle den Benutzer als Administrator.
$ sudo rabbitmqctl set_user_tags kbin administrator
Schritt 10 – Kbin herunterladen
Bevor wir Kbin herunterladen, müssen wir ein Kbin-Benutzerkonto erstellen.
$ adduser kbin
Füge den Benutzer kbin zur Gruppe sudo hinzu.
$ sudo usermod -aG sudo kbin
Melde dich als der Benutzer kbin an.
$ su - kbin
Erstelle das Verzeichnis /var/www/html/kbin.
$ sudo mkdir /var/wwww/html/kbin -p
Wechsle in das Verzeichnis.
$ cd /var/www/html/kbin
Gib dem Ordner die richtigen Berechtigungen, damit der aktuell angemeldete Benutzer Aufgaben ausführen kann.
$ sudo chown $USER:$USER kbin
Klone das Kbin-Git-Repository in den aktuellen Ordner. Achte darauf, den Punkt(.) am Ende des Befehls hinzuzufügen, um auf den aktuellen Ordner zu verweisen.
$ git clone https://codeberg.org/Kbin/kbin-core.git .
Erstelle das Verzeichnis public/media.
$ mkdir public/media
Gib ihm volle Berechtigung.
$ chmod 777 public/media
Schritt 11 – Umgebungsdatei konfigurieren
Erstelle den geheimen Mercure JWT-Schlüssel.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Erstelle das App-Geheimnis mit demselben Befehl.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Erstelle und öffne die Datei .env im Kbin-Verzeichnis zur Bearbeitung.
$ nano .env
Füge den folgenden Code in die Datei ein. Verwende die oben generierten Schlüssel in der folgenden Datei.
# Run "composer dump-env prod" to compile .env files for production use (requires symfony/flex >=1.2).
# https://symfony.com/doc/current/best_practices.html#use-environment-variables-for-infrastructure-configuration
# kbin variables
SERVER_NAME="nspeaks.xyz" # production
KBIN_DOMAIN=nspeaks.xyz
KBIN_TITLE=Howtoforge
KBIN_DEFAULT_LANG=en
KBIN_FEDERATION_ENABLED=true
KBIN_CONTACT_EMAIL=contact@nspeaks.com
KBIN_SENDER_EMAIL=noreply@nspeaks.com
KBIN_JS_ENABLED=true
KBIN_REGISTRATIONS_ENABLED=true
KBIN_API_ITEMS_PER_PAGE=25
#KBIN_STORAGE_URL=/media
KBIN_META_TITLE="Kbin Lab"
KBIN_META_DESCRIPTION="content aggregator and micro-blogging platform for the fediverse"
KBIN_META_KEYWORDS="kbin, content agregator, open source, fediverse"
KBIN_HEADER_LOGO=false
KBIN_CAPTCHA_ENABLED=false
# Redis
REDIS_PASSWORD=YourRedisPassword
REDIS_DNS=redis://default:${REDIS_PASSWORD}@localhost:6379
###> symfony/framework-bundle ###
APP_ENV=prod
APP_SECRET=427f5e2940e5b2472c1b44b2d06e0525
###< symfony/framework-bundle ###
###> doctrine/doctrine-bundle ###
# Format described at https://www.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/configuration.html#connecting-using-a-url
# IMPORTANT: You MUST configure your server version, either here or in config/packages/doctrine.yaml
#
POSTGRES_DB=kbin
POSTGRES_USER=kbin
POSTGRES_PASSWORD=Your_Password
POSTGRES_VERSION=15
DATABASE_URL="postgresql://${POSTGRES_USER}:${POSTGRES_PASSWORD}@127.0.0.1:5432/${POSTGRES_DB}?serverVersion=${POSTGRES_VERSION}&charset=utf8"
###< doctrine/doctrine-bundle ###
###> symfony/messenger ###
# Choose one of the transports below
RABBITMQ_PASSWORD=RabbitMQPassword
MESSENGER_TRANSPORT_DSN=amqp://kbin:${RABBITMQ_PASSWORD}@rabbitmq:5672/%2f/messages
#MESSENGER_TRANSPORT_DSN=doctrine://default
#MESSENGER_TRANSPORT_DSN=redis://${REDIS_PASSWORD}@redis:6379/messages
###< symfony/messenger ###
###> symfony/mailgun-mailer ###
#MAILER_DSN=mailgun+smtp://postmaster@sandboxxx.mailgun.org:key@default?region=us
MAILER_DSN=smtp://AKIA3FIG4NVFH4TXXEXY:BJQvNI9U6JqSuUFQ9Ffd22Dvom/8KNwk7EIrFTRai02/@email-smtp.us-west-2.amazonaws.com:465
###< symfony/mailgun-mailer ###
###> symfony/mercure-bundle ###
# See https://symfony.com/doc/current/mercure.html#configuration
# The URL of the Mercure hub, used by the app to publish updates (can be a local URL)
MERCURE_URL=https://example.com/.well-known/mercure
# The public URL of the Mercure hub, used by the browser to connect
MERCURE_PUBLIC_URL=https://example.com/.well-known/mercure
# The secret used to sign the JWTs
MERCURE_JWT_SECRET="!ChangeThisMercureHubJWTSecretKey!"
###< symfony/mercure-bundle ###
###> symfony/lock ###
LOCK_DSN=flock
###< symfony/lock ###
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Schritt 12 – Kbin installieren
Installiere die Pakete, die für Kbin benötigt werden, mit Composer.
$ composer install --prefer-dist --no-dev $ composer dump-env prod
Lösche den Cache.
$ APP_ENV=prod APP_DEBUG=0 php bin/console cache:clear $ composer clear-cache
Gib dem Medienordner die richtigen Berechtigungen.
$ sudo chown kbin:nginx public/media
Setze die richtigen Datei- und Verzeichnisberechtigungen mit dem Befehl setfacl. Der folgende Befehl erkennt den aktuell verwendeten Webserver (Nginx) und setzt die Berechtigungen für die bestehenden und zukünftigen Dateien und Ordner.
$ HTTPDUSER=$(ps axo user,comm | grep -E '[a]pache|[h]ttpd|[_]www|[w]ww-data|[n]ginx' | grep -v root | head -1 | cut -d\ -f1) $ sudo setfacl -dR -m u:"$HTTPDUSER":rwX -m u:$(whoami):rwX var $ sudo setfacl -R -m u:"$HTTPDUSER":rwX -m u:$(whoami):rwX var
Erstelle und migriere die PostgreSQL-Datenbank.
$ php bin/console doctrine:database:create $ php bin/console doctrine:migrations:migrate
Du wirst gefragt, ob du mit der Datenmigration fortfahren möchtest. Gib yes ein, um fortzufahren.
WARNING! You are about to execute a migration in database "kbin" that could result in schema changes and data loss. Are you sure you wish to continue? (yes/no) [yes]: > yes [notice] Migrating up to DoctrineMigrations\Version20230615203020 [notice] finished in 1373.9ms, used 24M memory, 79 migrations executed, 667 sql queries [OK] Successfully migrated to version : DoctrineMigrations\Version20230615203020
Installiere und erstelle das öffentliche Frontend für die Kbin-Site.
$ yarn install $ yarn build
Erstelle einen neuen Administrator-Benutzer für Kbin.
$ php bin/console kbin:user:create username email@example.com password
Erteile dem Benutzer administrative Rechte.
$ php bin/console kbin:user:admin username
Aktualisiere die Keys.
$ php bin/console kbin:ap:keys:update
Schritt 13 – SSL installieren
Wir müssen Certbot installieren, um das SSL-Zertifikat zu erzeugen. Du kannst Certbot entweder über das Ubuntu-Repository 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 Wed 2023-06-28 10:09:00 UTC 20min left Wed 2023-06-28 09:39:00 UTC 9min ago phpsessionclean.timer phpsessionclean.service Wed 2023-06-28 11:13:02 UTC 1h 24min left Wed 2023-06-28 04:41:28 UTC 5h 7min ago ua-timer.timer ua-timer.service Wed 2023-06-28 12:11:00 UTC 2h 22min 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 14 – Nginx konfigurieren
Erstelle und öffne die Datei /etc/nginx/conf.d/kbin.conf zum Bearbeiten.
$ sudo nano /etc/nginx/conf.d/kbin.conf
Füge den folgenden Code in die Datei ein.
server {
listen 443 ssl http2;
listen [::]:443 ssl http2;
server_name example.com;
access_log /var/log/nginx/kbin.access.log;
error_log /var/log/nginx/kbin.error.log;
# SSL
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_session_timeout 1d;
ssl_session_cache shared:SSL:50m;
ssl_session_tickets off;
ssl_protocols TLSv1.2 TLSv1.3;
ssl_prefer_server_ciphers on;
ssl_ciphers ECDHE-ECDSA-AES128-GCM-SHA256:ECDHE-RSA-AES128-GCM-SHA256:ECDHE-ECDSA-AES256-GCM-SHA384:ECDHE-RSA-AES256-GCM-SHA384:ECDHE-ECDSA-CHACHA20-POLY1305:ECDHE-RSA-CHACHA20-POLY1305:DHE-RSA-AES128-GCM-SHA256:DHE-RSA-AES256-GCM-SHA384;
ssl_ecdh_curve X25519:prime256v1:secp384r1:secp521r1;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
# 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;
root /var/www/html/kbin/public;
index index.php;
location / {
try_files $uri $uri/ /index.php;
}
# Pass PHP Scripts To FastCGI Server
location ~* \.php$ {
try_files $uri =404;
fastcgi_index index.php;
fastcgi_pass unix:/run/php-fpm/www.sock; # Depends On The PHP Version
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT $realpath_root;
include fastcgi_params;
}
# deny access to writable files/directories
location ~* ^/sites/*/(documents|edi|era) {
deny all;
return 404;
}
# deny access to certain directories
location ~* ^/(contrib|tests) {
deny all;
return 404;
}
# Alternatively all access to these files can be denied
location ~* ^/(admin|setup|acl_setup|acl_upgrade|sl_convert|sql_upgrade|gacl/setup|ippf_upgrade|sql_patch)\.php {
deny all;
return 404;
}
location = /favicon.ico {
log_not_found off;
access_log off;
}
location = /robots.txt {
log_not_found off;
access_log off;
}
location ~ /\. {
deny all;
}
}
# enforce HTTPS
server {
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
Beachte, dass das Stammverzeichnis, das in der Nginx-Konfiguration verwendet werden soll, /var/www/html/kbin/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 15 – Supervisor installieren und konfigurieren
Supervisor ist ein Prozessmanager und wir werden ihn als Prozessmonitor für Message Worker (RabbitMQ) für Kbin verwenden. Der erste Schritt ist die Installation von Supervisor.
$ sudo apt install supervisor
Erstelle die Datei /etc/supervisor/conf.d/messenger-worker.conf und öffne sie zum Bearbeiten.
$ sudo nano /etc/supervisor/conf.d/messenger-worker.conf
Füge den folgenden Code in die Datei ein.
[program:messenger-kbin] command=php /var/www/html/kbin/bin/console messenger:consume async --time-limit=3600 user=kbin numprocs=2 startsecs=0 autostart=true autorestart=true startretries=10 process_name=%(program_name)s_%(process_num)02d stderr_logfile=/var/log/supervisor/%(program_name)s_stderr.log stderr_logfile_maxbytes=10MB stdout_logfile=/var/log/supervisor/%(program_name)s_stdout.log stdout_logfile_maxbytes=10MB [program:messenger-ap] command=php /var/www/html/kbin/bin/console messenger:consume async_ap --time-limit=3600 user=kbin numprocs=2 startsecs=0 autostart=true autorestart=true startretries=10 process_name=%(program_name)s_%(process_num)02d stderr_logfile=/var/log/supervisor/%(program_name)s_stderr.log stderr_logfile_maxbytes=10MB stdout_logfile=/var/log/supervisor/%(program_name)s_stdout.log stdout_logfile_maxbytes=10MB
Speichere die Datei, indem du Strg + X drückst und Y eingibst, wenn du dazu aufgefordert wirst.
Führe die folgenden Befehle aus, um die neue Konfigurationsdatei einzulesen und zu aktualisieren.
$ sudo supervisorctl reread $ sudo supervisorctl update
Starten Sie alle Supervisor-Dienste.
$ sudo supervisorctl start all
Schritt 16 – Zugriff auf Kbin
Öffne die URL https://example.com und du erhältst die folgende Kbin-Homepage.
Klicke oben auf den Link Anmelden, um die Anmeldeseite aufzurufen.
Gib die in Schritt 12 erstellten Anmeldedaten ein und klicke auf die Schaltfläche Anmelden, um fortzufahren. Du gelangst zurück zur Kbin-Startseite. Von nun an kannst du Kbin nutzen.
Fazit
Damit ist unsere Anleitung zur Installation des Reddit-ähnlichen Content Aggregators Kbin auf einem Ubuntu 22.04 Server abgeschlossen. Wenn du noch Fragen hast, schreibe sie in die Kommentare unten.