Installieren von Mastodon auf Ubuntu 18.04 LTS

  • BETA
  • Webservice
  • Dezentral

Hinweis! Diese Anleitung ist noch in der BETA. Es können noch Fehler enthalten sein oder sie ist an einigen Stellen unvollständig. Du kannst gerne mithelfen und uns schreiben sollte dir etwas auffallen! hi@freifunk-minden.de

Mastodon ist ein Dezentraler Mikroblogging-Dienst. Mit dieser Anleitung kannst du Mastodon auf Ubuntu 18.04 LTS installieren. Wir haben als Vorlage diese Anleitung verwendet, aber erweitert und zusätzliche Erklärungen hinzugefügt.

Abschnitte die nicht unbedingt notwendig sind haben wir mit "optional" gekennzeichnet. Diese dienen entweder zur Optimierung oder aber sind zusätzliche Sicherheitseinstellungen.

Du solltest Root-Zugriff auf dem Server haben um die Installation durchführen zu können.

Curl

Installiere als erstes Curl, das wird unter anderem benötigt um Node.js und Yarn zu installieren.

apt install -y curl

Node.js

Wenn du Ubuntu 18.04 LTS - Minimal nutzt musst du noch gnupg2 installieren,

apt-get install -y gnupg2

Ansonsten kannst mit der Installation von Node.js - Version 8 fortfahren,

curl -sL https://deb.nodesource.com/setup_8.x | sudo -E bash -
apt-get update
apt-get install -y nodejs

Yarn

Yarn ist ein Paketmanager für Node.js, er wird benötigt um alle benötigten Pakete herunterzuladen, sowie JS und CSS Dateien zusammenzuführen.

curl -sS https://dl.yarnpkg.com/debian/pubkey.gpg | apt-key add -
echo "deb https://dl.yarnpkg.com/debian/ stable main" | tee /etc/apt/sources.list.d/yarn.list
apt-get update
apt-get install -y yarn

Pakete for Mastodon

Jetzt werden alle Pakete installiert die für Mastodon benötigt werden,

apt install -y \
  imagemagick ffmpeg libpq-dev libxml2-dev libxslt1-dev file git-core \
  g++ libprotobuf-dev protobuf-compiler pkg-config nodejs gcc autoconf \
  bison build-essential libssl-dev libyaml-dev libreadline6-dev \
  zlib1g-dev libncurses5-dev libffi-dev libgdbm5 libgdbm-dev \
  redis-server redis-tools postgresql postgresql-contrib \
  certbot libidn11-dev libicu-dev libjemalloc-dev

Redis Konfigurieren (Optional)

Bei der Installation von Redis wird kein Password gesetzt. Außerdem kann es sein das sie von außen erreichbar ist, was du unbedingt überprüfen solltest. Öffne zunächst die Konfiguration-Datei,

nano /etc/redis/redis.conf

Suche den Absatz "Security" und entferne die Kommentierung (#) und gib ein Passwort ein,

requirepass <password>

Als nächstes solltest du "bind" finden, wenn du diese Zeile so vorfindest, dann ist alles richtig, und die Redis ist nicht von außen erreichbar.

bind 127.0.0.1 ::1

Speichere deine Änderungen (strg-x) und starte die Redis neu,

service redis restart

PostgreSQL Konfiguration (Optional)

Damit die PostgreSQL etwas besser läuft kannst du auf https://pgtune.leopard.in.ua/#/ die Daten deines Servers eingeben um eine Optimierte Konfiguration zu erhalten. Dazu kopiere das Ergebnis in deine Konfiguration,

nano /etc/postgresql/10/main/postgresql.conf

Damit die Passwörter für die Datenbanknutzer gesichert sind, wird am Ende der Konfiguration noch diese Zeile hinzugefügt,

password_encryption = 'scram-sha-256'

Speichere deine Änderungen (strg-x) und starte die PostgreSQL neu,

service postgresql restart

Melde dich jetzt als "postgres"-Benutzer an und setzte das Passwort für diesen Benutzer,

sudo -i -u postgres psql
postgres=#\password postgres

Jetzt kannst du einen Benutzer für Mastodon erstellen und mit einem Passwort sichern. Damit Mastodon bei der Installation auch die Datenbank erstellen kann, benötigt der Benutzer Mastodon auch die Rechte um eine eigene Datenbank zu erstellen. Ersetze \ mit deinem eigenen.

postgres=# CREATE USER mastodon WITH PASSWORD '<password>';
postgres=# ALTER USER mastodon CREATEDB;
postgres=# \q

Öffne die Konfiguration für die Authentifizierung,

nano /etc/postgresql/10/main/pg_hba.conf

Ändere die Konfiguration entsprechend, damit überall "scram-sha-256" steht, damit erzwingt PostgreSQL das der Zugriff auf die Datenbank nur über Verschlüsselte Passwörter erfolgen kann.

local   all             postgres                                scram-sha-256
# "local" is for Unix domain socket connections only
local   all             all                                     scram-sha-256
# IPv4 local connections:
host    all             all             127.0.0.1/32            scram-sha-256
# IPv6 local connections:
host    all             all             ::1/128                 scram-sha-256
# Allow replication connections from localhost, by a user with the
# replication privilege.
local   replication     all                                     scram-sha-256
host    replication     all             127.0.0.1/32            scram-sha-256
host    replication     all             ::1/128                 scram-sha-256

Speichere deine Änderungen (strg-x) und starte die PostgreSQL neu,

service postgresql restart

Mastodon

Nun wird die Software für Mastodon installiert. Dazu wird ein Benutzerkonto für Mastodon erstellt, dieser benötigt keinen eigenen Login.

adduser --disabled-login mastodon

Jetzt wechsel zu dem Mastodon-Benutzer und installiere einige Pakete,

su mastodon
cd ~/
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
cd ~/.rbenv && src/configure && make -C src
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec bash
git clone https://github.com/rbenv/ruby-build.git ~/.rbenv/plugins/ruby-build
RUBY_CONFIGURE_OPTS=--with-jemalloc rbenv install 2.6.1
rbenv global 2.6.1

Jetzt wird gem Aktualisiert und der "bundler" installiert.

gem update --system
gem install bundler --no-document

Mastodon wird von Github heruntergeladen und die neueste Version wird eingestellt,

git clone https://github.com/tootsuite/mastodon.git live && cd live
git checkout $(git tag -l | grep -v 'rc[0-9]*$' | sort -V | tail -n 1)

Die nötigen Pakete für gem und yarn werden installiert,

bundle install \
  -j$(getconf _NPROCESSORS_ONLN) \
  --deployment --without development test
yarn install --pure-lockfile

Jetzt wird der Installation-Script gestartet, dabei werden folgendene Daten abgefragt, sowie verschiedene Fragen gestellt,

  • Domain name
  • Do you want to enable single user mode?
  • Are you using Docker to run Mastodon?
  • PostgreSQL host
  • PostgreSQL port
  • Name of PostgreSQL database
  • Name of PostgreSQL user
  • Password of PostgreSQL user
  • Redis host
  • Redis port
  • Redis password
  • Do you want to store uploaded files on the cloud?
  • Do you want to send e-mails from localhost?
  • Prepare the database now?
  • Compile the assets now?
  • Do you want to create an admin user straight away?
RAILS_ENV=production bundle exec rake mastodon:setup

Jetzt wieder auf den Root-Benutzer wechseln,

exit

Nginx

Jetzt wird der Webserver installiert, wir verwenden dafür Nginx, dieser ist eher schlicht was seine Konfiguration angeht und ist auch Leistungsfähiger als Apache2.

apt install -y nginx

Kopiere jetzt die Konfiguration für Mastodon,

cp /home/mastodon/live/dist/nginx.conf /etc/nginx/sites-available/mastodon.conf
ln -s /etc/nginx/sites-available/mastodon.conf /etc/nginx/sites-enabled/mastodon.conf

Anschließend ersetzt du "example.com" in der Konfiguration mit deiner Domain,

nano /etc/nginx/sites-available/mastodon.conf

Speichere deine Änderungen (strg-x) und starte den Nginx neu,

service nginx restart

Damit Mastodon mit SSL Verschlüsselt wird, werden jetzt über Let's Encrypt ein Zertifikate angefordert, auch hier trage statt "example.com" deine Domain ein,

certbot certonly --webroot -d example.com -w /home/mastodon/live/public/

Wenn du das Zertifikat erstellt wurde musst du nun ein weiteres mal deine Konfiguration anpassen und die Kommentierungen (#) entfernen, sowie "example.com" wieder mit deiner Domain ersetzten,

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

Speichere deine Änderungen (strg-x) und starte den Nginx neu,

service nginx restart

Konfiguration (optional)

In der Standard-Konfiguration ist der Nginx zwar schon schnell, aber es ist möglich die Geschwindigkeit und die Sicherheit zu erhöhen.

Überprüfe wieviel Prozessoren verfübar sind, sowie wieviel Connections möglich sind und notiere jeweils die Werte,

grep ^processor /proc/cpuinfo | wc -l
ulimit -n

Öffne die Konfiguration,

nano /etc/nginx/nginx.conf

Trage die Anzahl der Prozessoren in die Konfiguration,

worker_processes <processes>;

Und die Connections ein,

events {
    worker_connections <connections>;

    # scalable I/O event notification mechanism to trigger on events
    use epoll;
    multi_accept on;
}

Für weitere Optimierungen ersetze einfach "http" mit der folgenden Konfiguration,

http {

    ##
    # Basic Settings
    ##

    # security: don't show others which version of nginx is used
    server_tokens off;

    # error log will be only write from warn-level
    error_log  /var/log/nginx.error_log warn;
    access_log off;

    # no logging for 2XX und 3XX
    map $status $loggable {
        ~^[23]  0;
        default 1;
    }

    # caching
    # optimizes serving static files from the file system
    sendfile on;

    # assets file, 1000 files for 30 seconds
    open_file_cache max=1000 inactive=20s;
    open_file_cache_valid 30s;
    open_file_cache_min_uses 5;
    open_file_cache_errors off;

    #buffer
    client_body_buffer_size 128k;
    client_max_body_size 10m;
    client_header_buffer_size 1k;

    large_client_header_buffers 4 4k;

    output_buffers 1 32k;
    postpone_output 1460;

    client_header_timeout 3m;
    client_body_timeout 3m;
    send_timeout 3m;

    include /etc/nginx/mime.types;
    default_type application/octet-stream;

    ##
    # Gzip Settings
    ##

    gzip on;

    ##
    # Virtual Host Configs
    ##

    include /etc/nginx/conf.d/*.conf;
    include /etc/nginx/sites-enabled/*;
}

Speichere deine Änderungen (strg-x) und starte den Nginx neu,

service nginx restart

ufw (Optional)

Ufw ist die Standard Firewall die mit Ubuntu ausgeliefert wird. Du kannst damit die Zugriffe auf deinen Server minimieren. Mit den folgenden Befehlen werden nur die Ports für SSH sowie den Nginx geöffnet und die Ufw gestartet,

ufw allow ssh
ufw allow "Nginx Full"
service ufw start

fail2ban (Optional)

Fail2Ban kann dafür genutzt werden um Angriffe auf den Server zu erschweren. Es versucht anhand von Regeln ein bestimmtes Verhalten in den Log-Files zu erkennen. Wird eine Regel dabei ausgelöst, sperrt fail2ban die betreffende IP für einen bestimmten Zeitraum.

Fail2Ban kann auch mit anderen Firewalls betrieben werden, wir benutzen allerdings Ufw.

apt install -y fail2ban
nano /etc/fail2ban/jail.local
[default]

# "ignoreip" can be an IP address, a CIDR mask or a DNS host. Fail2ban will not
# ban a host which matches an address in this list. Several addresses can be
# defined using space separator.
ignoreip = 127.0.0.1/8

# "bantime" is the number of seconds that a host is banned.
bantime = 3600
banaction = ufw

# The length of time between login attempts before a ban is set.
findtime = 600
maxretry = 5

[sshd]
enabled  = true
port     = ssh
filter   = sshd
logpath  = /var/log/auth-fail2ban.log

[sshd-ddos]
enabled  = true
port     = ssh
filter   = sshd-dos
logpath  = /var/log/auth-fail2ban.log

[nginx-http-auth]
enabled  = true
filter   = nginx-http-auth
port     = http,https
logpath  = /var/log/nginx/nginx-fail2ban.log

[nginx-badbots]
enabled  = true
port     = http,https
filter   = nginx-badbots
logpath  = /var/log/nginx/nginx-fail2ban.log
maxretry = 2
service fail2ban start

Fast geschafft

Jetzt werden nur noch die Dateien für systemd kopieren und anschließend der Service gestartet,

cp /home/mastodon/live/dist/mastodon-\*.service /etc/systemd/system/
systemctl start mastodon-web mastodon-sidekiq mastodon-streaming
systemctl enable mastodon-web mastodon-sidekiq mastodon-streaming

Wenn du Fragen hast, etwas nicht ging oder du findest die Anleitung könnte noch verbessert werden, dann schreib uns einfach! hi@freifunk-minden.de