Cómo instalar Mastodon Social Network con Docker en Ubuntu 18.04 LTS

Mastodon es una red social gratuita, descentralizada y de código abierto. Fue creado como una alternativa a Twitter. Al igual que en Twitter, las personas pueden seguirse, publicar mensajes, imágenes y videos. Pero a diferencia de Twitter, no existe una tienda central o autoridad para el contenido.

En cambio, Mastodon opera a través de miles de servidores diferentes, cada uno de los cuales ejecuta varios miembros de la comunidad. Los usuarios registrados 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 le enseñará cómo configurar su instancia de Mastodon en un servidor con Ubuntu 18.04 usando Docker.

Requisitos

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

• Asegúrese de que su 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 su propio servidor de correo. Puede hacerlo en el mismo servidor en el que instalará mastodon o en un servidor diferente. Hacerlo está fuera del alcance de esta guía.

  Le recomendaremos que utilice un servicio de correo transaccional de terceros como Mailgun, Sendgrid, Amazon SES o Sparkpost. Las instrucciones en la guía usarán Mailgun como su proveedor de SMTP.

• Asegúrese de tener un nombre de dominio que apunte al servidor. Para este tutorial, utilizaremos example.com como dominio.

Paso 1:instalación de dependencias

Antes de instalar Mastodon, debemos asegurarnos de que nuestro servidor tenga cierto software que deberá instalarse correctamente. Ejecute 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

Parte del software anterior puede estar preinstalado para usted.

Ya que instalamos Git, debemos configurarlo antes de continuar.

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

Paso 2:configuración del cortafuegos

En nuestro paso anterior, instalamos, ufw (cortafuegos sin complicaciones) . Antes de que podamos proceder a instalar Mastodon, debemos configurarlo.

Habilite SSH y el puerto que acabamos de crear para que no nos bloqueen.

$ sudo ufw allow OpenSSH

Habilite el cortafuegos ufw.

$ sudo ufw enable

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

$ sudo ufw allow http
$ sudo ufw allow https

Compruebe el estado del cortafuegos.

$ sudo ufw status

Debería ver un resultado como el 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

Agregue la clave GPG de Docker a su sistema.

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

Verifique la huella digital de la clave descargada.

$ sudo apt-key fingerprint 0EBFCD88

Debería ver un resultado como el 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]

Agregue el repositorio de Docker.

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

Actualice su base de datos de paquetes.

$ sudo apt update

Instale 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

El resultado debe ser similar al 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

Presiona q para salir.

Agregue su cuenta de usuario limitada de Linux al grupo docker para que pueda ejecutar docker sin sudo.

sudo usermod -aG docker $USER

$USUARIO La variable seleccionará y agregará el usuario que ha iniciado sesión actualmente al grupo de Docker. Reemplazar $USUARIO con el nombre de usuario real si actualmente no ha iniciado sesión con ese usuario.

Cambia al usuario que acabamos de agregar. Aunque ya haya iniciado sesión, deberá volver a cambiar a él para volver a cargar los permisos.

$ su - ${USER}

Compruebe que todo funciona bien ejecutando el "Hello World" integrado programa.

$ docker run hello-world

Debería ver el siguiente resultado que indicará que Docker está instalado y funcionando 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 omitir este paso y continuar, pero tener Docker Compose instalado hará que ejecutar Mastodon sea mucho más fácil, especialmente si desea 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

Al momento de escribir este tutorial, 1.24.1 es la versión estable actual de Docker Compose. Puede verificar la última versión de lanzamiento desde su página de Github.

Aplique permisos ejecutables al archivo binario de composición de docker.

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

Agregar finalización de comando 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

Verifique si su instalación fue exitosa.

$ docker-compose --version

Imprimirá el siguiente resultado.

docker-compose version 1.24.1, build 4667896b

Paso 5 - Instalar Mastodon

Clone el repositorio de Mastodon en su servidor.

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

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

$ cd mastodon

Mastodon viene con un archivo de configuración de muestra. Necesitamos cambiarle el nombre para que Mastodon funcione.

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

Necesitamos generar claves secretas para nuestro archivo de configuración. Pero antes de eso, necesitamos construir la imagen de Docker.

$ docker-compose build

Ahora que la imagen se ha creado correctamente, debe crear varias claves necesarias para configurar Mastodon.

Genera SECRET_KEY_BASE primero.

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

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

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

Genere e inserte el 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

Genere e inserte el PAPERCLIP_SECRET en el archivo de configuración.

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

Generar valores para VAPID_PRIVATE_KEY y VAPID_PUBLIC_KEY .

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

Abra .env.production archivo.

$ sudo nano ./.env.production

Buscar VAPID_PRIVATE_KEY y VAPID_PUBLIC_KEY en el archivo y copie el resultado del comando anterior.

Encuentra el LOCAL_DOMAIN variable y cambie su valor de example.com al nombre de dominio que ha elegido para su instalación de Mastodon.

Introduzca los valores que obtuvo de su proveedor de SMTP.

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

Presiona Ctrl + X y guarde el archivo cuando haya terminado.

Debe volver a crear la imagen de Docker para implementar todos los cambios realizados anteriormente.

$ docker-compose build

Configure la base de datos.

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

Precompila los recursos de Mastodon.

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

Ejecute el siguiente comando para ejecutar el contenedor.

$ docker-compose up -d

Paso 6:instalar y configurar Nginx

El siguiente paso en nuestra guía es instalar el servidor Nginx para que el sitio web de Mastodon funcione.

Ejecute el siguiente comando para instalar el servidor Nginx.

$ sudo apt install nginx -y

Nginx viene con un sitio predeterminado configurado. Elimina eso.

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

Además, elimine el enlace simbólico del sitio predeterminado.

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

Cree 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

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

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

Copie y pegue 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á utilizando Let's encrypt como su proveedor de SSL. Si está utilizando otro servicio SSL, debe editar la ubicación de las claves y omitir la siguiente sección del tutorial.

Paso 7:instalar y configurar Let's Encrypt

Asegúrese de que Nginx esté detenido.

$ sudo systemctl stop nginx

Agregue el repositorio de Certbot.

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

Actualizar paquetes del sistema.

$ sudo apt update

Instale la herramienta Certbot.

$ sudo apt install certbot

Debe 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, cree el certificado utilizando el método webroot. Esto necesitará que Nginx se esté ejecutando.

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

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

Configurar la renovación automática de certificados SSL

Los certificados de Let's Encrypt tienen una validez de 90 días. Después de eso, debe renovarlos nuevamente. Para eso, puede crear un trabajo cron para que lo haga automáticamente por usted.

Cree un trabajo cron.

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

Copie y pegue lo siguiente en el archivo.

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

Guarde y salga del archivo presionando Ctrl + X e ingresando Y cuando se le solicite.

Haga que el script sea ejecutable y reinicie el demonio cron para que nuestro script se ejecute a diario.

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

Paso 8:crea tu usuario Mastodon

Visite su sitio de mastodonte en un navegador. Debería ver la siguiente pantalla.

Ingrese su nombre de usuario, dirección de correo electrónico y contraseña deseados para crear una nueva cuenta en su instancia de Mastodon. Su nombre de usuario completo que necesitará para conectarse a usuarios de otros servidores de Mastodon es howtoforge@example.com.

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

También puede confirmar manualmente el registro. Para eso, necesitará SSH en su instancia de Docker. Enumere todas las instancias actuales de Docker.

$ docker ps

Verá una salida como la 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, debemos acceder al contenedor de transmisión. SSH en mastodon_streaming_1 contenedor.

$ docker exec -it mastodon_streaming_1 /bin/bash

Esto lanzará un shell Bash dentro de su contenedor.

Ejecute el siguiente comando para aprobar su nombre de usuario recién creado.

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

Ejecute el siguiente comando para convertir su cuenta recién creada en administrador.

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

Salga del contenedor.

[email protected]:~$ exit

Inicie sesión en su instancia con su nombre de usuario y contraseña y aparecerá la siguiente pantalla.

Haz clic en Vamos y pasará a las siguientes páginas que le permitirán conocer algunos conceptos básicos de cómo funciona Mastodon.

Haga clic en Finalizar tutorial para ser recibido con la página de inicio de Mastodon, donde puede comenzar a publicar lo que desee.

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

Paso 9 - Mantenimiento

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

Aquí puede ver una lista de varios procesos y tareas programadas relacionadas con su instancia de Mastodon. También puede buscar tareas fallidas en la sección Dead or Retries. También le indicará el uso de memoria de su instancia.

Puede verificar el estado de la base de datos de su instancia desde https://example.com/pghero/

Puede realizar el mantenimiento de su base de datos, ejecutar consultas SQL y eliminar índices no utilizados.

Si su sitio no se carga en absoluto por algún motivo, puede consultar los registros generados por Docker.

Para eso, primero cierra tus contenedores.

$ docker-compose down

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

$ docker-compose up

Paso 10 Actualización de su mastodonte

Cambia a tu directorio de mastodontes.

$ cd /home/user/mastdon

Descargar actualizaciones del repositorio

$ git fetch

Si ha cambiado su docker-compose.yml archivo por alguna razón, primero debe ejecutar el siguiente comando.

$ git status

Esto le dirá todos los cambios realizados en él. Si se modifica el archivo, primero guarde los cambios.

$ git stash

Echa un vistazo a la última versión de Mastodon. Consulte la última versión en la página de lanzamientos.

$ git checkout <version/tag>

Si ejecutó git stash anteriormente, ejecute el siguiente comando para rehacer los cambios en docker-compose.yml archivo.

$ git stash pop

Cree la imagen de la ventana acoplable.

$ docker-compose build

Realizar migraciones de bases de datos.

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

Precompila los recursos de Mastodon.

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

Ejecute el siguiente comando para ejecutar el contenedor.

$ docker-compose up -d

Eso es todo por este tutorial. Para obtener más información sobre Mastodon, siga sus documentos.