Ubuntu 24.04 Server: Anleitung zur Installation von Mastodon

Willkommen zu dieser Anleitung zur Installation und Verwaltung einer Mastodon-Instanz auf Ubuntu 24.04.

Mastodon ist ein freies, quelloffenes soziales Netzwerk, das auf dezentraler Technologie basiert und eine Alternative zu zentralisierten Plattformen wie Twitter oder Facebook bietet.

Als föderiertes Netzwerk ermöglicht Mastodon Benutzern, ihre eigenen Server (Instanzen) zu betreiben, während sie gleichzeitig mit Benutzern auf anderen Instanzen kommunizieren können. Dies fördert die Freiheit der Nutzer, gibt ihnen mehr Kontrolle über ihre Daten und ermöglicht die Bildung von Gemeinschaften mit eigenen Regeln und Kulturen.

Diese Anleitung richtet sich nicht nur an Anfänger, sondern auch an fortgeschrittene User mit grundlegenden Linux-Kenntnissen, die ihre eigene Mastodon-Instanz aufsetzen und verwalten möchten. Wir werden Schritt für Schritt durch den gesamten Prozess gehen, von der Installation und Konfiguration bis hin zu fortgeschrittenen Themen wie Skalierung und Sicherheit.

Warum solltest du deine eigene Mastodon-Instanz betreiben?

Kontrolle: Du bestimmst die Regeln und das Erscheinungsbild deiner Community.
Datenschutz: Du hast volle Kontrolle über die Daten deiner Nutzer.
Unabhängigkeit: Du bist nicht von den Entscheidungen großer Technologieunternehmen abhängig.
Lernen: Du gewinnst wertvolle Erfahrungen im Betrieb und der Verwaltung eines sozialen Netzwerks.

Bitte beachte, dass der Betrieb einer Mastodon-Instanz Verantwortung und kontinuierliche Pflege erfordert. Diese Anleitung wird dir helfen, einen guten Start zu haben und deine Instanz langfristig erfolgreich zu betreiben .Lass uns nun mit der Einrichtung deiner eigenen Mastodon-Instanz beginnen!

Grundvoraussetzungen

Bevor du beginnst, stelle sicher, dass du Folgendes hast:

Einen Server mit Ubuntu 24.04 LTS (Long Term Support)
- Mindestens 2 CPU-Kerne
- Mindestens 4 GB RAM
- Mindestens 20 GB Festplattenspeicher
Root-Zugriff auf den Server (du solltest dich als Root-Benutzer einloggen können)
Eine Domain oder Subdomain für deine Mastodon-Instanz (z.B. mastodon.deinewebsite.de)
Einen SSH-Client auf deinem lokalen Computer (z.B. PuTTY für Windows oderTerminal für macOS/Linux)
Einen SMTP-Server für den E-Mail-Versand (z.B. von deinem Hosting-Anbieter oder einem Dienst wie Mailgun)

Systemaktualisierung

Aktualisiere die Paketlisten:

sudo apt update

ShellScript

Führe ein Systemupgrade durch:

sudo apt upgrade -y

ShellScript

Dies aktualisiert alle installierten Pakete auf die neueste Version. Die Option „-y“ beantwortet alle Fragen automatisch mit „Ja“.

Installiere einige grundlegende Abhängigkeiten:

sudo apt install -y curl wget gnupg apt-transport-https lsb-release ca-certificates

ShellScript

Diese Pakete werden für verschiedene Aufgaben während der Installation benötigt.

Installation von Node.js

Füge das offizielle Node.js-Repository hinzu:

curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list

ShellScript

Diese Befehle fügen den Schlüssel und die Quelle für das Node.js-Repository hinzu.

Aktualisiere die Paketlisten erneut:

sudo apt update

ShellScript

Installiere Node.js:

sudo apt install -y nodejs

ShellScript

Überprüfe die Installation:

node --version
npm --version

ShellScript

Installation von PostgreSQL

Installiere PostgreSQL:

curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | sudo gpg --dearmor -o /etc/apt/keyrings/nodesource.gpg
echo "deb [signed-by=/etc/apt/keyrings/nodesource.gpg] https://deb.nodesource.com/node_20.x nodistro main" | sudo tee /etc/apt/sources.list.d/nodesource.list

ShellScript

Überprüfe die Installation:

sudo systemctl status postgresql

ShellScript

Du solltest sehen, dass der PostgreSQL-Dienst aktiv und läuft.

Weiterer Systemabhängigkeiten

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

ShellScript

Dieser Befehl installiert alle notwendigen Abhängigkeiten für Mastodon, einschließlich Bildverarbeitung, Videokonvertierung, Webserver und Datenbanktreiber.

Installation von Yarn

Aktiviere das Corepack:

sudo corepack enable

ShellScript

Setze die Yarn-Version:

ShellScriptsudo yarn set version classic

ShellScript

Überprüfe die Installation:

yarn --version

ShellScript

Erstellung eines Mastodon-Benutzers

Erstelle einen neuen Benutzer für Mastodon:

sudo adduser --disabled-login mastodon

ShellScript

Dieser Befehl erstellt einen neuen Benutzer namens „mastodon“ ohne Login-Möglichkeit.

Installation von Ruby

Wechsle zum Mastodon-Benutzer:

sudo su - mastodon

ShellScript

Installiere rbenv (Ruby Version Manager):

git clone https://github.com/rbenv/rbenv.git ~/.rbenv
echo 'export PATH="$HOME/.rbenv/bin:$PATH"' >> ~/.bashrc
echo 'eval "$(rbenv init -)"' >> ~/.bashrc
exec bash

ShellScript

Installiere ruby-build:

git clone https://github.com/rbenv/ruby-build.git "$(rbenv root)"/plugins/ruby-build

ShellScript

Installiere Ruby:

RUBY_CONFIGURE_OPTS=--with-jemalloc rbenv install 3.2.3
rbenv global 3.2.3

ShellScript

Installiere Bundler:

gem install bundler --no-document

ShellScript

Überprüfe die Installation:

ruby --version
bundle --version

ShellScript

Verlasse den Mastodon-Benutzer:

exit

ShellScript

Konfiguration von PostgreSQL

Wechsle zum PostgreSQL-Benutzer:

sudo -u postgres psql

ShellScript

Erstelle einen Datenbankbenutzer für Mastodon:

CREATE USER mastodon CREATEDB;

SQL

Verlasse den PostgreSQL-Prompt:

\q

ShellScript

Installation von Mastodon

Wechsle zum Mastodon-Benutzer:

sudo su - mastodon

ShellScript

Klone das Mastodon-Repository:

git clone https://github.com/mastodon/mastodon.git live && cd live

ShellScript

Wechsle zur neuesten stabilen Version:

git checkout $(git tag -l | grep '^v[0-9.]*$' | sort -V | tail -n 1)

ShellScript

Installation der Abhängigkeiten

Konfiguriere Bundler:

bundle config deployment 'true'
bundle config without 'development test'

ShellScript

Installiere Ruby-Abhängigkeiten:

bundle install -j$(getconf _NPROCESSORS_ONLN)

ShellScript

Installiere JavaScript-Abhängigkeiten:

yarn install --pure-lockfile

ShellScript

Konfiguration von Mastodon

Führe den Setup-Assistenten aus:

Der Setup-Assistent von Mastodon ist ein interaktives Tool, das dich durch dieKonfiguration deiner Instanz führt. Hier ist eine detaillierte Anleitung für diesen Prozess:

RAILS_ENV=production bundle exec rake mastodon:setup

ShellScript

Der Assistent wird dich nun durch eine Reihe von Fragen führen. Hier sind die wichtigsten Punkte und wie du sie beantworten solltest:

a) Domain-Name:
- Gib hier den vollständigen Domain-Namen ein, unter dem deine Mastodon-Instanz erreichbar sein soll (z.B. mastodon.deinewebsite.de).WICHTIG: Dies kann später nicht mehr geändert werden!
b) Single-user Mode:
- Antworte mit „n“, wenn du möchtest, dass sich mehrere Benutzer auf deiner Instanz registrieren können.Antworte mit „y“, wenn du die einzige Person sein möchtest, die diese Instanz nutzt.
c) Docker:
- Da wir Mastodon direkt auf dem Server installieren, antworte hier mit „n“.
d) PostgreSQL-Konfiguration:
- Hostname: Gib „localhost“ ein, wenn PostgreSQL auf demselben Server läuft.Port: Der Standardport ist 5432. Drücke einfach Enter, wenn du diesen nicht geändert hast.Name der Datenbank: Gib „mastodon_production“ ein.Benutzername: Gib den PostgreSQL-Benutzernamen ein, den du früher erstellt hast (normalerweise „mastodon“).Passwort: Gib das Passwort für den PostgreSQL-Benutzer ein.
e) Redis-Konfiguration:
- Hostname: Gib „localhost“ ein, wenn Redis auf demselben Server läuft.Port: Der Standardport ist 6379. Drücke einfach Enter, wenn du diesen nicht geändert hast.Passwort: Wenn du kein Passwort für Redis eingerichtet hast, lasse dieses Feld leer.
f) SMTP-Konfiguration für E-Mail-Versand:
- Server: Gib den Hostnamen deines SMTP-Servers ein.Port: Üblicherweise 587 für TLS oder 465 für SSL.Login: Dein SMTP-Benutzername.Passwort: Dein SMTP-Passwort.Von-Adresse: Die E-Mail-Adresse, von der aus Mastodon Nachrichten senden soll (z.B. mastodon@deinewebsite.de).
g) Sprache:
- Wähle die Standardsprache für deine Instanz.
h) Administratorkonto:
- Der Assistent wird dich fragen, ob du sofort ein Administratorkonto erstellen möchtest. Antworte mit „y“.
- Gib dann einen Benutzernamen, eine E-Mail-Adresse und ein Passwort für das Administratorkonto ein.
Nach Beantwortung aller Fragen wird der Assistent die Konfiguration in der Datei .env.production speichern.
Der Assistent wird dann fragen, ob du die Assets (CSS/JS) kompilieren möchtest. Antworte mit „y“. Dieser Prozess kann einige Zeit dauern und viel RAM verbrauchen.
Zum Schluss wird der Assistent die Datenbank initialisieren und alle notwendigen Tabellen erstellen.
Notiere dir unbedingt die Zugangsdaten für das Administratorkonto, die am Ende angezeigt werden!

Nach Abschluss dieses Prozesses ist deine Mastodon-Instanz grundlegend konfiguriert. Du kannst nun mit den nächsten Schritten fortfahren, wie dem Einrichten der Systemdienste und der Webserver-Konfiguration.

Verlasse den Mastodon-Benutzer:

exit

ShellScript

Konfiguration von Nginx

Kopiere die Nginx-Konfigurationsvorlage:

sudo cp /home/mastodon/live/dist/nginx.conf /etc/nginx/sites-available/mastodon

ShellScript

Erstelle einen symbolischen Link:

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

ShellScript

Bearbeite die Konfigurationsdatei:

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

ShellScript

Ersetze "example.com" durch deine Domain und passe die SSL-Zertifikatspfade an.

Einrichtung der systemd-Dienste

Kopiere die systemd-Service-Vorlagen:

sudo cp /home/mastodon/live/dist/mastodon-*.service /etc/systemd/system/

ShellScript

Lade die systemd-Konfiguration neu:

sudo systemctl daemon-reload

ShellScript

Aktiviere und starte die Mastodon-Dienste:

sudo systemctl enable --now mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Überprüfe den Status der Dienste:

sudo systemctl status mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Let’s Encrypt

Konfiguriere SSL/TLS mit Let’s Encrypt:

sudo apt install certbot python3-certbot-nginx
sudo certbot --nginx -d deine-domain.com

ShellScript

Ersetze "deine-domain.com" durch deine tatsächliche Domain.

Starte Nginx neu:

sudo systemctl restart nginx

ShellScript

Sicherheitshinweise

Sicherheit ist bei der Verwaltung einer Mastodon-Instanz von größter Bedeutung. Hier sind detaillierte Schritte, um deine Instanz abzusichern:

Firewall-Konfiguration

Du hast zwei Hauptoptionen für die Firewall-Konfiguration: UFW (Uncomplicated Firewall) oder iptables. UFW ist ein benutzerfreundliches Frontend für iptables und wird oft für einfachere Konfigurationen empfohlen. Iptables bietet mehr Flexibilität, ist aber komplexerin der Handhabung.

Option 1: UFW (Uncomplicated Firewall)

UFW ist standardmäßig auf vielen Ubuntu-Systemen vorinstalliert.

Falls nicht, installiere es mit:

sudo apt install ufw

ShellScript

Konfiguriere UFW wie folgt:

sudo ufw default deny incoming
sudo ufw default allow outgoing
sudo ufw allow 22/tcp
sudo ufw allow 80/tcp
sudo ufw allow 443/tcp

ShellScript

Aktiviere UFW:

sudo ufw enable

ShellScript

Um den Status zu überprüfen:

sudo ufw status verbose

ShellScript

Option 2: iptables

Wenn du iptables bevorzugst, hier eine Basiskonfiguration.

Erstelle ein Skript zur Konfiguration von iptables:

sudo nano /etc/iptables-rules

ShellScript

Füge folgende Regeln in die Datei ein:

*filter

# Standardrichtlinien setzen
:INPUT DROP [0:0]
:FORWARD DROP [0:0]
:OUTPUT ACCEPT [0:0]

# Bestehende Verbindungen erlauben
-A INPUT -m conntrack --ctstate ESTABLISHED,RELATED -j ACCEPT

# Loopback-Verbindungen erlauben
-A INPUT -i lo -j ACCEPT

# SSH (Port 22) erlauben
-A INPUT -p tcp --dport 22 -j ACCEPT

# HTTP (Port 80) erlauben
-A INPUT -p tcp --dport 80 -j ACCEPT

# HTTPS (Port 443) erlauben
-A INPUT -p tcp --dport 443 -j ACCEPT

# ICMP (Ping) erlauben
-A INPUT -p icmp -j ACCEPT

COMMIT

ShellScript

Lade die Regeln:

ShellScriptsudo iptables-restore < /etc/iptables-rules

ShellScript

Um die Regeln dauerhaft zu speichern und beim Neustart zu laden, installiere iptables-persistent:

sudo apt install iptables-persistent
sudo netfilter-persistent save
sudo netfilter-persistent reload

ShellScript

Um den aktuellen Status der iptables-Regeln zu überprüfen:

sudo iptables -L -v

ShellScript

Zusätzliche Sicherheitsmaßnahmen

Unabhängig von der gewählten Firewall-Lösung solltest du folgende zusätzliche Sicherheitsmaßnahmen implementieren:

Regelmäßige Systemaktualisierungen:

sudo apt update
sudo apt upgrade -y

ShellScript

Führe diese Befehle wöchentlich aus.

Aktiviere automatische Sicherheitsupdates:

sudo apt install unattended-upgrades
sudo dpkg-reconfigure -plow unattended-upgrades

ShellScript

Konfiguriere sichere SSH-Einstellungen:

sudo nano /etc/ssh/sshd_config

ShellScript

Ändere folgende Zeilen:

PermitRootLogin no
PasswordAuthentication no

ShellScript

Starte den SSH-Dienst neu:

sudo systemctl restart sshd

ShellScript

2FA für dein Mastodon-Administratorkonto:

Logge dich in dein Mastodon-Konto ein
Gehe zu Einstellungen > Konto > Zwei-Faktor-Auth
Folge den Anweisungen zur Aktivierung

Installation Fail2ban

Installiere und konfiguriere Fail2ban, um wiederholte Anmeldeversuche zu blockieren:

sudo apt install fail2ban
sudo cp /etc/fail2ban/jail.conf /etc/fail2ban/jail.local
sudo nano /etc/fail2ban/jail.local

ShellScript

Aktiviere mindestens die SSH-Jail und passe die Einstellungen nach Bedarf an.

Weitere Punkte:

Verwende starke, einzigartige Passwörter für alle Konten und Dienste.
Halte Mastodon und alle anderen Softwarekomponenten stets auf dem neuesten Stand.

Backup und Restore

Erstelle ein Backup-Skript:

#!/bin/bash

# Setze Variablen
BACKUP_DIR="/path/to/backup/directory"
DATE=$(date +"%Y%m%d_%H%M%S")
MASTODON_USER="mastodon"
DB_NAME="mastodon_production"

# Erstelle Backup-Verzeichnis
mkdir -p $BACKUP_DIR/$DATE

# Datenbankbackup
echo "Erstelle Datenbank-Backup..."
sudo -u postgres pg_dump $DB_NAME > $BACKUP_DIR/$DATE/mastodon_db_backup.sql

# Medienbackup
echo "Erstelle Medien-Backup..."
sudo tar -czf $BACKUP_DIR/$DATE/mastodon_media_backup.tar.gz /home/$MASTODON_USER/live/public/system

# Konfigurationsbackup
echo "Erstelle Konfigurations-Backup..."
sudo cp /home/$MASTODON_USER/live/.env.production $BACKUP_DIR/$DATE/env_production_backup

# Setze Berechtigungen
sudo chown -R $MASTODON_USER:$MASTODON_USER $BACKUP_DIR/$DATE

echo "Backup abgeschlossen und gespeichert in $BACKUP_DIR/$DATE"

ShellScript

Mache das Skript ausführbar:

sudo chmod +x /usr/local/bin/mastodon_backup.sh

ShellScript

Teste das BackUp Script:

sudo apt install ufwShellScript

ShellScript

Richte einen Cronjob für tägliche Backups ein:

sudo crontab -e

ShellScript

Füge folgende Zeile hinzu:

0 2 * * * /usr/local/bin/mastodon_backup.sh

YAML

Dies führt das Backup täglich um 2 Uhr morgens aus.

Restore-Prozess

Stoppe die Mastodon-Dienste:

sudo systemctl stop mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Stelle die Datenbank wieder her:

sudo -u postgres psql

ShellScript

Im PostgreSQL-Prompt:

DROP DATABASE mastodon_production;
CREATE DATABASE mastodon_production;
\q

SQL

Dann:

sudo -u postgres psql mastodon_production < /path/to/backup/directory/DATE/mastodon_db_backup.sql

ShellScript

Stelle die Mediendateien wieder her:

sudo rm -rf /home/mastodon/live/public/system
sudo tar -xzf /path/to/backup/directory/DATE/mastodon_media_backup.tar.gz -C /

ShellScript

Stelle die Konfigurationsdatei wieder her:

sudo systemctl status mastodon-web mastodon-sidekiq mastodon-streamingShellScript

ShellScript

Setze die korrekten Berechtigungen:

sudo chown -R mastodon:mastodon /home/mastodon/live

ShellScript

Starte die Mastodon-Dienste:

sudo systemctl start mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Troubleshooting

Problem 1: Mastodon-Dienste starten nicht

Überprüfe den Status der Dienste:

sudo systemctl status mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Überprüfe die Logs:

sudo journalctl -u mastodon-web
sudo journalctl -u mastodon-sidekiq
sudo journalctl -u mastodon-streaming

ShellScript

Häufige Lösungen:

Überprüfe die Datenbankverbindung in .env.production
Stelle sicher, dass alle Abhängigkeiten installiert sind:

cd /home/mastodon/live
bundle install
yarn install

ShellScript

Problem 2: Webseite lädt nicht

Überprüfe den Nginx-Status:

sudo systemctl status nginx

ShellScript

Überprüfe die Nginx-Konfiguration:

sudo nginx -t

ShellScript

Überprüfe die Firewall-Einstellungen:

sudo ufw status  # Wenn du UFW verwendest

ShellScript

oder

sudo iptables -L  # Wenn du iptables verwendest

ShellScript

Überprüfe die SSL-Zertifikate:

sudo certbot certificates

ShellScript

Problem 3: Datenbank-Verbindungsprobleme

Überprüfe die PostgreSQL-Konfiguration:

sudo -u postgres psql -c "\l"

ShellScript

Stelle sicher, dass die Datenbankkonfiguration in .env.production korrekt ist:

sudo nano /home/mastodon/live/.env.production

ShellScript

Überprüfe, ob PostgreSQL läuft:

udo systemctl status postgresql

ShellScript

Problem 4: E-Mail-Versand funktioniert nicht

Überprüfe die SMTP-Konfiguration in .env.production
Teste den E-Mail-Versand manuell:

sudo su - mastodon
cd ~/live
RAILS_ENV=production bundle exec rails console

ShellScript

Im Rails-Console:

ActionMailer::Base.mail(to: 'deine@email.com', from: 'mastodon@deineinstanz.com', subject: 'Test', body: 'Dies ist ein Test').deliver_now

ShellScript

Überprüfe die Logs auf SMTP-Fehler:

sudo journalctl -u mastodon-sidekiq

ShellScript

Problem 5: Speicherplatzprobleme

Überprüfe den verfügbaren Speicherplatz:

df -h

ShellScript

Identifiziere große Dateien/Verzeichnisse:

sudo du -h /home/mastodon/live | sort -rh | head -n 20

ShellScript

Bereinige alte Mediendateien und Caches:

cd /home/mastodon/live
RAILS_ENV=production bundle exec rake mastodon:media:remove_remote
RAILS_ENV=production bundle exec rake mastodon:media:remove_orphans

ShellScript

Allgemeine Troubleshooting-Tipps:

Überprüfe immer zuerst die Logs für spezifische Fehlermeldungen.
Stelle sicher, dass alle Dienste (Nginx, PostgreSQL, Redis) laufen.
Überprüfe die Systemressourcen (CPU, RAM, Speicherplatz).
Vergleiche die aktuelle Konfiguration mit einer bekannten funktionierenden Version.
Konsultiere die offizielle Mastodon-Dokumentation und Community-Foren für spezifische Probleme.

Bei anhaltenden Problemen zögere nicht, in der Mastodon-Community oder bei erfahrenen Systemadministratoren um Hilfe zu bitten. Dokumentiere alle Schritte, die du unternimmst, um das Problem zu lösen, da dies bei der Fehlersuche und für zukünftige Referenzen hilfreich sein kann.

Skalierung

Bei wachsender Nutzerzahl deiner Mastodon-Instanz musst du möglicherweise skalieren. Hier einige Strategien:

Vertikale Skalierung:
- Erhöhe die Ressourcen deines Servers (CPU, RAM, SSD).
- Beispiel: Upgrade von 2 auf 4 CPU-Kerne und von 4GB auf 8GB RAM.
Horizontale Skalierung:
- Verteile Dienste auf mehrere Server:

a) Separater Datenbankserver:

# Auf dem neuen Datenbankserver
sudo apt install postgresql
# Konfiguriere PostgreSQL für Fernzugriff
sudo nano /etc/postgresql/12/main/postgresql.conf
# Ändere: listen_addresses = '*'
sudo nano /etc/postgresql/12/main/pg_hba.conf
# Füge hinzu: host all all your_mastodon_server_ip/32 md5

ShellScript

b) Separater Redis-Server:

# Auf dem neuen Redis-Server
sudo apt install redis-server
sudo nano /etc/redis/redis.conf
# Ändere: bind 0.0.0.0

ShellScript

c) Aktualisiere .env.production auf dem Hauptserver mit den neuen Serveradressen.

Lastverteilung

Setze einen Nginx-Load-Balancer vor mehreren Mastodon-Web-Servern ein.

Caching

Aktiviere Redis-Caching in der Mastodon-Konfiguration.

Aktualisierung von Mastodon

Regelmäßige Updates sind wichtig für Sicherheit und neue Funktionen.

Hier der Prozess:

Backup erstellen (siehe Backup-Abschnitt).
Stoppe Mastodon-Dienste:

sudo systemctl stop mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Wechsle zum Mastodon-Benutzer:

sudo su - mastodon

ShellScript

cd ~/live

ShellScript

Aktualisiere den Code:

git fetch
git checkout $(git tag -l | grep '^v[0-9]*\.[0-9]*\.[0-9]*$' | sort -V | tail -n 1)

ShellScript

Installiere neue Abhängigkeiten:

bundle install
yarn install

ShellScript

Führe Datenbankmigrationen durch:

RAILS_ENV=production bundle exec rails db:migrate

ShellScript

Precompile Assets:

RAILS_ENV=production bundle exec rails assets:precompile

ShellScript

Verlasse den Mastodon-Benutzer:

exit

ShellScript

Starte Mastodon-Dienste:

sudo systemctl start mastodon-web mastodon-sidekiq mastodon-streaming

ShellScript

Überprüfe die Funktionalität deiner Instanz im Browser.

Ressourcenmanagement

Überwachung

sudo apt install htop iotop

ShellScript

htop # CPU und RAM-Nutzung
iotop # Festplattenaktivität

Optimierung Datenbankleistung

Passe postgresql.conf an:

sudo nano /etc/postgresql/12/main/postgresql.conf

ShellScript

Wichtige Parameter:

shared_buffers = 256MB  # 25% des verfügbaren RAM
work_mem = 4MB
maintenance_work_mem = 64MB
effective_cache_size = 768MB  # 50% des verfügbaren RAM

YAML

Nginx-Optimierung

Passe nginx.conf an:

sudo nano /etc/nginx/nginx.conf

ShellScript

Beispielkonfiguration:

worker_processes auto;
worker_connections 1024;
keepalive_timeout 65;
gzip on;

Nginx

Sidekiq-Optimierung

Passe die Anzahl der Worker an:

sudo nano /etc/systemd/system/mastodon-sidekiq.service

ShellScript

Ändere:

ExecStart=/home/mastodon/.rbenv/shims/bundle exec sidekiq -c 5 -q default -q mailers -q pull -q push

ShellScript

Regelmäßige Bereinigung:

RAILS_ENV=production bundle exec rake mastodon:media:remove_remote
RAILS_ENV=production bundle exec rake mastodon:media:remove_orphans

ShellScript

Glossar

Föderiertes Netzwerk: Ein dezentrales Netzwerk aus verbundenen, aber unabhängigen Servern.
Toot: Ein Beitrag auf Mastodon, ähnlich einem Tweet.
Instanz: Ein einzelner Mastodon-Server im föderierten Netzwerk.
Sidekiq: Hintergrundverarbeitungssystem für Ruby, verwendet von Mastodon.
PostgreSQL: Die von Mastodon verwendete relationale Datenbank.
Redis: In-Memory-Datenspeicher, verwendet für Caching und Hintergrundaufgaben.
Nginx: Webserver und Reverse Proxy, der Anfragen an Mastodon weiterleitet.
Ruby on Rails: Das Web-Framework, auf dem Mastodon basiert.
ActivityPub: Das Protokoll, das die Föderation zwischen Mastodon-Instanzen ermöglicht.

Fazit

Herzlichen Glückwunsch! Du hast nun eine umfassende Anleitung zur Installation, Konfiguration und Verwaltung einer Mastodon-Instanz durchgearbeitet. Mit diesem Wissen bist du gut gerüstet, um deine eigene Instanz im föderierten Netzwerk von Mastodon zu betreiben.

Wir haben viele wichtige Aspekte behandelt, von der grundlegenden Installation über Sicherheitsmaßnahmen bis hin zu fortgeschrittenen Themen wie Skalierung und Leistungsoptimierung.

Einige Schlüsselpunkte zum Abschluss:

Sicherheit: Halte dein System und Mastodon stets auf dem neuesten Stand und implementiere robuste Sicherheitsmaßnahmen.
Backup: Führe regelmäßige Backups durch und teste die Wiederherstellung, um im Notfall vorbereitet zu sein.
Community: Baue aktiv eine Gemeinschaft auf und moderiere sie fair und transparent.
Ressourcen: Überwache die Serverressourcen und skaliere bei Bedarf.
Rechtliches: Bleibe über rechtliche Anforderungen und Datenschutzbestimmungen auf dem Laufenden.
Lernen: Die Technologie entwickelt sich ständig weiter. Bleib neugierig und lernbereit.

Denk daran, dass du Teil einer größeren Community von Mastodon-Administratoren bist. Zögere nicht, Hilfe zu suchen oder deine Erfahrungen mit anderen zu teilen. Die Mastodon-Community ist in der Regel sehr hilfsbereit und freut sich über neue Mitglieder.

Mit deiner eigenen Mastodon-Instanz trägst du zur Dezentralisierung des Internets bei und gibst Menschen eine Alternative zu den großen, zentralisierten sozialen Netzwerken. Dies ist ein wichtiger Schritt in Richtung eines freieren und vielfältigeren Internets.

Viel Erfolg mit deiner Mastodon-Instanz und genieße die Reise in die Welt der föderierten sozialen Netzwerke!