Installazione Kbin · 16 min read · Dec 18, 2025
Come installare l'aggregatore di contenuti Kbin simile a Reddit su Ubuntu 22.04
Kbin è un aggregatore di contenuti open-source simile a Reddit e una piattaforma di microblogging per il fediverse. Ti consente di creare e moderare comunità e può comunicare con altri servizi ActivityPub tra cui Mastodon, Pleroma e Peertube.
Sebbene ci siano istanze popolari di Kbin a cui puoi unirti e utilizzare, puoi anche eseguire la tua istanza Kbin per i tuoi amici e familiari. In questo tutorial, imparerai come installare Kbin su un server Ubuntu 22.04.
Prerequisiti
- Un server che esegue Ubuntu 22.04.
- Un utente sudo non root.
- Un nome di dominio completamente qualificato (FQDN) come
example.com. - Assicurati che tutto sia aggiornato.
$ sudo apt update $ sudo apt upgrade - Alcuni pacchetti di cui il tuo sistema ha bisogno.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -yAlcuni di questi pacchetti potrebbero già essere installati sul tuo sistema. - La nostra installazione richiede anche che l’Access Control List (ACL) funzioni. Installalo.
$ sudo apt install acl
Passo 1 - Configura il Firewall
Il primo passo è configurare il firewall. Ubuntu viene fornito di default con ufw (Uncomplicated Firewall).
Controlla se il firewall è in esecuzione.
$ sudo ufw status
Otterrai il seguente output.
Status: inactive
Consenti la porta SSH in modo che il firewall non interrompa la connessione attuale al momento dell’attivazione.
$ sudo ufw allow OpenSSH
Consenti anche le porte HTTP e HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Abilita il Firewall
$ sudo ufw enable
Il comando potrebbe interrompere le connessioni ssh esistenti. Procedere con l'operazione (y|n)? y
Il firewall è attivo e abilitato all'avvio del sistema
Controlla di nuovo lo stato del firewall.
$ sudo ufw status
Dovresti vedere un output simile.
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)
Passo 2 - Installa Git
Git è solitamente installato con il server Ubuntu, ma se non lo è, dovresti installarlo utilizzando il seguente comando.
$ sudo apt install git
Verifica l’installazione.
$ git --version
git version 2.34.1
Configura Git con informazioni di base.
$ git config --global user.name "Il tuo nome"
$ git config --global user.email "[email protected]"
Passo 3 - Installa Nginx
Ubuntu viene fornito con una versione più vecchia di Nginx. Per installare l’ultima versione, devi scaricare il repository ufficiale di Nginx.
Importa la chiave di firma di Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Aggiungi il repository per la versione stabile di 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
Aggiorna i repository di sistema.
$ sudo apt update
Installa Nginx.
$ sudo apt install nginx
Verifica l’installazione.
$ nginx -v
nginx version: nginx/1.24.0
Avvia il server Nginx.
$ sudo systemctl start nginx
Passo 4 - Installa PHP e configura PHP
Ubuntu 22.04 viene fornito con la versione PHP 8.1.2 che è un po’ obsoleta. Installeremo l’ultima versione PHP 8.2 utilizzando il repository PHP di Ondrej.
$ sudo add-apt-repository ppa:ondrej/php
Successivamente, installa PHP e le sue estensioni richieste da 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
Verifica l’installazione.
$ 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
Apri il file /etc/php/8.2/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf
Dobbiamo impostare l’utente/gruppo Unix dei processi PHP su nginx. Trova le righe user=www-data e group=www-data nel file e cambiale 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
...
Trova le righe listen.owner = www-data e listen.group = www-data nel file e cambiale 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
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Aumenta il limite di memoria per PHP-FPM da 128 MB a 512 MB.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php/8.2/fpm/php.ini
Aumenta la dimensione massima del file di upload a 8 MB.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 8M/' /etc/php/8.2/fpm/php.ini
Riavvia il servizio PHP-FPM.
$ sudo systemctl restart php8.2-fpm
Cambia il gruppo della directory delle sessioni PHP in Nginx.
$ sudo chgrp -R nginx /var/lib/php/sessions
Passo 5 - Installa Composer
Composer è uno strumento di gestione delle dipendenze per PHP ed è necessario per l’installazione di Kbin. Ottieni il file di installazione di composer.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Esegui l’installer per generare il binario di Composer.
$ php composer-setup.php
Rimuovi il file di installazione.
$ php -r "unlink('composer-setup.php');"
Sposta il binario composer.phar nella directory /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Verifica l’installazione di Composer.
$ composer --version
Composer version 2.5.8 2023-06-09 17:13:21
Passo 6 - Installa e configura PostgreSQL
Ubuntu 22.04 viene fornito con PostgreSQL 14 di default. Utilizzeremo PostgreSQL 15 invece.
Esegui il seguente comando per aggiungere la chiave GPG di PostgreSQL.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Aggiungi il repository APT alla tua lista di sorgenti.
$ 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'
Aggiorna il repository di sistema.
$ sudo apt update
Ora puoi installare PostgreSQL utilizzando il comando qui sotto.
$ sudo apt install postgresql postgresql-contrib
Il pacchetto postgresql-contrib contiene alcune utilità extra.
Controlla lo stato del servizio 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.
Puoi vedere che il servizio è abilitato e in esecuzione per impostazione predefinita.
Avvia la shell di PostgreSQL.
$ sudo -i -u postgres psql
Crea il database Kbin.
postgres=# CREATE DATABASE kbin;
Crea l’utente Kbin e scegli una password forte.
postgres-# CREATE USER kbinuser WITH PASSWORD 'Your_Password';
Cambia il proprietario del database in modo che sia l’utente Kbin.
postgres-# ALTER DATABASE kbin OWNER TO kbinuser;
Esci dalla shell.
postgres-# \q
Verifica che le tue credenziali funzionino.
$ 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=>
Esci dalla shell digitando \q.
Passo 7 - Installa Nodejs e Yarn
Ubuntu 22.04 viene fornito con Node v12 che è obsoleto. Installeremo l’ultima versione LTS di Node che è v18 al momento della scrittura di questo tutorial.
Ottieni l’installer di Node v18 da NodeSource.
$ curl -sL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh
Esegui lo script di installazione.
$ sudo bash nodesource_setup.sh
Installa Node.js.
$ sudo apt install nodejs
Verifica la versione di Node.js.
$ node -v
v18.16.1
Elimina il file di installazione.
$ rm nodesource_setup.sh
Passo 8 - Installa Yarn
Importa la chiave GPG per Yarn.
$ curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | gpg --dearmor | sudo tee /usr/share/keyrings/yarnkey.gpg >/dev/null
Aggiungi la sorgente Yarn alla lista dei repository di sistema.
$ 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
Aggiorna la tua lista di repository di sistema.
$ sudo apt update
Installa Yarn
$ sudo apt install yarn
Verifica l’installazione.
$ yarn --version
1.22.19
Passo 8 - Installa Redis
Magento utilizza Redis per la memorizzazione delle sessioni e della cache. È completamente facoltativo e puoi utilizzare il database per la memorizzazione delle sessioni. Ma Redis fa un lavoro migliore. L’ultima versione di Magento funziona con Redis 7.0. Ubuntu viene fornito con Redis 6.0, quindi utilizzeremo il repository Redis per l’installazione.
Importa la chiave GPG ufficiale di Redis.
$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
Aggiungi il repository APT alla tua lista di sorgenti.
$ 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
Aggiorna la lista dei repository di sistema.
$ sudo apt update
Esegui il seguente comando per installare il server Redis.
$ sudo apt install redis
Conferma la versione di Redis.
$ redis-server -v
Redis server v=7.0.11 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=3af367a78d5e21e9
Verifichiamo la connessione al servizio utilizzando il seguente comando.
$ redis-cli
Verrai spostato nella shell di Redis.
Il primo passo è impostare la password per l’utente predefinito di Redis. Sostituisci Your_Redis_Password con una password forte a tua scelta. Assicurati di anteporre la password con il carattere >.
127.0.0.1:6379> acl setuser default >Your_Redis_Password
Testa l’autenticazione di Redis.
127.0.0.1:6379> AUTH Your_Redis_Password
OK
Invia un ping al servizio.
127.0.0.1:6379> ping
PONG
Esci dal servizio digitando exit.
Se vuoi, puoi utilizzare il seguente comando per generare la password di Redis.
$ openssl rand 60 | openssl base64 -A
OaYOuq6J9HhxMV0sGCeZbaGecphCl4GBfVkCOPkNjkQE1FX9DKpGSCJcDb8UV+AuFKA8tR1PgjGequn1
Passo 9 - Installa e configura RabbitMQ
Kbin richiede RabbitMQ per scopi di messaggistica. Lo installeremo dal repository di Ubuntu.
$ sudo apt install rabbitmq-server
Crea un utente Rabbit. Scegli una password forte.
$ sudo rabbitmqctl add_user kbin StrongPassword
Rendi l’utente un amministratore.
$ sudo rabbitmqctl set_user_tags kbin administrator
Passo 10 - Scarica Kbin
Prima di scaricare Kbin, dobbiamo creare un account utente Kbin.
$ adduser kbin
Aggiungi l’utente kbin al gruppo sudo.
$ sudo usermod -aG sudo kbin
Accedi come utente kbin.
$ su - kbin
Crea la directory /var/www/html/kbin.
$ sudo mkdir /var/wwww/html/kbin -p
Passa alla directory.
$ cd /var/www/html/kbin
Dai i permessi appropriati alla cartella in modo che l’utente attualmente connesso possa eseguire operazioni.
$ sudo chown $USER:$USER kbin
Clona il repository Git di Kbin nella cartella corrente. Assicurati di aggiungere il punto (.) alla fine del comando per riferirti alla cartella corrente.
$ git clone https://codeberg.org/Kbin/kbin-core.git .
Crea la directory public/media.
$ mkdir public/media
Dai pieno permesso ad essa.
$ chmod 777 public/media
Passo 11 - Configura il file di ambiente
Genera la chiave segreta JWT di Mercure.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Genera la chiave segreta dell’app utilizzando lo stesso comando di nuovo.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Crea e apri il file .env per la modifica nella directory Kbin.
$ nano .env
Incolla il seguente codice in esso. Usa le chiavi generate sopra nel seguente file.
# Esegui "composer dump-env prod" per compilare i file .env per l'uso in produzione (richiede symfony/flex >=1.2).
# https://symfony.com/doc/current/best_practices.html#use-environment-variables-for-infrastructure-configuration
# variabili kbin
SERVER_NAME="nspeaks.xyz" # produzione
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="aggregatore di contenuti e piattaforma di microblogging per il fediverse"
KBIN_META_KEYWORDS="kbin, aggregatore di contenuti, 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 ###
# Formato descritto su https://www.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/configuration.html#connecting-using-a-url
# IMPORTANTE: Devi configurare la versione del tuo server, qui o 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 ###
# Scegli uno dei trasporti qui sotto
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 ###
# Vedi https://symfony.com/doc/current/mercure.html#configuration
# L'URL dell'hub Mercure, utilizzato dall'app per pubblicare aggiornamenti (può essere un URL locale)
MERCURE_URL=https://example.com/.well-known/mercure
# L'URL pubblico dell'hub Mercure, utilizzato dal browser per connettersi
MERCURE_PUBLIC_URL=https://example.com/.well-known/mercure
# La chiave segreta utilizzata per firmare i JWT
MERCURE_JWT_SECRET="!ChangeThisMercureHubJWTSecretKey!"
###< symfony/mercure-bundle ###
###> symfony/lock ###
LOCK_DSN=flock
###< symfony/lock ###
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Passo 12 - Installa Kbin
Installa i pacchetti richiesti da Kbin utilizzando Composer.
$ composer install --prefer-dist --no-dev
$ composer dump-env prod
Pulisci la cache.
$ APP_ENV=prod APP_DEBUG=0 php bin/console cache:clear
$ composer clear-cache
Dai i permessi appropriati alla cartella media.
$ sudo chown kbin:nginx public/media
Imposta i permessi di file e directory appropriati utilizzando il comando setfacl. Il seguente comando rileva il server web attualmente in uso (Nginx) e imposta i permessi per i file e le cartelle esistenti e futuri.
$ 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
Crea e migra il database PostgreSQL.
$ php bin/console doctrine:database:create
$ php bin/console doctrine:migrations:migrate
Ti verrà chiesto se vuoi continuare con la migrazione dei dati. Digita yes per procedere.
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
Installa e costruisci il frontend pubblico per il sito Kbin.
$ yarn install
$ yarn build
Crea un nuovo utente amministratore per Kbin.
$ php bin/console kbin:user:create username [email protected] password
Concedi privilegi amministrativi all’utente.
$ php bin/console kbin:user:admin username
Aggiorna le chiavi.
$ php bin/console kbin:ap:keys:update
Passo 13 - Installa SSL
Dobbiamo installare Certbot per generare il certificato SSL. Puoi installare Certbot utilizzando il repository di Ubuntu o scaricare l’ultima versione utilizzando lo strumento Snapd. Utilizzeremo la versione Snapd.
Ubuntu 22.04 viene fornito con Snapd installato di default. Esegui i seguenti comandi per assicurarti che la tua versione di Snapd sia aggiornata.
$ sudo snap install core && sudo snap refresh core
Installa Certbot.
$ sudo snap install --classic certbot
Usa il seguente comando per assicurarti che il comando Certbot possa essere eseguito creando un collegamento simbolico alla directory /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Esegui il seguente comando per generare un certificato SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
Il comando sopra scaricherà un certificato nella directory /etc/letsencrypt/live/example.com sul tuo server.
Genera un certificato di gruppo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Controlla il servizio di pianificazione del rinnovo di Certbot.
$ sudo systemctl list-timers
Troverai snap.certbot.renew.service come uno dei servizi programmati per l’esecuzione.
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
Fai un test del processo per controllare se il rinnovo SSL funziona correttamente.
$ sudo certbot renew --dry-run
Se non vedi errori, sei a posto. Il tuo certificato si rinnoverà automaticamente.
Passo 14 - Configura Nginx
Crea e apri il file /etc/nginx/conf.d/kbin.conf per la modifica.
$ sudo nano /etc/nginx/conf.d/kbin.conf
Incolla il seguente codice in esso.
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;
# usa https://blog.cloudflare.com/announcing-1111 Cloudfare+Apnic labs, è gratuito e sicuro
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;
}
# Passa gli script PHP al server FastCGI
location ~* \.php$ {
try_files $uri =404;
fastcgi_index index.php;
fastcgi_pass unix:/run/php-fpm/www.sock; # Dipende dalla versione di PHP
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT $realpath_root;
include fastcgi_params;
}
# nega l'accesso a file/directory scrivibili
location ~* ^/sites/*/(documents|edi|era) {
deny all;
return 404;
}
# nega l'accesso a determinate directory
location ~* ^/(contrib|tests) {
deny all;
return 404;
}
# In alternativa, tutto l'accesso a questi file può essere negato
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;
}
}
# forzare HTTPS
server {
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
Nota che la directory root da utilizzare nella configurazione di Nginx è /var/www/html/kbin/public/.
Salva il file premendo Ctrl + X e inserendo Y quando richiesto una volta terminato.
Apri il file /etc/nginx/nginx.conf per la modifica.
$ sudo nano /etc/nginx/nginx.conf
Aggiungi la seguente riga prima della riga include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Verifica la sintassi del file di configurazione di Nginx.
$ sudo nginx -t
nginx: il file di configurazione /etc/nginx/nginx.conf ha una sintassi corretta
nginx: il test del file di configurazione /etc/nginx/nginx.conf è riuscito
Riavvia il servizio Nginx.
$ sudo systemctl restart nginx
Passo 15 - Installa e configura Supervisor
Supervisor è un gestore di processi e lo utilizzeremo come monitor di processo per il lavoratore di messaggi (RabbitMQ) per Kbin. Il primo passo è installare Supervisor.
$ sudo apt install supervisor
Crea il file /etc/supervisor/conf.d/messenger-worker.conf e aprilo per la modifica.
$ sudo nano /etc/supervisor/conf.d/messenger-worker.conf
Incolla il seguente codice in esso.
[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
Salva il file premendo Ctrl + X e inserendo Y quando richiesto.
Esegui i seguenti comandi per rileggere e aggiornare il nuovo file di configurazione.
$ sudo supervisorctl reread
$ sudo supervisorctl update
Avvia tutti i servizi di Supervisor.
$ sudo supervisorctl start all
Passo 16 - Accedi a Kbin
Apri l’URL https://example.com e otterrai la seguente homepage di Kbin.
Clicca sul link Accedi in alto per aprire la pagina di accesso.
Inserisci le credenziali create nel passo 12 e fai clic sul pulsante Accedi per procedere. Verrai riportato alla homepage di Kbin. Puoi iniziare a utilizzare Kbin da qui in poi.
Conclusione
Questo conclude il nostro tutorial su come installare l’aggregatore di contenuti simile a Reddit Kbin su un server Ubuntu 22.04. Se hai domande, postale nei commenti qui sotto.
Ricevi i nuovi post nella tua casella di posta.
Nessuno spam. Disiscriviti in qualsiasi momento.