Instalación Kbin · 16 min read · Dec 18, 2025
Cómo instalar el agregador de contenido Kbin similar a Reddit en Ubuntu 22.04
Kbin es un agregador de contenido y plataforma de microblogging de código abierto similar a Reddit para el fediverso. Te permite crear y moderar comunidades y puede comunicarse con otros servicios de ActivityPub, incluidos Mastodon, Pleroma y Peertube.
Si bien hay instancias populares de Kbin a las que puedes unirte y usar, también puedes ejecutar tu propia instancia de Kbin para tus amigos y familiares. En este tutorial, aprenderás cómo instalar Kbin en un servidor Ubuntu 22.04.
Requisitos previos
- Un servidor que ejecute Ubuntu 22.04.
- Un usuario sudo no root.
- Un nombre de dominio completamente calificado (FQDN) como
example.com. - Asegúrate de que todo esté actualizado.
$ sudo apt update $ sudo apt upgrade - Algunos paquetes que tu sistema necesita.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release ubuntu-keyring unzip -yAlgunos de estos paquetes pueden estar ya instalados en tu sistema. - Nuestra instalación también requiere que la Lista de Control de Acceso (ACL) funcione. Instálala.
$ sudo apt install acl
Paso 1 - Configurar el Firewall
El primer paso es configurar el firewall. Ubuntu viene con ufw (Firewall poco complicado) por defecto.
Verifica si el firewall está en funcionamiento.
$ sudo ufw status
Obtendrás la siguiente salida.
Estado: inactivo
Permite el puerto SSH para que el firewall no interrumpa la conexión actual al habilitarlo.
$ sudo ufw allow OpenSSH
Permite también los puertos HTTP y HTTPS.
$ sudo ufw allow http
$ sudo ufw allow https
Habilita el Firewall
$ sudo ufw enable
El comando puede interrumpir las conexiones ssh existentes. ¿Proceder con la operación (y|n)? y
El firewall está activo y habilitado al inicio del sistema
Verifica el estado del firewall nuevamente.
$ sudo ufw status
Deberías ver una salida similar.
Estado: activo
Para Acción Desde
-- ------ ----
OpenSSH PERMITIR En cualquier lugar
80/tcp PERMITIR En cualquier lugar
443 PERMITIR En cualquier lugar
OpenSSH (v6) PERMITIR En cualquier lugar (v6)
80/tcp (v6) PERMITIR En cualquier lugar (v6)
443 (v6) PERMITIR En cualquier lugar (v6)
Paso 2 - Instalar Git
Git generalmente se instala con el servidor Ubuntu, pero si no está, deberías instalarlo usando el siguiente comando.
$ sudo apt install git
Verifica la instalación.
$ git --version
git version 2.34.1
Configura Git con información básica.
$ git config --global user.name "Tu Nombre"
$ git config --global user.email "[email protected]"
Paso 3 - Instalar Nginx
Ubuntu viene con una versión más antigua de Nginx. Para instalar la última versión, necesitas descargar el repositorio oficial de Nginx.
Importa la clave de firma de Nginx.
$ curl https://nginx.org/keys/nginx_signing.key | gpg --dearmor \
| sudo tee /usr/share/keyrings/nginx-archive-keyring.gpg >/dev/null
Agrega el repositorio para la versión estable 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
Actualiza los repositorios del sistema.
$ sudo apt update
Instala Nginx.
$ sudo apt install nginx
Verifica la instalación.
$ nginx -v
nginx version: nginx/1.24.0
Inicia el servidor Nginx.
$ sudo systemctl start nginx
Paso 4 - Instalar PHP y configurar PHP
Ubuntu 22.04 viene con la versión PHP 8.1.2 que está un poco desactualizada. Instalaremos la última versión PHP 8.2 usando el repositorio de PHP de Ondrej.
$ sudo add-apt-repository ppa:ondrej/php
A continuación, instala PHP y sus extensiones requeridas por 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 la instalación.
$ 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
Abre el archivo /etc/php/8.2/fpm/pool.d/www.conf.
$ sudo nano /etc/php/8.2/fpm/pool.d/www.conf
Necesitamos establecer el usuario/grupo Unix de los procesos PHP a nginx. Encuentra las líneas user=www-data y group=www-data en el archivo y cámbialas a nginx.
...
; Usuario/grupo Unix de los procesos
; Nota: El usuario es obligatorio. Si el grupo no está establecido, se usará el grupo del usuario predeterminado
; se usará.
; RPM: usuario de apache elegido para proporcionar acceso a los mismos directorios que httpd
user = nginx
; RPM: Mantener un grupo permitido para escribir en el directorio de registros.
group = nginx
...
Encuentra las líneas listen.owner = www-data y listen.group = www-data en el archivo y cámbialas a nginx.
; Establecer permisos para el socket unix, si se usa uno. En Linux, los permisos de lectura/escritura
; deben establecerse para permitir conexiones desde un servidor web. Muchos
; sistemas derivados de BSD permiten conexiones independientemente de los permisos. El propietario
; y el grupo pueden especificarse por nombre o por sus ID numéricos.
; Valores predeterminados: el usuario y el grupo se establecen como el usuario en ejecución
; el modo se establece en 0660
listen.owner = nginx
listen.group = nginx
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Aumenta el límite de memoria para PHP-FPM de 128 MB a 512 MB.
$ sudo sed -i 's/memory_limit = 128M/memory_limit = 512M/' /etc/php/8.2/fpm/php.ini
Aumenta el tamaño máximo de carga de archivos a 8 MB.
$ sudo sed -i 's/upload_max_filesize = 2M/upload_max_filesize = 8M/' /etc/php/8.2/fpm/php.ini
Reinicia el servicio PHP-FPM.
$ sudo systemctl restart php8.2-fpm
Cambia el grupo del directorio de sesiones de PHP a Nginx.
$ sudo chgrp -R nginx /var/lib/php/sessions
Paso 5 - Instalar Composer
Composer es una herramienta de gestión de dependencias para PHP y es necesaria para la instalación de Kbin. Obtén el archivo de configuración de composer.
$ php -r "copy('https://getcomposer.org/installer', 'composer-setup.php');"
Ejecuta el instalador para generar el binario de Composer.
$ php composer-setup.php
Elimina el archivo de configuración.
$ php -r "unlink('composer-setup.php');"
Mueve el binario composer.phar al directorio /usr/local/bin.
$ sudo mv composer.phar /usr/local/bin/composer
Verifica la instalación de Composer.
$ composer --version
Composer version 2.5.8 2023-06-09 17:13:21
Paso 6 - Instalar y configurar PostgreSQL
Ubuntu 22.04 viene con PostgreSQL 14 por defecto. Usaremos PostgreSQL 15 en su lugar.
Ejecuta el siguiente comando para agregar la clave GPG de PostgreSQL.
$ curl https://www.postgresql.org/media/keys/ACCC4CF8.asc | gpg --dearmor | sudo tee /usr/share/keyrings/postgresql-key.gpg >/dev/null
Agrega el repositorio APT a tu lista de fuentes.
$ 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'
Actualiza el repositorio del sistema.
$ sudo apt update
Ahora, puedes instalar PostgreSQL usando el siguiente comando.
$ sudo apt install postgresql postgresql-contrib
El paquete postgresql-contrib contiene algunas utilidades adicionales.
Verifica el estado del servicio 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.
Puedes ver que el servicio está habilitado y en funcionamiento por defecto.
Lanza la consola de PostgreSQL.
$ sudo -i -u postgres psql
Crea la base de datos Kbin.
postgres=# CREATE DATABASE kbin;
Crea el usuario Kbin y elige una contraseña fuerte.
postgres-# CREATE USER kbinuser WITH PASSWORD 'Tu_Contraseña';
Cambia el propietario de la base de datos al usuario Kbin.
postgres-# ALTER DATABASE kbin OWNER TO kbinuser;
Sal de la consola.
postgres-# \q
Verifica que tus credenciales funcionen.
$ psql --username kbinuser --password --host localhost kbin
Contraseña:
psql (15.3 (Ubuntu 15.3-1.pgdg22.04+1))
Conexión SSL (protocolo: TLSv1.3, cifrado: TLS_AES_256_GCM_SHA384, compresión: desactivada)
Escribe "help" para ayuda.
kbin=>
Sal de la consola escribiendo \q.
Paso 7 - Instalar Nodejs y Yarn
Ubuntu 22.04 viene con Node v12 que está desactualizado. Instalaremos la última versión LTS de Node que es v18 en el momento de escribir este tutorial.
Obtén el instalador de Node v18 de NodeSource.
$ curl -sL https://deb.nodesource.com/setup_lts.x -o nodesource_setup.sh
Ejecuta el script del instalador.
$ sudo bash nodesource_setup.sh
Instala Node.js.
$ sudo apt install nodejs
Verifica la versión de Node.js.
$ node -v
v18.16.1
Elimina el archivo del instalador.
$ rm nodesource_setup.sh
Paso 8 - Instalar Yarn
Importa la clave GPG para Yarn.
$ curl -sL https://dl.yarnpkg.com/debian/pubkey.gpg | gpg --dearmor | sudo tee /usr/share/keyrings/yarnkey.gpg >/dev/null
Agrega la fuente de Yarn a la lista de repositorios del 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
Actualiza tu lista de repositorios del sistema.
$ sudo apt update
Instala Yarn
$ sudo apt install yarn
Verifica la instalación.
$ yarn --version
1.22.19
Paso 8 - Instalar Redis
Magento utiliza Redis para almacenamiento de sesiones y caché. Es completamente opcional y puedes usar la base de datos para almacenamiento de sesiones. Pero Redis hace un mejor trabajo. La última versión de Magento funciona con Redis 7.0. Ubuntu viene con Redis 6.0, así que usaremos el repositorio de Redis para la instalación.
Importa la clave GPG oficial de Redis.
$ curl -fsSL https://packages.redis.io/gpg | sudo gpg --dearmor -o /usr/share/keyrings/redis-archive-keyring.gpg
Agrega el repositorio APT a tu lista de fuentes.
$ 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
Actualiza la lista de repositorios del sistema.
$ sudo apt update
Emite el siguiente comando para instalar el servidor Redis.
$ sudo apt install redis
Confirma la versión de Redis.
$ redis-server -v
Servidor Redis v=7.0.11 sha=00000000:0 malloc=jemalloc-5.2.1 bits=64 build=3af367a78d5e21e9
Verifiquemos la conexión del servicio usando el siguiente comando.
$ redis-cli
Serás cambiado a la consola de Redis.
El primer paso es establecer la contraseña para el usuario predeterminado de Redis. Reemplaza Tu_Contraseña_Redis con una contraseña fuerte de tu elección. Asegúrate de prefijar la contraseña con el carácter >.
127.0.0.1:6379> acl setuser default >Tu_Contraseña_Redis
Prueba la autenticación de Redis.
127.0.0.1:6379> AUTH Tu_Contraseña_Redis
OK
Envía un ping al servicio.
127.0.0.1:6379> ping
PONG
Sal del servicio escribiendo exit.
Si lo deseas, puedes usar el siguiente comando para generar la contraseña de Redis.
$ openssl rand 60 | openssl base64 -A
OaYOuq6J9HhxMV0sGCeZbaGecphCl4GBfVkCOPkNjkQE1FX9DKpGSCJcDb8UV+AuFKA8tR1PgjGequn1
Paso 9 - Instalar y configurar RabbitMQ
Kbin requiere RabbitMQ para propósitos de encolado de mensajes. Lo instalaremos desde el repositorio de Ubuntu.
$ sudo apt install rabbitmq-server
Crea un usuario Rabbit. Elige una contraseña fuerte.
$ sudo rabbitmqctl add_user kbin ContraseñaFuerte
Haz que el usuario sea un administrador.
$ sudo rabbitmqctl set_user_tags kbin administrator
Paso 10 - Descargar Kbin
Antes de descargar Kbin, necesitamos crear una cuenta de usuario Kbin.
$ adduser kbin
Agrega al usuario kbin al grupo sudo.
$ sudo usermod -aG sudo kbin
Inicia sesión como el usuario kbin.
$ su - kbin
Crea el directorio /var/www/html/kbin.
$ sudo mkdir /var/wwww/html/kbin -p
Cambia al directorio.
$ cd /var/www/html/kbin
Dale los permisos adecuados a la carpeta para que el usuario actualmente conectado pueda realizar tareas.
$ sudo chown $USER:$USER kbin
Clona el repositorio Git de Kbin en la carpeta actual. Asegúrate de agregar el punto (.) al final del comando para referirte a la carpeta actual.
$ git clone https://codeberg.org/Kbin/kbin-core.git .
Crea el directorio public/media.
$ mkdir public/media
Dale permisos completos a él.
$ chmod 777 public/media
Paso 11 - Configurar el archivo de entorno
Genera la clave secreta JWT de Mercure.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Genera la clave secreta de la aplicación usando el mismo comando nuevamente.
$ node -e "console.log(require('crypto').randomBytes(32).toString('hex'))"
Crea y abre el archivo .env para editar en el directorio de Kbin.
$ nano .env
Pega el siguiente código en él. Usa las claves generadas arriba en el siguiente archivo.
# Ejecuta "composer dump-env prod" para compilar archivos .env para uso en producción (requiere symfony/flex >=1.2).
# https://symfony.com/doc/current/best_practices.html#use-environment-variables-for-infrastructure-configuration
# variables de kbin
SERVER_NAME="nspeaks.xyz" # producción
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="agregador de contenido y plataforma de microblogging para el fediverso"
KBIN_META_KEYWORDS="kbin, agregador de contenido, código abierto, fediverso"
KBIN_HEADER_LOGO=false
KBIN_CAPTCHA_ENABLED=false
# Redis
REDIS_PASSWORD=TuContraseñaRedis
REDIS_DNS=redis://default:${REDIS_PASSWORD}@localhost:6379
###> symfony/framework-bundle ###
APP_ENV=prod
APP_SECRET=427f5e2940e5b2472c1b44b2d06e0525
###< symfony/framework-bundle ###
###> doctrine/doctrine-bundle ###
# Formato descrito en https://www.doctrine-project.org/projects/doctrine-dbal/en/latest/reference/configuration.html#connecting-using-a-url
# IMPORTANTE: DEBES configurar tu versión de servidor, ya sea aquí o en config/packages/doctrine.yaml
#
POSTGRES_DB=kbin
POSTGRES_USER=kbin
POSTGRES_PASSWORD=Tu_Contraseña
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 ###
# Elige uno de los transportes a continuación
RABBITMQ_PASSWORD=ContraseñaRabbitMQ
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 ###
# Ver https://symfony.com/doc/current/mercure.html#configuration
# La URL del hub de Mercure, utilizada por la aplicación para publicar actualizaciones (puede ser una URL local)
MERCURE_URL=https://example.com/.well-known/mercure
# La URL pública del hub de Mercure, utilizada por el navegador para conectarse
MERCURE_PUBLIC_URL=https://example.com/.well-known/mercure
# La clave secreta utilizada para firmar los JWT
MERCURE_JWT_SECRET="!CambiaEstaClaveSecretaJWTMercure!"
###< symfony/mercure-bundle ###
###> symfony/lock ###
LOCK_DSN=flock
###< symfony/lock ###
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Paso 12 - Instalar Kbin
Instala los paquetes requeridos por Kbin usando Composer.
$ composer install --prefer-dist --no-dev
$ composer dump-env prod
Limpia la caché.
$ APP_ENV=prod APP_DEBUG=0 php bin/console cache:clear
$ composer clear-cache
Dale los permisos adecuados a la carpeta media.
$ sudo chown kbin:nginx public/media
Establece los permisos de archivo y directorio adecuados utilizando el comando setfacl. El siguiente comando detecta el servidor web actual en uso (Nginx) y establece permisos para los archivos y carpetas existentes y futuros.
$ 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 y migra la base de datos PostgreSQL.
$ php bin/console doctrine:database:create
$ php bin/console doctrine:migrations:migrate
Se te pedirá si deseas continuar con la migración de datos. Escribe yes para proceder.
¡ADVERTENCIA! Estás a punto de ejecutar una migración en la base de datos "kbin" que podría resultar en cambios en el esquema y pérdida de datos. ¿Estás seguro de que deseas continuar? (yes/no) [yes]:
> yes
[notice] Migrando hasta DoctrineMigrations\Version20230615203020
[notice] finalizado en 1373.9ms, se usaron 24M de memoria, 79 migraciones ejecutadas, 667 consultas sql
[OK] Migrado exitosamente a la versión: DoctrineMigrations\Version20230615203020
Instala y construye el frontend público para el sitio Kbin.
$ yarn install
$ yarn build
Crea un nuevo usuario administrador para Kbin.
$ php bin/console kbin:user:create nombredeusuario [email protected] contraseña
Otorga privilegios administrativos al usuario.
$ php bin/console kbin:user:admin nombredeusuario
Actualiza las claves.
$ php bin/console kbin:ap:keys:update
Paso 13 - Instalar SSL
Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot usando el repositorio de Ubuntu o obtener la última versión usando la herramienta Snapd. Usaremos la versión Snapd.
Ubuntu 22.04 viene con Snapd instalado por defecto. Ejecuta los siguientes comandos para asegurarte de que tu versión de Snapd esté actualizada.
$ sudo snap install core && sudo snap refresh core
Instala Certbot.
$ sudo snap install --classic certbot
Usa el siguiente comando para asegurarte de que el comando Certbot pueda ejecutarse creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Ejecuta el siguiente comando para generar un certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/example.com en tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Verifica el servicio programador de renovación de Certbot.
$ sudo systemctl list-timers
Encontrarás snap.certbot.renew.service como uno de los servicios programados para ejecutarse.
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
Haz una prueba del proceso para verificar si la renovación de SSL está funcionando correctamente.
$ sudo certbot renew --dry-run
Si no ves errores, estás listo. Tu certificado se renovará automáticamente.
Paso 14 - Configurar Nginx
Crea y abre el archivo /etc/nginx/conf.d/kbin.conf para editar.
$ sudo nano /etc/nginx/conf.d/kbin.conf
Pega el siguiente código en él.
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, es gratis y seguro
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;
}
# Pasar scripts PHP al servidor FastCGI
location ~* \.php$ {
try_files $uri =404;
fastcgi_index index.php;
fastcgi_pass unix:/run/php-fpm/www.sock; # Depende de la versión de PHP
fastcgi_param SCRIPT_FILENAME $realpath_root$fastcgi_script_name;
fastcgi_param DOCUMENT_ROOT $realpath_root;
include fastcgi_params;
}
# denegar acceso a archivos/directorios escribibles
location ~* ^/sites/*/(documents|edi|era) {
deny all;
return 404;
}
# denegar acceso a ciertos directorios
location ~* ^/(contrib|tests) {
deny all;
return 404;
}
# Alternativamente, se puede denegar todo acceso a estos archivos
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;
}
}
# forzar HTTPS
server {
listen 80;
listen [::]:80;
server_name example.com;
return 301 https://$host$request_uri;
}
Nota que el directorio raíz que se usará en la configuración de Nginx es /var/www/html/kbin/public/.
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida una vez que termines.
Abre el archivo /etc/nginx/nginx.conf para editar.
$ sudo nano /etc/nginx/nginx.conf
Agrega la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Verifica la sintaxis del archivo de configuración de Nginx.
$ sudo nginx -t
nginx: el archivo de configuración /etc/nginx/nginx.conf tiene una sintaxis correcta
nginx: la prueba del archivo de configuración /etc/nginx/nginx.conf fue exitosa
Reinicia el servicio Nginx.
$ sudo systemctl restart nginx
Paso 15 - Instalar y configurar Supervisor
Supervisor es un administrador de procesos y lo usaremos como un monitor de procesos para el trabajador de mensajes (RabbitMQ) para Kbin. El primer paso es instalar Supervisor.
$ sudo apt install supervisor
Crea el archivo /etc/supervisor/conf.d/messenger-worker.conf y ábrelo para editar.
$ sudo nano /etc/supervisor/conf.d/messenger-worker.conf
Pega el siguiente código en él.
[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
Guarda el archivo presionando Ctrl + X y entrando Y cuando se te pida.
Ejecuta los siguientes comandos para volver a leer y actualizar el nuevo archivo de configuración.
$ sudo supervisorctl reread
$ sudo supervisorctl update
Inicia todos los servicios de Supervisor.
$ sudo supervisorctl start all
Paso 16 - Acceder a Kbin
Abre la URL https://example.com y obtendrás la siguiente página de inicio de Kbin.
Haz clic en el enlace Iniciar sesión en la parte superior para mostrar la página de inicio de sesión.
Ingresa las credenciales creadas en el paso 12 y haz clic en el botón Iniciar sesión para continuar. Serás llevado de regreso a la página de inicio de Kbin. Puedes comenzar a usar Kbin desde aquí.
Conclusión
Esto concluye nuestro tutorial sobre la instalación del agregador de contenido Kbin similar a Reddit en un servidor Ubuntu 22.04. Si tienes alguna pregunta, publícalas en los comentarios a continuación.
Recibe nuevas publicaciones en tu bandeja de entrada.
No spam. Cancela la suscripción en cualquier momento.