Cómo instalar la red social Mastodon con Docker en Ubuntu 18.04 LTS

Mastodon es una red social libre, descentralizada y de código abierto. Se creó como alternativa a Twitter. Al igual que en Twitter, la gente puede seguirse entre sí, publicar mensajes, imágenes y vídeos. Pero a diferencia de Twitter, no hay un almacén central ni una autoridad para el contenido.

En su lugar, Mastodon opera a través de miles de servidores diferentes, cada uno de los cuales está dirigido por varios miembros de la comunidad. Los usuarios inscritos en un servidor pueden conectarse fácilmente con los usuarios de la otra red y seguirse entre instancias.

Cualquiera puede instalar su propia instancia de un servidor Mastodon. Este tutorial te enseñará a configurar tu instancia de Mastodon en un servidor con Ubuntu 18.04 utilizando Docker.

Requisitos previos

  • Un servidor basado en Ubuntu 18.04 con un usuario sudo no root.

  • Asegúrate de que tu sistema está actualizado.

    $ sudo apt update
    $ sudo apt upgrade
    
  • Mastodon envía notificaciones por correo electrónico a los usuarios. Una opción para que funcione es configurar tu propio servidor de correo. Puedes hacerlo en el mismo servidor en el que vas a instalar Mastodon o en un servidor diferente. Hacerlo está fuera del alcance de esta guía.

    Te recomendamos que utilices un servicio de correo transaccional de terceros como Mailgun, Sendgrid, Amazon SES o Sparkpost. Las instrucciones de la guía utilizarán Mailgun como proveedor de SMTP.

  • Asegúrate de que tienes un nombre de dominio que apunta al servidor. Para este tutorial, usaremos example.com como dominio.

Paso 1 - Instalación de las dependencias

Antes de instalar Mastodon, tenemos que asegurarnos de que nuestro servidor tiene cierto software que necesitará para instalarse correctamente. Ejecuta los siguientes comandos para instalar las dependencias.

$ sudo apt update
$ sudo apt install ca-certificates curl ufw apt-transport-https software-properties-common git -y

Algunos de los programas anteriores pueden estar preinstalados para ti.

Como hemos instalado Git, debemos configurarlo antes de continuar.

$ git config --global user.name "Your Name" 
$ git config --global user.email "[email protected]"

Paso 2 - Configurar el cortafuegos

En nuestro paso anterior, instalamos, ufw (Uncomplicated Firewall). Antes de proceder a instalar Mastodon, debemos configurarlo.

Activa el SSH y el puerto que acabamos de crear para que no se nos bloquee.

$ sudo ufw allow OpenSSH

Habilitar el cortafuegos ufw.

$ sudo ufw enable

También tenemos que habilitar http y https para que Mastodon funcione.

$ sudo ufw allow http
$ sudo ufw allow https

Comprueba el estado del cortafuegos.

$ sudo ufw status

Deberías ver una salida como la siguiente.

Status: active

To                         Action      From
--                         ------      ----
OpenSSH                    ALLOW       Anywhere                  
80/tcp                     ALLOW       Anywhere                  
443/tcp                    ALLOW       Anywhere                  
OpenSSH (v6)               ALLOW       Anywhere (v6)             
80/tcp (v6)                ALLOW       Anywhere (v6)             
443/tcp (v6)               ALLOW       Anywhere (v6)             

Paso 3 - Instalar Docker

Añade la clave GPG de Docker a tu sistema.

$ curl -fsSL https://download.docker.com/linux/ubuntu/gpg | sudo apt-key add -

Comprueba la huella digital de la clave descargada.

$ sudo apt-key fingerprint 0EBFCD88

Deberías ver una salida como la siguiente.

pub   rsa4096 2017-02-22 [SCEA]
      9DC8 5822 9FC7 DD38 854A  E2D8 8D81 803C 0EBF CD88
uid           [ unknown] Docker Release (CE deb) <[email protected]>
sub   rsa4096 2017-02-22 [S]

Añade el repositorio de Docker.

$ sudo add-apt-repository "deb [arch=amd64] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"

Actualiza tu base de datos de paquetes.

$ sudo apt update

Instala Docker-CE. CE es la edición comunitaria de Docker.

$ sudo apt install docker-ce -y

Docker debería estar instalado ahora. Comprueba que se está ejecutando.

$ sudo systemctl status docker

La salida debería ser similar a la siguiente.

? docker.service - Docker Application Container Engine
   Loaded: loaded (/lib/systemd/system/docker.service; enabled; vendor preset: enabled)
   Active: active (running) since Tue 2019-10-22 18:26:29 UTC; 25min ago
     Docs: https://docs.docker.com
 Main PID: 3574 (dockerd)
    Tasks: 8
   CGroup: /system.slice/docker.service
   ??3574 /usr/bin/dockerd -H fd:// --containerd=/run/containerd/containerd.sock

Pulsa q para salir.

Añade tu cuenta de usuario limitado de Linux al grupo de Docker para que puedas ejecutar Docker sin sudo.

sudo usermod -aG docker $USER

La variable$USER elegirá y añadirá al grupo docker el usuario actual que haya iniciado la sesión. Sustituye $USER por el nombre de usuario real si no has iniciado la sesión con ese usuario.

Cambia al usuario que acabamos de añadir. Aunque ya hayas iniciado la sesión, tendrás que volver a cambiar a él para recargar los permisos.

$ su - ${USER}

Comprueba que todo funciona bien ejecutando el programa incorporado "Hola Mundo ".

$ docker run hello-world

Deberías ver la siguiente salida que te indicará que Docker está instalado y funciona correctamente.

Unable to find image 'hello-world:latest' locally
latest: Pulling from library/hello-world
1b930d010525: Pull complete 
Digest: sha256:c3b4ada4687bbaa170745b3e4dd8ac3f194ca95b2d0518b417fb47e5879d9b5f
Status: Downloaded newer image for hello-world:latest

Hello from Docker!
This message shows that your installation appears to be working correctly.

Paso 4 - Instalar Docker Compose

Es posible saltarse este paso y continuar, pero tener instalado Docker Compose hará que la ejecución de Mastodon sea mucho más fácil, especialmente si quieres hacerlo en más de un servidor.

$ sudo curl -L "https://github.com/docker/compose/releases/download/1.24.1/docker-compose-$(uname -s)-$(uname -m)" -o /usr/local/bin/docker-compose

En el momento de escribir este tutorial, 1.24.1 es la versión estable actual de Docker Compose. Puedes consultar la última versión en su página de Github.

Aplica los permisos de ejecución al binario de Docker Compose.

$ sudo chmod +x /usr/local/bin/docker-compose

Añade la finalización de comandos a Docker Compose.

$ sudo curl -L https://raw.githubusercontent.com/docker/compose/1.24.1/contrib/completion/bash/docker-compose -o /etc/bash_completion.d/docker-compose

Comprueba si la instalación se ha realizado correctamente.

$ docker-compose --version

Se imprimirá la siguiente salida.

docker-compose version 1.24.1, build 4667896b

Paso 5 - Instalar Mastodon

Clona el repositorio de Mastodon en tu servidor.

$ git clone https://github.com/tootsuite/mastodon

Navega hasta el directorio en el que acabamos de copiar los archivos.

$ cd mastodon

Mastodon viene con un archivo de configuración de ejemplo. Tenemos que renombrarlo para que Mastodon funcione.

$ cp .env.production.sample .env.production

Tenemos que generar claves secretas para nuestro archivo de configuración. Pero antes, tenemos que construir la imagen Docker.

$ docker-compose build

Ahora que la imagen está construida con éxito, necesitas crear varias claves que son necesarias para configurar Mastodon.

Genera primero SECRET_KEY_BASE.

$ SECRET_KEY_BASE=$(docker-compose run --rm web bundle exec rake secret)

Inserta la clave anterior en el archivo de configuración.

$ sed -i -e "s/SECRET_KEY_BASE=/&${SECRET_KEY_BASE}/" .env.production

Genera e inserta la OTP_SECRET en el archivo de configuración.

$ OTP_SECRET=$(docker-compose run --rm web bundle exec rake secret)
$ sed -i -e "s/OTP_SECRET=/&${OTP_SECRET}/" .env.production

Genera e inserta el PAPERCLIP_SECRET en el fichero de configuración.

$ PAPERCLIP_SECRET=$(docker-compose run --rm web bundle exec rake secret)
$ sed -i -e "s/PAPERCLIP_SECRET=/&${PAPERCLIP_SECRET}/" .env.production

Genera valores para VAPID_PRIVATE_KEY y VAPID_PUBLIC_KEY.

$ docker-compose run --rm web bundle exec rake mastodon:webpush:generate_vapid_key

Abre el archivo .env.production.

$ sudo nano ./.env.production

Busca VAPID_PRIVATE_KEY y VAPID_PUBLIC_KEY en el archivo y copia el resultado del comando anterior.

Busca la variable LOCAL_DOMAIN y cambia su valor de ejemplo.com al nombre de dominio que hayas elegido para tu instalación de Mastodon.

Introduce los valores que has obtenido de tu proveedor de SMTP.

SMTP_SERVER = smtp.mailgun.org
SMTP_PORT = 587
SMTP_LOGIN = username
SMTP_PASSWORD = password
SMTP_FROM_ADDRESS = [email protected]

Pulsa Ctrl + X y guarda el archivo cuando hayas terminado.

Tienes que volver a construir la imagen Docker para aplicar todos los cambios realizados anteriormente.

$ docker-compose build

Configura la base de datos.

$ docker-compose run --rm web rails db:migrate

Precompila los activos de Mastodon.

$ docker-compose run --rm web rails assets:precompile

Ejecuta el siguiente comando para ejecutar el contenedor.

$ docker-compose up -d

Paso 6 - Instalar y configurar Nginx

El siguiente paso de nuestra guía es instalar el servidor Nginx para hacer funcionar el sitio web de Mastodon.

Ejecuta el siguiente comando para instalar el servidor Nginx.

$ sudo apt install nginx -y

Nginx viene con un sitio configurado por defecto. Elimina eso.

$ sudo rm /etc/nginx/sites-available/default

Elimina también el enlace simbólico del sitio por defecto.

$ sudo rm /etc/nginx/sites-enabled/default

Crea un archivo de configuración de Nginx para Mastodon.

$ sudo touch /etc/nginx/sites-available/mastodon

Crea un enlace simbólico para la configuración de Mastodon.

$ sudo ln -s /etc/nginx/sites-available/mastodon /etc/nginx/sites-enabled/mastodon

Abre la configuración de Mastodon en el editor Nano. (Puedes elegir el editor que quieras)

$ sudo nano /etc/nginx/sites-available/mastodon

Copia y pega el siguiente texto en él.

map $http_upgrade $connection_upgrade {
  default upgrade;
  ''      close;
}

server {
  listen 80;
  listen [::]:80;
  server_name example.com;
  root /home/user/mastodon/public;
  # Useful for Let's Encrypt
  location /.well-known/acme-challenge/ { allow all; }
  location / { return 301 https://$host$request_uri; }
}

server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name example.com;

  ssl_protocols TLSv1.2;
  ssl_ciphers HIGH:!MEDIUM:!LOW:!aNULL:!NULL:!SHA;
  ssl_prefer_server_ciphers on;
  ssl_session_cache shared:SSL:10m;

  ssl_certificate     /etc/letsencrypt/live/example.com/fullchain.pem;
  ssl_certificate_key /etc/letsencrypt/live/example.com/privkey.pem;

  keepalive_timeout    70;
  sendfile             on;
  client_max_body_size 80m;

  root /home/user/mastodon/public;

  gzip on;
  gzip_disable "msie6";
  gzip_vary on;
  gzip_proxied any;
  gzip_comp_level 6;
  gzip_buffers 16 8k;
  gzip_http_version 1.1;
  gzip_types text/plain text/css application/json application/javascript text/xml application/xml application/xml+rss text/javascript;

  add_header Strict-Transport-Security "max-age=31536000";

  location / {
    try_files $uri @proxy;
  }

  location ~ ^/(emoji|packs|system/accounts/avatars|system/media_attachments/files) {
    add_header Cache-Control "public, max-age=31536000, immutable";
    try_files $uri @proxy;
  }
  
  location /sw.js {
    add_header Cache-Control "public, max-age=0";
    try_files $uri @proxy;
  }

  location @proxy {
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header Proxy "";
    proxy_pass_header Server;

    proxy_pass http://127.0.0.1:3000;
    proxy_buffering off;
    proxy_redirect off;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $connection_upgrade;

    tcp_nodelay on;
  }

  location /api/v1/streaming {
    proxy_set_header Host $host;
    proxy_set_header X-Real-IP $remote_addr;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-Proto https;
    proxy_set_header Proxy "";

    proxy_pass http://127.0.0.1:4000;
    proxy_buffering off;
    proxy_redirect off;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection $connection_upgrade;

    tcp_nodelay on;
  }

  error_page 500 501 502 503 504 /500.html;
}

La configuración anterior asume que estás usando Let's encrypt como tu proveedor de SSL. Si estás usando otro servicio SSL, entonces tienes que editar la ubicación de las claves y saltarte la siguiente sección del tutorial.

Paso 7 - Instalar y configurar Let's Encrypt

Asegúrate de que Nginx está parado.

$ sudo systemctl stop nginx

Añade el repositorio de Certbot.

$ sudo add-apt-repository ppa:certbot/certbot

Actualiza los paquetes del sistema.

$ sudo apt update

Instala la herramienta Certbot.

$ sudo apt install certbot

Tienes que crear el certificado dos veces: una con el método TLS SNI y la segunda con el método webroot.

sudo certbot certonly --standalone -d example.com

Ahora, crea el certificado utilizando el método webroot. Para ello necesitarás que Nginx esté en funcionamiento.

sudo systemctl start nginx
sudo certbot certonly --webroot -d example.com -w /home/user/mastodon/public/

La herramienta te preguntará si quieres mantener el certificado o renovarlo. Elige la opción de renovar.

Configurar la renovación automática de los certificados SSL

Los certificados Let's Encrypt tienen una validez de 90 días. Una vez transcurridos, deberás renovarlos de nuevo. Para ello, puedes crear una tarea cron que lo haga automáticamente por ti.

Crea una tarea cron.

$ sudo nano /etc/cron.daily/letsencrypt-renew

Copia y pega lo siguiente en el archivo.

#!/usr/bin/env bash
certbot renew
systemctl reload nginx

Guarda y sal del archivo pulsando Ctrl + X e introduciendo Y cuando te lo pida.

Haz que el script sea ejecutable y reinicia el demonio cron para que nuestro script se ejecute diariamente.

$ sudo chmod +x /etc/cron.daily/letsencrypt-renew
$ sudo systemctl restart cron

Paso 8 - Crea tu usuario Mastodon

Visita tu sitio mastodóntico en un navegador. Deberías ver la siguiente pantalla.

Añadir usuario de Mastodonte

Introduce el nombre de usuario, la dirección de correo electrónico y la contraseña que desees para crear una nueva cuenta en tu instancia de Mastodon. El nombre de usuario completo que necesitarás para conectarte con los usuarios de otros servidores de Mastodon es [email protected]

Mastodon te enviará un correo de confirmación para verificar el registro.

También puedes confirmar manualmente el registro. Para ello, tendrás que acceder por SSH a tu instancia Docker. Enumera todas las instancias Docker actuales.

$ docker ps

Verás un resultado como el siguiente.

CONTAINER ID        IMAGE                 COMMAND                  CREATED             STATUS                  PORTS                      NAMES
32f2c4cd2598        tootsuite/mastodon    "/tini -- bash -c 'r…"   16 hours ago        Up 16 hours (healthy)   127.0.0.1:3000->3000/tcp   mastodon_web_1
76beca2b858d        tootsuite/mastodon    "/tini -- node ./str…"   16 hours ago        Up 16 hours (healthy)   127.0.0.1:4000->4000/tcp   mastodon_streaming_1
08f7a42b75ac        tootsuite/mastodon    "/tini -- bundle exe…"   16 hours ago        Up 16 hours                                        mastodon_sidekiq_1
bacaa8c09a85        redis:5.0-alpine      "docker-entrypoint.s…"   17 hours ago        Up 17 hours (healthy)                              mastodon_redis_1
62e9b2175a53        postgres:9.6-alpine   "docker-entrypoint.s…"   17 hours ago        Up 17 hours (healthy)                              mastodon_db_1

Para realizar los cambios necesarios, necesitamos acceder al contenedor de streaming. Accede mediante SSH al contenedor mastodon_streaming_1.

$ docker exec -it mastodon_streaming_1 /bin/bash

Esto lanzará un shell Bash dentro de tu contenedor.

Ejecuta el siguiente comando para aprobar tu recién creado nombre de usuario.

[email protected]:~$ RAILS_ENV=production bin/tootctl accounts modify howtoforge --confirm

Ejecuta el siguiente comando para convertir tu cuenta recién creada en un administrador.

[email protected]:~$ RAILS_ENV=production bin/tootctl accounts modify howtoforge --role admin

Sal del contenedor.

[email protected]:~$ exit

Accede a tu instancia con tu nombre de usuario y contraseña y te aparecerá la siguiente pantalla.

Primeros pasos del mastodonte

Haz clic en Vamos y pasarás a las siguientes páginas que te permitirán conocer algunos aspectos básicos del funcionamiento de Mastodon.

Cómo funciona Mastodon

Responder - Impulsar - Favorito

Haz clic en Finalizar el tutorial para que te aparezca la página de inicio de Mastodon, donde podrás empezar a publicar a gusto.

Panel de control de Mastodonte

Puedes acceder a la configuración y al área de administración desde el menú de Preferencias.

Paso 9 - Mantenimiento

Para ver el rendimiento y los registros de tu instancia de Mastodon, dirígete a https://example.com/sidekiq/

Aquí puedes ver una lista de varios procesos y tareas programadas relacionadas con tu instancia de Mastodon. También puedes comprobar si hay tareas fallidas en la sección Muertos o Reintentos. También te indicará el uso de memoria de tu instancia.

Mantenimiento de mastodontes

Puedes comprobar el estado de la base de datos de tu instancia desde https://example.com/pghero/

pghero

Puedes realizar el mantenimiento de tu base de datos, ejecutar consultas SQL y eliminar los índices no utilizados.

Si tu sitio no se carga por alguna razón, puedes comprobar los registros generados por Docker.

Para ello, cierra primero tus contenedores.

$ docker-compose down

Ejecuta Docker compose en un estado adjunto para que puedas ver los registros generados por cada contenedor.

$ docker-compose up

Paso 10 Actualizar tu Mastodonte

Cambia a tu directorio Mastodon.

$ cd /home/user/mastdon

Descarga las actualizaciones del repositorio

$ git fetch

Si has cambiado tu archivo docker-compose.yml por alguna razón, tienes que ejecutar primero el siguiente comando.

$ git status

Esto te dirá todos los cambios realizados en él. Si el archivo ha sido modificado, entonces guarda tus cambios primero.

$ git stash

Comprueba la última versión de Mastodon. Comprueba la última versión en la página de versiones.

$ git checkout <version/tag>

Si has ejecutado git stash antes, entonces ejecuta el siguiente comando para rehacer tus cambios en el archivo docker-compose.yml.

$ git stash pop

Construye la imagen docker.

$ docker-compose build

Realiza las migraciones de la base de datos.

$ docker-compose run --rm web rails db:migrate

Precompila los activos de Mastodon.

$ docker-compose run --rm web rails assets:precompile

Ejecuta el siguiente comando para ejecutar el contenedor.

$ docker-compose up -d

Eso es todo para este tutorial. Para saber más sobre Mastodon sigue su documentación.

También te podría gustar...