Come installare Mastodon Social Network con Docker su Ubuntu 18.04 LTS

Mastodon è un social network gratuito, decentralizzato e open source. È stato creato come alternativa a Twitter. Proprio come su Twitter, le persone possono seguirsi, pubblicare messaggi, immagini e video. Ma a differenza di Twitter, non esiste un archivio centrale o un'autorità per i contenuti.

Invece, Mastodon opera su migliaia di server diversi, ciascuno gestito da vari membri della comunità. Gli utenti registrati su un server possono connettersi facilmente agli utenti dell'altra rete e seguirsi a vicenda attraverso le istanze.

Chiunque può installare la propria istanza di un server Mastodon. Questo tutorial ti insegnerà come configurare la tua istanza di Mastodon su un server con Ubuntu 18.04 usando Docker.

Prerequisiti

• Un server basato su Ubuntu 18.04 con un utente sudo non root.

• Assicurati che il tuo sistema sia aggiornato.

  $ sudo apt update
  $ sudo apt upgrade
  

• Mastodon invia notifiche e-mail agli utenti. Un'opzione per farlo funzionare è configurare il proprio server di posta. Puoi farlo sullo stesso server in cui installerai mastodon o su un server diverso. Farlo esula dagli scopi di questa guida.

  Ti consigliamo di utilizzare un servizio di posta transazionale di terze parti come Mailgun, Sendgrid, Amazon SES o Sparkpost. Le istruzioni nella guida utilizzeranno Mailgun come provider SMTP.

• Assicurati di avere un nome di dominio che punta al server. Per questo tutorial, utilizzeremo example.com come dominio.

Passaggio 1:installazione delle dipendenze

Prima di installare Mastodon, dobbiamo assicurarci che il nostro server disponga di determinati software che dovranno essere installati correttamente. Esegui i seguenti comandi per installare le dipendenze.

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

Alcuni dei software sopra indicati potrebbero essere preinstallati per te.

Poiché abbiamo installato Git, dovremmo configurarlo prima di procedere.

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

Passaggio 2:configurazione del firewall

Nel passaggio precedente, abbiamo installato ufw (Uncomplicated Firewall) . Prima di poter procedere con l'installazione di Mastodon, dobbiamo configurarlo.

Abilita SSH e la porta che abbiamo appena creato in modo da non essere bloccati.

$ sudo ufw allow OpenSSH

Abilita il firewall ufw.

$ sudo ufw enable

Dobbiamo anche abilitare http e https per il funzionamento di Mastodon.

$ sudo ufw allow http
$ sudo ufw allow https

Controlla lo stato del firewall.

$ sudo ufw status

Dovresti vedere un output come il seguente.

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)             

Passaggio 3:installa Docker

Aggiungi la chiave GPG di Docker al tuo sistema.

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

Verifica l'impronta digitale della chiave scaricata.

$ sudo apt-key fingerprint 0EBFCD88

Dovresti vedere un output come il seguente.

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]

Aggiungi il repository Docker.

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

Aggiorna il database dei tuoi pacchetti.

$ sudo apt update

Installa Docker-CE. CE è la Community Edition di Docker.

$ sudo apt install docker-ce -y

Docker dovrebbe essere installato ora. Verifica che sia in esecuzione.

$ sudo systemctl status docker

L'output dovrebbe essere simile al seguente.

? 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

Premi q per uscire.

Aggiungi il tuo account utente Linux limitato al gruppo docker in modo da poter eseguire docker senza sudo.

sudo usermod -aG docker $USER

$UTENTE La variabile selezionerà e aggiungerà l'utente attualmente connesso al gruppo Docker. Sostituisci $USER con il nome utente effettivo se non sei attualmente connesso con quell'utente.

Passa all'utente che abbiamo appena aggiunto. Anche se avevi già effettuato l'accesso, dovrai comunque riattivarlo per ricaricare le autorizzazioni.

$ su - ${USER}

Verifica che tutto funzioni correttamente eseguendo il "Hello World" integrato programma.

$ docker run hello-world

Dovresti vedere il seguente output che dirà che Docker è installato e funziona correttamente.

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.

Passaggio 4 - Installa Docker Compose

È possibile saltare questo passaggio e procedere, ma l'installazione di Docker Compose renderà l'esecuzione di Mastodon molto più semplice, soprattutto se si desidera farlo su più di un server.

$ 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 della stesura di questo tutorial, 1.24.1 è l'attuale versione stabile di Docker Compose. Puoi controllare l'ultima versione di rilascio dalla loro pagina Github.

Applica le autorizzazioni eseguibili alla finestra mobile per comporre il binario.

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

Aggiungi il completamento del 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

Verifica se l'installazione è andata a buon fine.

$ docker-compose --version

Stamperà il seguente output.

docker-compose version 1.24.1, build 4667896b

Passaggio 5 - Installa Mastodon

Clona il repository di Mastodon sul tuo server.

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

Passa alla directory in cui abbiamo appena copiato i file.

$ cd mastodon

Mastodon viene fornito con un file di configurazione di esempio. Dobbiamo rinominarlo per far funzionare Mastodon.

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

Dobbiamo generare chiavi segrete per il nostro file di configurazione. Ma prima dobbiamo creare l'immagine Docker.

$ docker-compose build

Ora che l'immagine è stata creata correttamente, devi creare diverse chiavi necessarie per configurare Mastodon.

Genera SECRET_KEY_BASE prima.

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

Inserisci la chiave sopra nel file di configurazione.

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

Genera e inserisci OTP_SECRET nel file di configurazione.

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

Genera e inserisci il PAPERCLIP_SECRET nel file di configurazione.

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

Genera valori per VAPID_PRIVATE_KEY e VAPID_PUBLIC_KEY .

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

Apri .env.production file.

$ sudo nano ./.env.production

Cerca VAPID_PRIVATE_KEY e VAPID_PUBLIC_KEY nel file e copia l'output del comando precedente.

Trova il LOCAL_DOMAIN variabile e modificarne il valore da example.com al nome di dominio che hai scelto per la tua installazione di Mastodon.

Inserisci i valori che hai ricevuto dal tuo provider SMTP.

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

Premi Ctrl + X e salva il file quando hai finito.

Devi creare nuovamente l'immagine Docker per implementare tutte le modifiche apportate sopra.

$ docker-compose build

Configura il database.

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

Precompila gli asset di Mastodon.

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

Esegui il comando seguente per eseguire il contenitore.

$ docker-compose up -d

Fase 6 - Installa e configura Nginx

Il prossimo passo nella nostra guida è installare il server Nginx per far funzionare il sito web di Mastodon.

Esegui il comando seguente per installare il server Nginx.

$ sudo apt install nginx -y

Nginx viene fornito con un sito predefinito configurato. Rimuovilo.

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

Inoltre, rimuovi il collegamento simbolico per il sito predefinito.

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

Crea un file di configurazione Nginx per Mastodon.

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

Crea un collegamento simbolico per la configurazione di Mastodon.

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

Apri la configurazione di Mastodon nell'editor Nano. (Puoi scegliere qualsiasi editor desideri)

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

Copia e incolla il seguente testo al suo interno.

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 configurazione sopra presuppone che tu stia utilizzando Let's encrypt come tuo provider SSL. Se stai utilizzando un altro servizio SSL, devi modificare la posizione delle chiavi e saltare la sezione successiva del tutorial.

Passaggio 7 - Installa e configura Let's Encrypt

Assicurati che Nginx sia fermo.

$ sudo systemctl stop nginx

Aggiungi repository Certbot.

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

Aggiorna i pacchetti di sistema.

$ sudo apt update

Installa lo strumento Certbot.

$ sudo apt install certbot

È necessario creare il certificato due volte, una con il metodo TLS SNI e la seconda utilizzando il metodo webroot.

sudo certbot certonly --standalone -d example.com

Ora crea il certificato usando il metodo webroot. Questo richiederà Nginx per essere in esecuzione.

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

Lo strumento ti chiederà se desideri conservare il certificato o rinnovarlo. Scegli l'opzione per rinnovare.

Impostazione del rinnovo automatico dei certificati SSL

I certificati Let's Encrypt hanno una validità di 90 giorni. Successivamente, è necessario rinnovarli di nuovo. Per questo, puoi creare un cron job per farlo automaticamente per te.

Crea un lavoro cron.

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

Copia e incolla quanto segue nel file.

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

Salva ed esci dal file premendo Ctrl + X e inserendo Y quando richiesto.

Rendi lo script eseguibile e riavvia il demone cron in modo che il nostro script venga eseguito quotidianamente.

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

Fase 8:crea il tuo utente Mastodon

Visita il tuo sito di mastodonte in un browser. Dovresti vedere la seguente schermata.

Inserisci il nome utente, l'indirizzo e-mail e la password desiderati per creare un nuovo account sulla tua istanza Mastodon. Il tuo nome utente completo di cui avrai bisogno per connetterti agli utenti di altri server Mastodon è howtoforge@example.com.

Mastodon ti invierà una mail di conferma per verificare l'iscrizione.

Puoi anche confermare manualmente la registrazione. Per questo, dovrai eseguire SSH nella tua istanza Docker. Elenca tutte le istanze Docker correnti.

$ docker ps

Vedrai un output come di seguito.

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

Per apportare le modifiche richieste, dobbiamo accedere al contenitore di streaming. SSH nel mastodon_streaming_1 contenitore.

$ docker exec -it mastodon_streaming_1 /bin/bash

Questo avvierà una shell Bash all'interno del tuo contenitore.

Esegui il comando seguente per approvare il nome utente appena creato.

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

Esegui il comando seguente per rendere il tuo account appena creato un amministratore.

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

Esci dal contenitore.

[email protected]:~$ exit

Accedi alla tua istanza con il tuo nome utente e password e sarai accolto con la seguente schermata.

Fai clic su Andiamo e passerai alle pagine seguenti che ti faranno conoscere alcune nozioni di base su come funziona Mastodon.

Fai clic su Termina tutorial per essere accolto con la home page del tuo Mastodon dove puoi iniziare a postare a tuo piacimento.

Puoi accedere alle impostazioni e all'area di amministrazione dal menu Preferenze.

Fase 9 - Manutenzione

Per visualizzare le prestazioni e i registri della tua istanza Mastodon, vai su https://example.com/sidekiq/

Qui puoi visualizzare un elenco di vari processi e attività pianificate relative alla tua istanza Mastodon. Puoi anche verificare la presenza di attività non riuscite nella sezione Dead or Retries. Ti dirà anche l'utilizzo della memoria della tua istanza.

Puoi controllare lo stato del database della tua istanza da https://example.com/pghero/

Puoi eseguire la manutenzione del tuo database, eseguire query SQL e rimuovere gli indici inutilizzati.

Se il tuo sito non si carica per qualche motivo, puoi controllare i log generati da Docker.

Per questo, chiudi prima i contenitori.

$ docker-compose down

Esegui Docker compose in uno stato allegato in modo da poter visualizzare i log generati da ciascun contenitore.

$ docker-compose up

Fase 10:potenziare il tuo mastodonte

Passa alla directory del mastodonte.

$ cd /home/user/mastdon

Scarica gli aggiornamenti dal repository

$ git fetch

Se hai modificato il tuo docker-compose.yml file per qualche motivo, devi prima eseguire il comando seguente.

$ git status

Questo ti dirà tutte le modifiche apportate. Se il file viene modificato, salva prima le modifiche.

$ git stash

Scopri l'ultima versione di Mastodon. Controlla l'ultima versione dalla pagina delle versioni.

$ git checkout <version/tag>

Se hai eseguito git stash in precedenza, esegui il comando seguente per ripetere le modifiche a docker-compose.yml file.

$ git stash pop

Costruisci l'immagine della finestra mobile.

$ docker-compose build

Esegui migrazioni del database.

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

Precompila gli asset di Mastodon.

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

Esegui il comando seguente per eseguire il contenitore.

$ docker-compose up -d

Questo è tutto per questo tutorial. Per saperne di più su Mastodon segui i loro documenti.