By lars in docker — 16. Nov. 2021

Mastodon via Docker richtig installieren

Update: 8.12.2022 Nginx Config erneuert. 14.3.23: typos entfernt

Mastodon ist ein kostenloses, dezentrales und quelloffenes soziales Netzwerk. Es wurde als Alternative zu Twitter erstellt. Genau wie bei Twitter können Menschen einander folgen, Nachrichten, Bilder und Videos posten. Im Gegensatz zu Twitter gibt es jedoch keinen zentralen Speicher oder eine zentrale Autorität für die Inhalte.

Stattdessen arbeitet Mastodon über Tausende von verschiedenen Servern, auf denen jeweils verschiedene Mitglieder der Community laufen. Benutzer, die sich auf einem Server angemeldet haben, können sich problemlos mit Benutzern im anderen Netzwerk verbinden und einander über Instanzen hinweg folgen.

Jeder kann seine eigene Instanz eines Mastodon-Servers installieren. In diesem Tutorial erfahren Sie, wie Sie Ihre Mastodon-Instanz auf einem Server mit Ubuntu 20.04 bzw. Debian 11 mit Docker einrichten.

Was wird vorab benötigt?

Ein Ubuntu oder Debian Server mit einem Nicht-Root-Sudo-Benutzer. Die Installation mit anderen Systemen könnte abweichen.

Stellen Sie sicher, dass Ihr System auf dem neuesten Stand ist.

sudo apt update && sudo apt upgrade

Mastodon sendet E-Mail-Benachrichtigungen an Benutzer. Eine Möglichkeit, damit es funktioniert, besteht darin, einen eigenen Mailserver einzurichten. Sie können dies auf demselben Server tun, auf dem Sie Mastodon installieren, oder auf einem anderen Server. Dies zu tun ist nicht Gegenstand dieser Anleitung.

Wir empfehlen Ihnen, einen Transaktions-Mail-Dienst eines Drittanbieters wie Mailgun, Sendgrid, Amazon SES oder Sparkpost zu verwenden. Die Anweisungen in der Anleitung verwenden Mailgun als Ihren SMTP-Anbieter.

Stellen Sie sicher, dass Sie einen Domänennamen haben, der auf den Server verweist. Für dieses Tutorial verwenden wir example.com als Domäne.

Bevor wir Mastodon installieren, müssen wir sicherstellen, dass unser Server über eine bestimmte Software verfügt, die er ordnungsgemäß installieren muss. Führen Sie die folgenden Befehle aus, um die Abhängigkeiten zu installieren.

Abhängigkeiten installieren

sudo apt install ca-Zertifikate curl ufw apt-transport-https software-properties-common git -y

Einige der oben genannten Softwares sind möglicherweise für Sie vorinstalliert.

Da wir Git installiert haben, sollten wir es konfigurieren, bevor wir fortfahren. (Optional)

git config --global user.name "Ihr Name"
git config --global user.email "yuremail@domain.com"

Firewall konfigurieren

In unserem vorherigen Schritt haben wir ufw (Uncomplicated Firewall) installiert. Bevor wir mit der Installation von Mastodon fortfahren können, müssen wir es konfigurieren.

Aktivieren Sie SSH und den gerade erstellten Port, damit wir nicht ausgesperrt werden.

sudo ufw allow OpenSSH
sudo ufw allow NGINX FULL

Die Firewall mit den Einstellungen neu laden

sudo ufw reload

Wir müssen auch http und https aktivieren, damit Mastodon funktioniert.

sudo ufw allow http
sudo ufw allow https

Überprüfen Sie den Status der Firewall.

sudo ufw status

Ausgabe:

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)

Docker installieren

Fügen Sie den GPG-Schlüssel von Docker zu Ihrem System hinzu.

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

Überprüfen Sie den Fingerabdruck des heruntergeladenen Schlüssels.

 sudo apt-key fingerprint 0EBFCD88

So, oder so ähnlich sollte die Ausgabe aussehen:

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

Fügen Sie das Docker-Repository hinzu.

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

Aktualisieren Sie Ihre Paketdatenbank.

sudo apt update

Installieren Sie Docker-CE. CE ist die Community Edition des Dockers.

sudo apt install docker-ce -y

Docker sollte jetzt installiert sein. Überprüfen Sie, ob es läuft.

sudo systemctl status docker

Die Ausgabe sollte der folgenden ähneln.

? 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

Drücken Sie zum Beenden q.

Seperaten Nutzer anlegen

sudo usermod -aG docker $USER

Die Variable $USER wählt den aktuell angemeldeten Benutzer aus und fügt ihn der Docker-Gruppe hinzu. Ersetzen Sie $USER durch den tatsächlichen Benutzernamen, wenn Sie derzeit nicht mit diesem Benutzer angemeldet sind.

su mastodon

Fügen Sie Ihr eingeschränktes Linux-Benutzerkonto zur Docker-Gruppe hinzu, damit Sie Docker ohne sudo ausführen können. Für alles andere muss der User per sudo die Befehle ausführen, es sei denn die Benutzerrechte der Dateien liegen auch beim Mastodon Nutzer.

Docker-compose installieren

Es ist möglich, diesen Schritt zu überspringen und fortzufahren, aber die Installation von Docker Compose macht die Ausführung von Mastodon viel einfacher, insbesondere wenn Sie dies auf mehr als einem Server tun möchten.

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

Zum Zeitpunkt der Erstellung dieses Tutorials ist 1.24.1 die aktuelle stabile Version von Docker Compose. Sie können auf der Github-Seite nach der neuesten Version suchen.

Wenden Sie ausführbare Berechtigungen auf die Docker Compose-Binärdatei an.

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

Fügen Sie die Befehlsvervollständigung zu Docker Compose hinzu.

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

Überprüfen Sie, ob Ihre Installation erfolgreich war.

docker-compose --version

docker-compose version 1.24.1, build 4667896b

Mastodon installieren

Das Repository clonen.

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

In das enstandene Verzeichnis wechseln.

cd mastodon

Mastodon wird mit einer Beispielkonfigurationsdatei geliefert. Wir müssen es umbenennen, damit Mastodon funktioniert.

sudo cp .env.production.sample .env.production

Wir müssen geheime Schlüssel für unsere Konfigurationsdatei generieren. Zuvor müssen wir jedoch das Docker-Image erstellen.

docker-compose build

Nachdem das Image erfolgreich erstellt wurde, müssen Sie mehrere Schlüssel erstellen, die zum Konfigurieren von Mastodon erforderlich sind.

Zuerst den SECRET_KEY_BASE generieren.

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

Den obigen Key in die Konfigurationsdatei eintragen.

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

Dann den OTP_SECRET generieren und ebenso eintragen.

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

Nun den PAPERCLIP_SECRET generieren und in die Konfigurationsdatei eintragen.

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

Zum Schluss noch den den VAPID_PRIVATE_KEY und VAPID_PUBLIC_KEY erstellen.

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

Die .env.production Datei öffnen.

Nun nach VAPID_PRIVATE_KEY und VAPID_PUBLIC_KEY und die zuvor generierten Keys eintragen.

In der gleichen Datei den Eintrag LOCAL_DOMAIN suchen und den Eintrag example.com zu der Domain ändern die für Mastodon genutzt werden soll.

Als nächstes die Einstellungen für die SMTP Einstellungen anpassen.

SMTP_SERVER = smtp.mailgun.org
SMTP_PORT = 587
SMTP_LOGIN = username
SMTP_PASSWORD = password
SMTP_FROM_ADDRESS = notifications@example.com

Mit Ctrl + X abspeichern.

Nun muss das Docker image neu erstellen damit alle Änderungen die oben gemacht wurden auch im Container geändert werden.

docker-compose build

Die Datenbank erstellen.

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

Neu kompilieren der Mastodon’s assets.

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

Folgendes Kommando ausführen damit alle Container gestartet werden.

docker-compose up -d

Nginx einrichten

Zuerst wieder zum sudo Nutzer wechseln und dann folgendes installieren.

Dann muss Nginx installiert werden, damit Mastodon auch von außen erreichbar ist.

su  <sudo user>
sudo apt install nginx -y

Nginx kommt mit einer konfigurierten Seite. Diese muss entfernt werden.

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

Und den dazu gehörigen Sym-Link entfernen.

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

Nun die Konfiguration für Mastodon erstellen.

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

Einen Sym-Link erstellen zu sites-available.

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

Nun diese Datei öffnen.

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

Folgendes per Copy Paste einfügen

map $http_upgrade $connection_upgrade {
  default upgrade;
  ''      close;
}
#anonymisieren der Ip  Adressen
map $remote_addr $ip_anonym1 {
 default 0.0.0;
 "~(?P<ip>(\d+)\.(\d+)\.(\d+))\.\d+" $ip;
 "~(?P<ip>[^:]+:[^:]+):" $ip;
}

map $remote_addr $ip_anonym2 {
 default .0;
 "~(?P<ip>(\d+)\.(\d+)\.(\d+))\.\d+" .0;
 "~(?P<ip>[^:]+:[^:]+):" ::;
}

map $ip_anonym1$ip_anonym2 $ip_anonymized {
 default 0.0.0.0;
 "~(?P<ip>.*)" $ip;
}


server {
    if ($host = fulda.social) {
        return 301 https://$host$request_uri;
    } # managed by Certbot
    if ($http_user_agent ~ fedisearch) {
       return 403 'fuck off';
    }

  listen 80;
  listen [::]:80;
  server_name domain.social;
  root /var/www/mastodon;
  # Useful for Let's Encrypt
  location /.well-known/acme-challenge/ { allow all; }
  location / { return 301 https://$host$request_uri; }
}
proxy_cache_path /var/cache/nginx keys_zone=STATIC:10m;
server {
  listen 443 ssl http2;
  listen [::]:443 ssl http2;
  server_name domain.social;

  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/domain.social/fullchain.pem; # managed by Certbot
  ssl_certificate_key /etc/letsencrypt/live/domain.social/privkey.pem; # managed by Certbot

  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 image/svg+xml image/x-icon;

  # security
  access_log off;
  error_log off;
  #include                 nginxconfig.io/security.conf;
  location / {
    try_files $uri @proxy;
  }



  # If Docker is used for deployment and Rails serves static files,
  # then needed must replace line `try_files $uri =404;` with `try_files $uri @proxy;`.


  location = /sw.js {
    add_header Cache-Control "public, max-age=604800, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/assets/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/avatars/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/emoji/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/headers/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/packs/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/shortcuts/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/sounds/ {
    add_header Cache-Control "public, max-age=2419200, must-revalidate";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }

  location ~ ^/system/ {
    add_header Cache-Control "public, max-age=2419200, immutable";
    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";
    try_files $uri @proxy;
  }


  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 $scheme;
    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;

    add_header Strict-Transport-Security "max-age=63072000; includeSubDomains";

    tcp_nodelay on;
  }

 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 $scheme;
    proxy_set_header Proxy "";
    proxy_pass_header Server;

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

    proxy_cache STATIC;
    proxy_cache_valid 200 7d;
    proxy_cache_valid 410 24h;
    proxy_cache_use_stale error timeout updating http_500 http_502 http_503 http_504;
    add_header X-Cached $upstream_cache_status;

    tcp_nodelay on;
  }

}

Die obige Konfiguration geht davon aus, dass Sie Let’s encrypt als SSL-Anbieter verwenden. Wenn Sie einen anderen SSL-Dienst verwenden, müssen Sie die Position der Schlüssel bearbeiten und den nächsten Abschnitt des Tutorials überspringen

Letsencrypt Zertifikat erstellen

Sicherstellen das Nginx nicht läuft.

sudo systemctl stop nginx

Das Certbot repository hinzufügen.

sudo add-apt-repository ppa:certbot/certbot

Update der System Pakete.

sudo apt update

Certbot installieren.

sudo apt install certbot python3-cerbot-nginx

Nun das Zertifikat erstellen.

sudo certbot certonly --nginx -d example.com

automatisches erneuern der Zertifkate einrichten.

Um zu überprüfen, ob das erneuern der Zertfikate wirklich klappt muss folgende Zeile ausgeführt werden.

sudo certbot renew --dry-run

Die Ausgabe sollte so aussehen.

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Processing /etc/letsencrypt/renewal/domain.conf
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Cert not due for renewal, but simulating renewal for dry run
Plugins selected: Authenticator nginx, Installer nginx
Simulating renewal of an existing certificate for pix.fulda.social
Performing the following challenges:
http-01 challenge for domain.com
Waiting for verification...
Cleaning up challenges

- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
new certificate deployed with reload of nginx server; fullchain is
/etc/letsencrypt/live/domain.social/fullchain.pem

nun Nginx starten.

sudo service nginx start

Damit ist die Webseite erreichbar und kann eingerichtet werden.

Zuerst muss ein Konto erstellt werden und im folgenden Schritt muss diesem Adminisrationsrechte erteilt werden.

Danach wieder auf dem Server per SSH einloggen und mit folgenden Befehlen dem zuvor erstellten Nutzer Administrationsrechte gewähren.

Mit diesem Befehl gelangt man in den Container.

docker exec -it mastodon_streaming_1 /bin/bash

Hier nun den User anlegen.

RAILS_ENV=production bin/tootctl accounts modify Benutzername --confirm

RAILS_ENV=production bin/tootctl accounts modify Benutzername --role admin

exit

Erste Schritte mit dem neuen Account

Relays hinzufügen

Nach dem Einloggen werden sie durch ein kleines Tutorial geleitet. Danach kann man direkt mit dem Posten starten.
Ich empfehle folgende Einstellungen zu tätigen.

auf https://domain.com/admin/relays wechseln und dort folgende Relays hinzufügen.

https://relay.masto.tech/inbox
https://relay.chemnitz.social/inbox
https://relay.mas.to/inbox
https://relay.fedinoc.de/inbox
https://relay.libranet.de/inbox

Damit lässt sich der Federation Tab doch direkt besser füllen.

AGB, Datenschutzhinweise hinzufügen

Dies ist in der EU notwendig, wenn eine Registrierung erlaubt sein soll für diese Instanz.

Ebenso wichtig sind die Spielregeln für diesen Server. Hier kann der Administrator festlegen was gepostet werden darf, oder was nicht.

Beides zu finden unter

https://domain.com/admin/settings/edit
https://domain.com/admin/rules

quelle: https://www.howtoforge.com/how-to-install-mastodon-social-network-with-docker-on-ubuntu-1804/

Mastodon Updates installieren

In der Mastodon Directory wechseln.

cd /home/user/mastdon

Die letzten Updates herunterladen.

git fetch

Wenn Sie Ihre docker-compose.yml-Datei aus irgendeinem Grund geändert haben, müssen Sie zuerst den folgenden Befehl ausführen.

git status

Dies zeigt Ihnen alle Änderungen an, die daran vorgenommen wurden. Wenn die Datei geändert wird, speichern Sie zuerst Ihre Änderungen.

git stash

Schauen Sie sich die neueste Mastodon-Version an. Überprüfen Sie die neueste Version von der releases Page.

git checkout <version/tag>

git checkout v4.0.2

Wenn Sie git stash früher ausgeführt haben, führen Sie den folgenden Befehl aus, um Ihre Änderungen an der Datei docker-compose.yml zu wiederholen.

git stash pop

Das Docker Image erstellen.

docker-compose build

Datenbank muss migriert werden. Wenn man das nicht macht bekommt man folgende Warnung in Mastodon

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