Installation Kbin · 16 min read · Dec 18, 2025
Comment installer l'agrégateur de contenu Kbin, similaire à Reddit, sur Ubuntu 22.04
Kbin est un agrégateur de contenu et une plateforme de microblogging open-source similaire à Reddit pour le fediverse. Il vous permet de créer et de modérer des communautés et peut communiquer avec d’autres services ActivityPub, y compris Mastodon, Pleroma et Peertube.
Bien qu’il existe des instances populaires de Kbin auxquelles vous pouvez vous joindre et utiliser, vous pouvez également exécuter votre propre instance Kbin pour vos amis et votre famille. Dans ce tutoriel, vous apprendrez à installer Kbin sur un serveur Ubuntu 22.04.
Prérequis
- Un serveur exécutant Ubuntu 22.04.
- Un utilisateur sudo non-root.
- Un nom de domaine entièrement qualifié (FQDN) comme
example.com. - Assurez-vous que tout est à jour.
$ sudo apt update $ sudo apt upgrade - Quelques paquets dont votre système a besoin.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -yCertains de ces paquets peuvent déjà être installés sur votre système. - Notre installation nécessite également que la liste de contrôle d’accès (ACL) fonctionne. Installez-la.
$ sudo apt install acl
Étape 1 - Configurer le pare-feu
La première étape consiste à configurer le pare-feu. Ubuntu est livré avec ufw (Uncomplicated Firewall) par défaut.
Vérifiez si le pare-feu est en cours d’exécution.
$ sudo ufw status
Vous obtiendrez la sortie suivante.
Status: inactive
Autorisez le port SSH afin que le pare-feu ne rompe pas la connexion actuelle lors de son activation.
$ sudo ufw allow OpenSSH
Autorisez également les ports HTTP et HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Activez le pare-feu
$ sudo ufw enable
Command may disrupt existing ssh connections. Proceed with operation (y|n)? y
Firewall is active and enabled on system startup
Vérifiez à nouveau l’état du pare-feu.
$ sudo ufw status
Vous devriez voir une sortie similaire.
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)
Étape 2 - Installer Git
Git est généralement installé avec le serveur Ubuntu, mais s’il ne l’est pas, vous devez l’installer en utilisant la commande suivante.
$ sudo apt install git
Vérifiez l’installation.
$ git --version
git version 2.34.1
Configurez Git avec des informations de base.
$ git config --global user.name "Votre Nom"
$ git config --global user.email "[email protected]"
Étape 3 - Installer Nginx
Ubuntu est livré avec une version plus ancienne de Nginx. Pour installer la dernière version, vous devez télécharger le dépôt officiel de Nginx.
Importez la clé de signature de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Ajoutez le dépôt pour la version stable de Nginx.
$ 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
Mettez à jour les dépôts du système.
$ sudo apt update
Installez Nginx.
$ sudo apt install nginx
Vérifiez l’installation.
$ nginx -v
nginx version: nginx/1.24.0
Démarrez le serveur Nginx.
$ sudo systemctl start nginx
Étape 4 - Installer PHP et configurer PHP
Ubuntu 22.04 est livré avec la version PHP 8.1.2 qui est un peu obsolète. Nous allons installer la dernière version PHP 8.2 en utilisant le dépôt PHP d’Ondrej.
$ sudo add-apt-repository ppa:ondrej/php
Ensuite, installez PHP et ses extensions requises par Kbin.
$ 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
Vérifiez l’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
Ouvrez le fichier /etc/php/8.2/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf
Nous devons définir l’utilisateur/groupe Unix des processus PHP sur nginx. Trouvez les lignes user=www-data et group=www-data dans le fichier et changez-les en 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
...
Trouvez les lignes listen.owner = www-data et listen.group = www-data dans le fichier et changez-les en 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
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Augmentez la limite de mémoire pour PHP-FPM de 128 Mo à 512 Mo.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php/8.2/fpm/php.ini
Augmentez la taille maximale de téléchargement de fichiers à 8 Mo.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 8M/' /etc/php/8.2/fpm/php.ini
Redémarrez le service PHP-FPM.
$ sudo systemctl restart php8.2-fpm
Changez le groupe du répertoire des sessions PHP en Nginx.
$ sudo chgrp -R nginx /var/lib/php/sessions
Étape 5 - Installer Composer
Composer est un outil de gestion des dépendances pour PHP et est requis pour l’installation de Kbin. Récupérez le fichier de configuration de Composer.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Exécutez l’installateur pour générer le binaire Composer.
$ php composer-setup.php
Supprimez le fichier de configuration.
$ php -r "unlink('composer-setup.php');"
Déplacez le binaire composer.phar vers le répertoire /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Vérifiez l’installation de Composer.
$ composer --version
Composer version 2.5.8 2023-06-09 17:13:21
Étape 6 - Installer et configurer PostgreSQL
Ubuntu 22.04 est livré avec PostgreSQL 14 par défaut. Nous allons utiliser PostgreSQL 15 à la place.
Exécutez la commande suivante pour ajouter la clé GPG de PostgreSQL.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Ajoutez le dépôt APT à votre liste de sources.
$ 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'
Mettez à jour le dépôt du système.
$ sudo apt update
Maintenant, vous pouvez installer PostgreSQL en utilisant la commande ci-dessous.
$ sudo apt install postgresql postgresql-contrib
Le paquet postgresql-contrib contient quelques utilitaires supplémentaires.
Vérifiez l’état du service PostgreSQL.
$ 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.
Vous pouvez voir que le service est activé et en cours d’exécution par défaut.
Lancez le shell PostgreSQL.
$ sudo -i -u postgres psql
Créez la base de données Kbin.
postgres=# CREATE DATABASE kbin;
Créez l’utilisateur Kbin et choisissez un mot de passe fort.
postgres-# CREATE USER kbinuser WITH PASSWORD 'Votre_Mot_de_Passe';
Changez le propriétaire de la base de données en l’utilisateur Kbin.
postgres-# ALTER DATABASE kbin OWNER TO kbinuser;
Quittez le shell.
postgres-# \q
Vérifiez que vos identifiants fonctionnent.
$ 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=>
Quittez le shell en tapant \q.
Étape 7 - Installer Nodejs et Yarn
Ubuntu 22.04 est livré avec Node v12 qui est obsolète. Nous allons installer la dernière version LTS de Node qui est v18 au moment de la rédaction de ce tutoriel.
Récupérez l’installateur Node v18 de NodeSource.
$ curl -sL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh
Exécutez le script d’installation.
$ sudo bash nodesource_setup.sh
Installez Node.js.
$ sudo apt install nodejs
Vérifiez la version de Node.js.
$ node -v
v18.16.1
Supprimez le fichier d’installation.
$ rm nodesource_setup.sh
Étape 8 - Installer Yarn
Importez la clé GPG pour Yarn.
$ curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | gpg --dearmor | sudo tee /usr/share/keyrings/yarnkey.gpg >/dev/null
Ajoutez la source Yarn à la liste des dépôts système.
$ 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
Mettez à jour votre liste de dépôts système.
$ sudo apt update
Installez Yarn
$ sudo apt install yarn
Vérifiez l’installation.
$ yarn --version
1.22.19
Étape 8 - Installer Redis
Magento utilise Redis pour le stockage des sessions et du cache. C’est entièrement optionnel et vous pouvez utiliser la base de données pour le stockage des sessions. Mais Redis fait un meilleur travail. La dernière version de Magento fonctionne avec Redis 7.0. Ubuntu est livré avec Redis 6.0, donc nous allons utiliser le dépôt Redis pour l’installation.
Importez la clé GPG officielle de Redis.
$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
Ajoutez le dépôt APT à votre liste de sources.
$ 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
Mettez à jour la liste des dépôts du système.
$ sudo apt update
Exécutez la commande suivante pour installer le serveur Redis.
$ sudo apt install redis
Confirmez la version de Redis.
$ redis-server -v
Redis server v=7.0.11 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=3af367a78d5e21e9
Vérifions la connexion au service en utilisant la commande suivante.
$ redis-cli
Vous serez transféré dans le shell Redis.
La première étape consiste à définir le mot de passe pour l’utilisateur par défaut de Redis. Remplacez Your_Redis_Password par un mot de passe fort de votre choix. Assurez-vous de préfixer le mot de passe avec le caractère >.
127.0.0.1:6379> acl setuser default >Your_Redis_Password
Testez l’authentification Redis.
127.0.0.1:6379> AUTH Your_Redis_Password
OK
Ping le service.
127.0.0.1:6379> ping
PONG
Quittez le service en tapant exit.
Si vous le souhaitez, vous pouvez utiliser la commande suivante pour générer le mot de passe Redis.
$ openssl rand 60 | openssl base64 -A
OaYOuq6J9HhxMV0sGCeZbaGecphCl4GBfVkCOPkNjkQE1FX9DKpGSCJcDb8UV+AuFKA8tR1PgjGequn1
Étape 9 - Installer et configurer RabbitMQ
Kbin nécessite RabbitMQ pour les besoins de mise en file d’attente des messages. Nous allons l’installer à partir du dépôt Ubuntu.
$ sudo apt install rabbitmq-server
Créez un utilisateur Rabbit. Choisissez un mot de passe fort.
$ sudo rabbitmqctl add_user kbin StrongPassword
Faites de l’utilisateur un administrateur.
$ sudo rabbitmqctl set_user_tags kbin administrator
Étape 10 - Télécharger Kbin
Avant de télécharger Kbin, nous devons créer un compte utilisateur Kbin.
$ adduser kbin
Ajoutez l’utilisateur kbin au groupe sudo.
$ sudo usermod -aG sudo kbin
Connectez-vous en tant qu’utilisateur kbin.
$ su - kbin
Créez le répertoire /var/www/html/kbin.
$ sudo mkdir /var/wwww/html/kbin -p
Accédez au répertoire.
$ cd /var/www/html/kbin
Donnez les permissions appropriées au dossier afin que l’utilisateur actuellement connecté puisse effectuer des tâches.
$ sudo chown $USER:$USER kbin
Clonez le dépôt Git de Kbin dans le dossier actuel. Assurez-vous d’ajouter le point (.) à la fin de la commande pour faire référence au dossier actuel.
$ git clone https://codeberg.org/Kbin/kbin-core.git .
Créez le répertoire public/media.
$ mkdir public/media
Donnez-lui toutes les permissions.
$ chmod 777 public/media
Étape 11 - Configurer le fichier d’environnement
Générez la clé secrète JWT Mercure.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Générez le secret de l’application en utilisant la même commande à nouveau.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Créez et ouvrez le fichier .env pour l’éditer dans le répertoire Kbin.
$ nano .env
Collez le code suivant dedans. Utilisez les clés générées ci-dessus dans le fichier suivant.
# 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
[email protected]
[email protected]
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="agrégateur de contenu et plateforme de microblogging pour le fediverse"
KBIN_META_KEYWORDS="kbin, agrégateur de contenu, 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://[email protected]: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 ###
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Étape 12 - Installer Kbin
Installez les paquets requis par Kbin en utilisant Composer.
$ composer install --prefer-dist --no-dev
$ composer dump-env prod
Effacez le cache.
$ APP_ENV=prod APP_DEBUG=0 php bin/console cache:clear
$ composer clear-cache
Donnez les permissions appropriées au dossier media.
$ sudo chown kbin:nginx public/media
Définissez les permissions de fichiers et de répertoires appropriées en utilisant la commande setfacl. La commande suivante détecte le serveur web actuellement utilisé (Nginx) et définit les permissions pour les fichiers et dossiers existants et futurs.
$ 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
Créez et migrez la base de données PostgreSQL.
$ php bin/console doctrine:database:create
$ php bin/console doctrine:migrations:migrate
Vous serez invité à confirmer si vous souhaitez continuer avec la migration des données. Tapez yes pour continuer.
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
Installez et construisez l’interface publique pour le site Kbin.
$ yarn install
$ yarn build
Créez un nouvel utilisateur administrateur pour Kbin.
$ php bin/console kbin:user:create username [email protected] password
Accordez des privilèges administratifs à l’utilisateur.
$ php bin/console kbin:user:admin username
Mettez à jour les clés.
$ php bin/console kbin:ap:keys:update
Étape 13 - Installer SSL
Nous devons installer Certbot pour générer le certificat SSL. Vous pouvez soit installer Certbot en utilisant le dépôt d’Ubuntu, soit récupérer la dernière version en utilisant l’outil Snapd. Nous allons utiliser la version Snapd.
Ubuntu 22.04 est livré avec Snapd installé par défaut. Exécutez les commandes suivantes pour vous assurer que votre version de Snapd est à jour.
$ sudo snap install core && sudo snap refresh core
Installez Certbot.
$ sudo snap install --classic certbot
Utilisez la commande suivante pour vous assurer que la commande Certbot peut être exécutée en créant un lien symbolique vers le répertoire /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Exécutez la commande suivante pour générer un certificat SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
La commande ci-dessus téléchargera un certificat dans le répertoire /etc/letsencrypt/live/example.com sur votre serveur.
Générez un certificat de groupe Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Vérifiez le service de planification de renouvellement de Certbot.
$ sudo systemctl list-timers
Vous trouverez snap.certbot.renew.service comme l’un des services programmés pour s’exécuter.
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
Faites un essai à blanc du processus pour vérifier si le renouvellement SSL fonctionne correctement.
$ sudo certbot renew --dry-run
Si vous ne voyez aucune erreur, vous êtes prêt. Votre certificat se renouvellera automatiquement.
Étape 14 - Configurer Nginx
Créez et ouvrez le fichier /etc/nginx/conf.d/kbin.conf pour l’éditer.
$ sudo nano /etc/nginx/conf.d/kbin.conf
Collez le code suivant dedans.
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;
}
Remarquez que le répertoire racine à utiliser dans la configuration Nginx est /var/www/html/kbin/public/.
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité une fois terminé.
Ouvrez le fichier /etc/nginx/nginx.conf pour l’éditer.
$ sudo nano /etc/nginx/nginx.conf
Ajoutez la ligne suivante avant la ligne include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Vérifiez la syntaxe du fichier de configuration Nginx.
$ sudo nginx -t
nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
nginx: configuration file /etc/nginx/nginx.conf test is successful
Redémarrez le service Nginx.
$ sudo systemctl restart nginx
Étape 15 - Installer et configurer Supervisor
Supervisor est un gestionnaire de processus et nous l’utiliserons comme moniteur de processus pour le travailleur de messages (RabbitMQ) pour Kbin. La première étape consiste à installer Supervisor.
$ sudo apt install supervisor
Créez le fichier /etc/supervisor/conf.d/messenger-worker.conf et ouvrez-le pour l’éditer.
$ sudo nano /etc/supervisor/conf.d/messenger-worker.conf
Collez le code suivant dedans.
[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
Enregistrez le fichier en appuyant sur Ctrl + X et en entrant Y lorsque vous y êtes invité.
Exécutez les commandes suivantes pour relire et mettre à jour le nouveau fichier de configuration.
$ sudo supervisorctl reread
$ sudo supervisorctl update
Démarrez tous les services Supervisor.
$ sudo supervisorctl start all
Étape 16 - Accéder à Kbin
Ouvrez l’URL https://example.com et vous obtiendrez la page d’accueil Kbin suivante.
Cliquez sur le lien Se connecter en haut pour faire apparaître la page de connexion.
Entrez les identifiants créés à l’étape 12 et cliquez sur le bouton Se connecter pour continuer. Vous serez ramené à la page d’accueil Kbin. Vous pouvez commencer à utiliser Kbin à partir de maintenant.
Conclusion
Cela conclut notre tutoriel sur l’installation de l’agrégateur de contenu Kbin, similaire à Reddit, sur un serveur Ubuntu 22.04. Si vous avez des questions, postez-les dans les commentaires ci-dessous.
Recevez de nouveaux articles dans votre boîte de réception.
Aucun spam. Désabonnez-vous à tout moment.