Cómo instalar BookWyrm en un servidor Debian 12
BookWyrm es una red social federada de código abierto para lectores de libros. Actúa como una alternativa a Goodreads sin publicidad. Utiliza el protocolo ActivityPub para enviar y recibir la actividad de los usuarios entre otras instancias de BookWyrm y otros servicios que utilizan el protocolo, como Mastodon. Ofrece muchas funciones, como reseñas de libros, valoraciones, actividad lectora, estanterías de libros como «pendientes de leer», «leyendo actualmente» y «leído», listas de libros y seguimiento de otros usuarios y su progreso de lectura. También ofrece funciones de moderación de usuarios, como bloquear o aprobar manualmente seguidores, y múltiples niveles de privacidad para estados, estanterías y listas.
En este tutorial, aprenderás a instalar la red social federada BookWyrm para lectores de libros en un servidor Debian 12.
Requisitos previos
- Un servidor con Debian 12.
- Un usuario no root con privilegios sudo.
- Un Nombre de Dominio Completamente Cualificado (FQDN) como
bookwyrm.example.comque apunte a tu servidor. - Una cuenta SMTP con un servicio de correo electrónico como Amazon SES o Mailgun.
- Asegúrate de que todo está actualizado.
$ sudo apt update $ sudo apt upgrade
- Pocos paquetes que necesite tu sistema.
$ sudo apt install wget curl nano ufw software-properties-common dirmngr apt-transport-https gnupg2 ca-certificates lsb-release debian-archive-keyring unzip -y
Puede que algunos de estos paquetes ya estén instalados en tu sistema.
Paso 1 – Configurar el cortafuegos
El primer paso es configurar el cortafuegos. Debian viene con ufw (Uncomplicated Firewall) por defecto.
Comprueba si el cortafuegos se está ejecutando.
$ sudo ufw status
Obtendrás la siguiente salida.
Status: inactive
Permite el puerto SSH para que el cortafuegos no rompa la conexión actual al activarlo.
$ sudo ufw allow OpenSSH
Permite también los puertos HTTP y HTTPS.
$ sudo ufw allow http $ sudo ufw allow https
Habilita el cortafuegos
$ sudo ufw enable Command may disrupt existing ssh connections. Proceed with operation (y|n)? y Firewall is active and enabled on system startup
Comprueba de nuevo el estado del cortafuegos.
$ sudo ufw status
Deberías ver un resultado similar.
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)
Paso 2 – Instalar y configurar PostgreSQL
Ubuntu 22.04 incluye PostgreSQL 14 por defecto. Nosotros utilizaremos PostgreSQL 15 en su lugar.
Ejecuta el siguiente comando para añadir 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
Añade 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 utilizando el comando siguiente.
$ sudo apt install postgresql postgresql-contrib
El paquete postgresql-contrib contiene algunas utilidades adicionales.
Comprueba el estado del servicio PostgreSQL.
$ sudo systemctl status postgresql
? postgresql.service - PostgreSQL RDBMS
Loaded: loaded (/lib/systemd/system/postgresql.service; enabled; preset: enabled)
Active: active (exited) since Sat 2023-09-09 07:39:21 UTC; 16s ago
Main PID: 3653 (code=exited, status=0/SUCCESS)
CPU: 1ms
Sep 09 07:39:21 bookwyrm systemd[1]: Starting postgresql.service - PostgreSQL RDBMS...
Sep 09 07:39:21 bookwyrm systemd[1]: Finished postgresql.service - PostgreSQL RDBMS.
Verás que el servicio está activado y en ejecución por defecto.
Inicia el intérprete de comandos PostgreSQL.
$ sudo -i -u postgres psql
Crea la base de datos BookWyrm.
postgres=# CREATE DATABASE bookwyrm TEMPLATE template0 ENCODING 'UNICODE';
Crea el usuario BookWyrm y elige una contraseña segura.
postgres-# CREATE USER bookwyrmuser WITH PASSWORD 'Your_Password';
Cambia el propietario de la base de datos por el usuario BookWyrm.
postgres-# ALTER DATABASE bookwyrm OWNER TO bookwyrmuser;
Concede todos los privilegios de la base de datos al usuario BookWyrm.
postgres-# GRANT ALL PRIVILEGES ON DATABASE bookwyrm TO bookwyrmuser;
Sal del intérprete de comandos.
postgres-# \q
Comprueba que tus credenciales funcionan.
$ psql --username bookwyrmuser --password --host localhost bookwyrm Password: psql (15.4 (Debian 15.4-1.pgdg120+1)) SSL connection (protocol: TLSv1.3, cipher: TLS_AES_256_GCM_SHA384, compression: off) Type "help" for help. bookwyrm=>
Sal del intérprete de comandos escribiendo \q.
Paso 3 – Instalar Redis
Magento utiliza Redis para el almacenamiento de sesiones y caché. Es totalmente opcional y puedes utilizar la base de datos para el 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 utilizaremos 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
Añade 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
Ejecuta el siguiente comando para instalar el servidor Redis.
$ sudo apt install redis
Confirma la versión de Redis.
$ redis-server -v Redis server v=7.2.1 sha=00000000:0 malloc=jemalloc-5.3.0 bits=64 build=95712a67f5005c28
Verifiquemos la conexión al servicio mediante el siguiente comando.
$ redis-cli
Pasarás a la shell de Redis.
El primer paso es establecer la contraseña para el usuario Redis por defecto. Sustituye Your_Redis_Password por una contraseña segura de tu elección. Asegúrate de anteponer a la contraseña el carácter >.
127.0.0.1:6379> acl setuser default >Your_Redis_Password
Prueba la autenticación de Redis.
127.0.0.1:6379> AUTH Your_Redis_Password OK
Haz ping al servicio.
127.0.0.1:6379> ping PONG
Sal del servicio escribiendo exit.
Si quieres, puedes utilizar el siguiente comando para generar la contraseña de Redis.
$ openssl rand 60 | openssl base64 -A OaYOuq6J9HhxMV0sGCeZbaGecphCl4GBfVkCOPkNjkQE1FX9DKpGSCJcDb8UV+AuFKA8tR1PgjGequn1
Paso 4 – Instalar Nginx
Debian 12 incluye una versión 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
Añade el repositorio de la versión estable de Nginx.
$ echo "deb [signed-by=/usr/share/keyrings/nginx-archive-keyring.gpg] \
http://nginx.org/packages/debian `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. En los sistemas Debian, el siguiente comando sólo funcionará con sudo.
$ sudo nginx -v nginx version: nginx/1.24.0
Inicia el servidor Nginx.
$ sudo systemctl start nginx
Comprueba el estado del servicio.
$ sudo systemctl status nginx
? nginx.service - nginx - high performance web server
Loaded: loaded (/lib/systemd/system/nginx.service; enabled; preset: enabled)
Active: active (running) since Sat 2023-09-09 08:40:27 UTC; 1s ago
Docs: https://nginx.org/en/docs/
Process: 6946 ExecStart=/usr/sbin/nginx -c /etc/nginx/nginx.conf (code=exited, status=0/SUCCESS)
Main PID: 6947 (nginx)
Tasks: 2 (limit: 1107)
Memory: 1.7M
CPU: 8ms
CGroup: /system.slice/nginx.service
??6947 "nginx: master process /usr/sbin/nginx -c /etc/nginx/nginx.conf"
??6948 "nginx: worker process"
Paso 5 – Instalar SSL
Necesitamos instalar Certbot para generar el certificado SSL. Puedes instalar Certbot utilizando el repositorio de Debian u obtener la última versión utilizando la herramienta Snapd. Nosotros utilizaremos la versión Snapd.
Debian 12 no viene con Snapd instalado. Instala el paquete Snapd.
$ sudo apt install snapd
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
Utiliza el siguiente comando para asegurarte de que se puede ejecutar el comando Certbot creando un enlace simbólico al directorio /usr/bin.
$ sudo ln -s /snap/bin/certbot /usr/bin/certbot
Comprueba si Certbot funciona correctamente.
$ certbot --version certbot 2.6.0
Genera el certificado SSL.
$ sudo certbot certonly --nginx --agree-tos --no-eff-email --staple-ocsp --preferred-challenges http -m [email protected] -d bookwyrm.example.com
El comando anterior descargará un certificado en el directorio /etc/letsencrypt/live/bookwyrm.example.com de tu servidor.
Genera un certificado de grupo Diffie-Hellman.
$ sudo openssl dhparam -dsaparam -out /etc/ssl/certs/dhparam.pem 4096
Comprueba 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 ---------------------------------------------------------------------------------------------------------------- Sat 2023-09-09 23:49:00 UTC 15h left - - snap.certbot.renew.timer snap.certbot.renew.service Sun 2023-09-10 00:00:00 UTC 15h left - - dpkg-db-backup.timer dpkg-db-backup.service Sun 2023-09-10 00:00:00 UTC 15h left Sat 2023-09-09 06:42:47 UTC 2h 1min ago exim4-base.timer exim4-base.service
Realiza una ejecución en seco del proceso para comprobar si la renovación SSL funciona correctamente.
$ sudo certbot renew --dry-run
Si no ves ningún error, ya está todo listo. Tu certificado se renovará automáticamente.
Paso 6 – Descarga BookWyrm
Crea un directorio para BookWyrm.
$ sudo mkdir /opt/bookwyrm
Accede al directorio.
$ cd /opt/bookwyrm
Clona la rama de producción de la aplicación BookWyrm desde GitHub.
$ sudo git clone https://github.com/bookwyrm-social/bookwyrm.git --branch production --single-branch ./
Crea el archivo de entorno copiando el archivo de ejemplo.
$ sudo cp .env.example .env
Paso 7 – Configurar BookWyrm
Genera una clave secreta para BookWyrm.
$ openssl rand 60 | openssl base64 -A wcMjI1FW0mL9RfyxYDNZE/8bQP88kVIAUh7ekcSNAOUQCVfNeuMeW3und4BO5WbyCYy+9KpHqoEHWCkl
Abre el archivo de entorno para editarlo.
$ sudo nano .env
Configura las siguientes variables.
SECRET_KEY="wcMjI1FW0mL9RfyxYDNZE/8bQP88kVIAUh7ekcSNAOUQCVfNeuMeW3und4BO5WbyCYy+9KpHqoEHWCkl" DOMAIN=bookwyrm.example.com [email protected] POSTGRES_PASSWORD=Your_Password POSTGRES_USER=bookwyrmuser POSTGRES_DB=bookwyrm POSTGRES_HOST=localhost REDIS_ACTIVITY_HOST=localhost REDIS_ACTIVITY_PORT=6379 REDIS_ACTIVITY_PASSWORD=Your_Redis_Password REDIS_ACTIVITY_DB_INDEX=0 REDIS_BROKER_HOST=localhost REDIS_BROKER_PORT=6379 REDIS_BROKER_PASSWORD=Your_Redis_Password REDIS_BROKER_DB_INDEX=1 FLOWER_USER=username FLOWER_PASSWORD=flowerpassword EMAIl_HOST= EMAIL_PORT=587 EMAIL_HOST_USER=AmazonSESUSER EMAIL_HOST_PASSWORD=AmazonSESPASSWORD EMAIL_USE_TLS=true EMAIL_USE_SSL=false EMAIL_SENDER_NAME=HowtoForge EMAIL_SENDER_DOMAIN=example.com ## only enable it if you have a fairly powered server with a minimum of 2 CPU Cores and 2GB of RAM ENABLE_PREVIEW_IMAGES=true
Repasemos todas las variables del archivo de entorno.
SECRET_KEY– la clave que generaste anteriormenteDOMAIN– el nombre de dominio completo (FQDN) de tu instancia de BookWyrn. En nuestro caso, seríabookwyrm.example.com.POSTGRES_PASSWORD– Contraseña PostgreSQL configurada en el paso 2.POSTGRES_HOST– configurado alocalhostsi lo alojas en la misma máquina.POSTGRES_USER– fijado abookwyrmuserque elegiste en el paso 2.POSTGRES_DB– configurado abookwyrmque elegiste en el paso 2.REDIS_ACTIVITY_HOSTyREDIS_BROKER_HOST– establécelos en localhost si alojas el servidor Redis en la misma máquina.REDIS_ACTIVITY_PORTyREDIS_BROKER_PORT– establécelos en el puerto Redis 6379 por defecto.REDIS_ACTIVITY_DByREDIS_BROKER_DB– establécelos en 0 y 1 respectivamente. Utilizaremos bases de datos diferentes para ambos.REDIS_ACTIVITY_PASSWORDyREDIS_BROKER_PASSWORD– configúralos con la contraseña de Redis elegida en el paso 3.FLOWER_USER– elige un nombre de usuario para el servicio Flower, necesario para BookWyrm.FLOWER_PASSWORD– elige una contraseña para el servicio Flower.EMAIL_HOST– establece el host SMTP del servicio de correo electrónico que estés utilizando.EMAIL_PORT– Establece el puerto SMTP del servicio de correo electrónico.EMAIL_HOST_USER– Establece el nombre de usuario SMTP.EMAIL_HOST_PASSWORD– Establece la contraseña SMTP.EMAIL_USE_TLS– ponlo a true si tu servicio de correo electrónico utiliza TLS.EMAIL_USE_SSL– Establécelo como verdadero si tu servicio de correo electrónico utiliza SSL.EMAIL_SENDER_NAME– elige el nombre del remitente para los correos electrónicos enviados por tu instancia.EMAIL_SENDER_DOMAIN– Establécelo como el nombre de dominio utilizado por el servicio de correo electrónico.ENABLE_PREVIEW_IMAGES– ponlo a true si quieres que tu instancia genere imágenes de previsualización automáticamente. Sin embargo, asegúrate de que tu servidor dispone de suficiente CPU y RAM para ello, ya que se trata de un proceso intensivo.
Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Paso 8 – Configurar Nginx
Copia el archivo /opt/bookwyrm/nginx/server_config al directorio de configuración de Nginx.
$ sudo cp /opt/bookwyrm/nginx/server_config /etc/nginx/conf.d/server_config
Crea y abre el archivo /etc/nginx/conf.d/bookwyrm.conf para editarlo.
$ sudo nano /etc/nginx/conf.d/bookwyrm.conf
Pega en él el siguiente código.
include /etc/nginx/conf.d/server_config;
upstream web {
server localhost:8000;
}
server {
listen [::]:80;
listen 80;
server_name bookwyrm.example.com;
# redirect http to https
return 301 https://bookwyrm.example.com$request_uri;
}
server {
access_log /var/log/nginx/bookwyrm.access.log cache_log;
error_log /var/log/nginx/bookwyrm.error.log;
listen [::]:443 ssl http2;
listen 443 ssl http2;
server_name bookwyrm.example.com;
client_max_body_size 3M;
if ($host != "bookwyrm.example.com") {
return 301 $scheme://bookwyrm.example.com$request_uri;
}
# SSL code
ssl_certificate /etc/letsencrypt/live/bookwyrm.example.com/fullchain.pem;
ssl_certificate_key /etc/letsencrypt/live/bookwyrm.example.com/privkey.pem;
ssl_trusted_certificate /etc/letsencrypt/live/bookwyrm.example.com/chain.pem;
ssl_session_timeout 1d;
ssl_session_cache shared:MozSSL:10m;
ssl_session_tickets off;
ssl_prefer_server_ciphers off;
ssl_stapling on;
ssl_stapling_verify on;
ssl_dhparam /etc/ssl/certs/dhparam.pem;
resolver 1.1.1.1 1.0.0.1 [2606:4700:4700::1111] [2606:4700:4700::1001] 8.8.8.8 8.8.4.4 [2001:4860:4860::8888] [2001:4860:4860::8844] valid=60s;
resolver_timeout 2s;
ssl_protocols TLSv1.2 TLSv1.3;
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;
tcp_nopush on;
types_hash_max_size 2048;
gzip on;
proxy_read_timeout 1800s;
# store responses to anonymous users for up to 1 minute
proxy_cache bookwyrm_cache;
proxy_cache_valid any 1m;
add_header X-Cache-Status $upstream_cache_status;
# ignore the set cookie header when deciding to
# store a response in the cache
proxy_ignore_headers Cache-Control Set-Cookie Expires;
# PUT requests always bypass the cache
# logged in sessions also do not populate the cache
# to avoid serving personal data to anonymous users
proxy_cache_methods GET HEAD;
proxy_no_cache $cookie_sessionid;
proxy_cache_bypass $cookie_sessionid;
# tell the web container the address of the outside client
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
proxy_set_header Host $host;
proxy_redirect off;
location ~ ^/(login[^-/]|password-reset|resend-link|2fa-check) {
limit_req zone=loginlimit;
proxy_pass http://web;
}
# do not log periodic polling requests from logged in users
location /api/updates/ {
access_log off;
proxy_pass http://web;
}
location / {
proxy_pass http://web;
}
# directly serve images and static files from the
# bookwyrm filesystem using sendfile.
# make the logs quieter by not reporting these requests
location ~ ^/(images|static)/ {
root /opt/bookwyrm;
try_files $uri =404;
add_header X-Cache-Status STATIC;
access_log off;
}
# monitor the celery queues with flower, no caching enabled
location /flower/ {
proxy_pass http://localhost:8888;
proxy_cache_bypass 1;
}
}
Cuando hayas terminado, guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Abre el archivo /etc/nginx/nginx.conf para editarlo.
$ sudo nano /etc/nginx/nginx.conf
Añade la siguiente línea antes de la línea include /etc/nginx/conf.d/*.conf;.
server_names_hash_bucket_size 64;
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te solicite.
Comprueba la sintaxis del archivo de configuración de 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
Reinicia el servicio Nginx para habilitar la nueva configuración.
$ sudo systemctl restart nginx
Paso 9 – Instalar BookWyrm
Antes de instalar BookWyrm, necesitamos instalar algunos paquetes de Python.
$ sudo apt install python3-venv python3-pip python3-dev libpq-dev
Cambia al directorio Bookwyrm.
$ cd /opt/bookwyrm
Cambia la propiedad de la carpeta al usuario actualmente conectado.
$ sudo chown -R $USER:$USER .
Crea el directorio venv de Python.
$ python3 -m venv ./venv
Instala las dependencias Python de BookWyrm utilizando el gestor de paquetes pip.
$ ./venv/bin/pip3 install -r requirements.txt
Migra el esquema de la base de datos.
$ venv/bin/python3 manage.py migrate
Inicializa la base de datos.
$ venv/bin/python3 manage.py initdb
Compila los temas.
$ venv/bin/python3 manage.py compile_themes
Crea los archivos estáticos.
$ venv/bin/python3 manage.py collectstatic --no-input
Crea y configura el usuario del sistema BookWyrm.
$ sudo useradd bookwyrm -r
Cambiar el propietario del directorio de instalación al usuario BookWyrm.
$ sudo chown -R bookwyrm:bookwyrm /opt/bookwyrm
A partir de ahora, para ejecutar cualquier comando relacionado con BookWyrm, ejecútalo como el usuario BookWyrm.
$ sudo -u bookwyrm echo I am the ${whoami} user
I am the bookwyrm user
Crear el archivo de unidad de servicio de BookWyrm
BookWyrm se entrega con los archivos de unidad de servicio para el servicio, el trabajador y el programador. Cópialos en el directorio /etc/systemd/system.
$ sudo cp /opt/bookwyrm/contrib/systemd/*.service /etc/systemd/system/
Habilita e inicia los servicios utilizando el siguiente comando.
$ sudo systemctl enable bookwyrm bookwyrm-worker bookwyrm-scheduler --now
Comprueba el estado del servicio BookWyrm.
$ sudo systemctl status bookwyrm
? bookwyrm.service - BookWyrm
Loaded: loaded (/etc/systemd/system/bookwyrm.service; enabled; preset: enabled)
Active: active (running) since Mon 2023-09-11 00:05:54 UTC; 7s ago
Main PID: 28583 (gunicorn)
Tasks: 2 (limit: 1107)
Memory: 99.2M
CPU: 1.254s
CGroup: /system.slice/bookwyrm.service
??28583 /opt/bookwyrm/venv/bin/python3 /opt/bookwyrm/venv/bin/gunicorn bookwyrm.wsgi:application --bind 0.0.0.0:8000
??28603 /opt/bookwyrm/venv/bin/python3 /opt/bookwyrm/venv/bin/gunicorn bookwyrm.wsgi:application --bind 0.0.0.0:8000
Del mismo modo, puedes comprobar el estado de los dos servicios restantes.
El último paso del proceso de instalación consiste en generar el código de administrador necesario para crear la cuenta de administrador.
$ sudo -u bookwyrm /opt/bookwyrm/venv/bin/python3 /opt/bookwyrm/manage.py admin_code
Puedes obtener el código en cualquier momento volviendo a ejecutar el mismo comando.
Deberías obtener un resultado similar.
******************************************* Use this code to create your admin account: 299f3181-e57e-4f16-94c9-51cfc427b8df *******************************************
El siguiente paso es acceder a BookWyrm y configurar tu instancia.
Paso 10 – Acceder a BookWyrm
Abre la URL https://bookwyrm.example.com en tu navegador y obtendrás la siguiente página.
Si todo parece correcto, haz clic en el botón Continuar para pasar a la página siguiente.
Introduce la clave de administrador que obtuviste en el paso anterior junto con las credenciales de la cuenta de administrador. Pulsa el botón Registrarse cuando hayas terminado para pasar a la página siguiente.
Aquí se te pedirá que configures tu sitio y añadas información y políticas del sitio.
A continuación, comprueba tu configuración de correo electrónico haciendo clic en Sistema >> Configuración de correo electrónico en la barra lateral izquierda. Confirma tu configuración de correo electrónico que aparece en la página y haz clic en el botón Enviar correo de prueba para enviarte un correo de prueba.
Si el correo se envió correctamente, deberías recibir el siguiente correo.
También puedes configurar los ajustes restantes accediendo a ellos desde la barra lateral izquierda. Una vez hayas hecho todo esto, tu instancia de BookWyrm estará lista para ser utilizada.
Paso 11 – Copia de seguridad de BookWyrm
BookWyrm incluye una utilidad de copia de seguridad, pero está personalizada para la instalación Docker. También incluye una utilidad de poda automática de copias de seguridad que limpia automáticamente la carpeta de copias de seguridad. Cambiaremos la utilidad de copia de seguridad para adaptarla a nuestro método de instalación y utilizaremos junto con ella la utilidad de poda de copias de seguridad suministrada.
Crea el archivo ~/bookwyrm-backup.sh y ábrelo para editarlo.
$ nano ~/bookwyrm-backup.sh
Pega en él el siguiente código.
#!/bin/bash
POSTGRES_DB=bookwyrm
POSTGRES_USER=bookwyrmuser
if [ -z "$POSTGRES_DB" ]; then
echo "Database not specified, defaulting to bookwyrm"
fi
if [ -z "$POSTGRES_USER" ]; then
echo "Database user not specified, defaulting to bookwyrm"
fi
BACKUP_DB=${POSTGRES_DB:-bookwyrm}
BACKUP_USER=${POSTGRES_USER:-bookwyrm}
filename=backup_${BACKUP_DB}_$(date +%F)_$(date +%T)
PGPASSWORD="Your_Password" pg_dump -h localhost -U $BACKUP_USER $BACKUP_DB > ~/backups/$filename.sql
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida. Cambia los valores de las variables POSTGRES_DB, POSTGRES_USER, y PGPASSWORD según los valores que configuraste en el paso 2.
Copia el archivo en el directorio /usr/local/bin.
$ sudo cp ~/bookwyrm-backup.sh /usr/local/bin/bookwyrm-backup.sh
Haz ejecutable el archivo de copia de seguridad.
$ sudo chmod +x /usr/local/bin/bookwyrm-backup.sh
Crea el directorio de copia de seguridad.
$ mkdir ~/backups
Copia el archivo /opt/bookwyrm/postgres-docker/weed.sh en el directorio /usr/local/bin.
$ sudo cp /opt/bookwyrm/postgres-docker/weed.sh /usr/local/bin/bookwyrm-weed.sh
Crea y abre el archivo cronfile para editarlo.
$ nano cronfile
Pega en él el siguiente código.
0 0 * * * /usr/local/bin/bookwyrm-backup.sh # This script will weed the backups directory. It will keep the 14 # most-recent backups, then one backup/week for the next four backups, then one # backup/month after that. 0 5 * * * /usr/local/bin/bookwyrm-weed.sh -d 14 -w 4 -m -1 ~/backups
Guarda el archivo pulsando Ctrl + X e introduciendo Y cuando se te pida.
Copia el cronfile al directorio /etc/cron.d.
$ sudo cp ~/cronfile /etc/cron.d/cronfile
Establece los permisos correctos para el cronfile.
$ sudo chmod 0644 /etc/cron.d/cronfile
Envía el archivo al directorio crontab.
$ sudo crontab /etc/cron.d/cronfile
Crea el archivo cron.log.
$ sudo touch /var/log/cron.log
Prueba la creación de la copia de seguridad.
$ bookwyrm-backup.sh
Comprueba el directorio de copias de seguridad.
$ ls ~/backups -al total 764 drwxr-xr-x 2 navjot navjot 4096 Sep 11 01:31 . drwx------ 7 navjot navjot 4096 Sep 11 01:31 .. -rw-r--r-- 1 navjot navjot 257577 Sep 11 01:21 backup_bookwyrm_2023-09-11.sql -rw-r--r-- 1 navjot navjot 257577 Sep 11 01:27 backup_bookwyrm_2023-09-11_01:27:35.sql -rw-r--r-- 1 navjot navjot 257577 Sep 11 01:31 backup_bookwyrm_2023-09-11_01:31:45.sql
Paso 12 – Actualizar BookWyrm
Actualizar tu instancia de BookWyrm implica varios pasos. Primero, extrae los últimos cambios del repositorio GitHub de BookWyrm.
$ cd /opt/bookwyrm $ sudo -u bookwyrm git pull
Instala las nuevas dependencias de Python.
$ sudo -u bookwyrm venv/bin/pip install -r requirements.txt
Compila los temas.
$ sudo -u bookwyrm venv/bin/python3 manage.py compile_themes
Recopila todos los archivos estáticos.
$ sudo -u bookwyrm venv/bin/python3 manage.py collectstatic --no-input
Migrar la base de datos. Crea primero una copia de seguridad siguiendo el paso anterior.
$ sudo -u bookwyrm venv/bin/python3 manage.py migrate
Reinicia los servicios de BookWyrm.
$ sudo systemctl restart bookwyrm bookwyrm-worker bookwyrm-scheduler
Conclusión
Con esto concluye nuestro tutorial sobre la instalación de la red social BookWyrm en un servidor Debian 12. Si tienes alguna pregunta, publícala en los comentarios a continuación.