# Eigenen Mastodon-Server erstellen: Schritt für Schritt erklärt

Ein eigener Mastodon-Server gibt Ihnen die volle Kontrolle über Ihre Daten und die Moderation Ihrer **Community**. So erzielen Sie eine individuelle, datenschutzfreundliche und werbefreie Nutzererfahrung.

## Was sind die Voraussetzungen für einen Mastodon-Server?

Sie können mit Ihrem Server klein starten und ihn **je nach Bedarf erweitern**, um mit dem Wachstum Ihrer Community Schritt zu halten. Für das Aufsetzen eines Mastodon-Servers benötigen Sie:

- **VPS oder ein anderer Server**: Obwohl Sie Mastodon auch auf einem lokalen Server betreiben können, ist ein [Virtual Private Server (VPS)](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-virtual-private-server-vps/) eine flexiblere und einfach zu verwaltende Lösung. Dieser Server sollte am besten Ubuntu 20.04 oder Debian 11 als Betriebssystem verwenden und Ihnen Root-Zugriff gewähren, um die erforderlichen Konfigurationen vorzunehmen.
- **Domain oder Subdomain**: Sie benötigen eine eigene Domain oder eine Subdomain, um Ihren Mastodon-Server zu identifizieren. So können Benutzerinnen und Benutzer Ihre Instanz finden und sich mit ihr verbinden.

- **Ständige Online-Verfügbarkeit**: Ihr Server muss rund um die Uhr online sein, damit andere Ihre Mastodon-Instanz nutzen können.
- **E-Mail-Anbieter**: Mastodon sendet Benachrichtigungen und Bestätigungslinks per E-Mail, daher brauchen Sie einen E-Mail-Anbieter, um diese Funktionen zu unterstützen. Sie können einen eigenen [SMTP-Server](https://www.ionos.de/digitalguide/e-mail/e-mail-technik/smtp-server/) installieren. Allerdings ist Drittanbieter-Software meist praktischer. Mastodon empfiehlt unter anderem Mailgun, SparkPost oder Sendgrid.
- **[Object Storage](https://www.ionos.de/digitalguide/server/knowhow/was-ist-object-storage/) Provider (optional)**: Es ist ratsam, einen Amazon S3-kompatiblen Object Storage Provider zu nutzen, da Mastodon Daten wie Bilder, Videos und andere Medien auf dem Server speichert. Der zusätzliche Speicherplatz sorgt dafür, dass Ihre Mastodon-Instanz reibungslos läuft und genügend Platz für Benutzerdaten bietet.

Ihr Server sollte außerdem die folgenden technischen Mindestanforderungen erfüllen:

- **CPU/Rechenpower**: min. 2 Kerne
- **RAM/Arbeitsspeicher**: min. 2 GB
- **Festplattenspeicher**: min. 30 GB

Mastodon verwendet eine Datenbank (PostgreSQL), um Benutzerdaten und andere Informationen zu speichern. Bei einer großen Benutzerbasis kann die Anzahl der Datenbankzugriffe hoch sein. Achten Sie darauf, dass Ihre **Datenbank ausreichend optimiert ist** und genügend Ressourcen (CPU und RAM) zur Verfügung stehen, um diese Zugriffe effizient zu verarbeiten.

## Mastodon-Server mit IONOS VPS hosten

Sie wollen mit Ihrer eigenen Mastodon-Instanz starten, aber sind sich nicht sicher, welcher VPS-Plan Ihren Anforderungen gerecht wird? IONOS bietet Ihnen **leistungsstarke VPS-Pakete** mit dedizierten Ressourcen und unbegrenztem Traffic zu kostengünstigen Preisen.

Für einen einfachen Mastodon-Server ist das [VPS Linux M+ Paket](https://www.ionos.de/server/vps "VPS Linux M+ von IONOS") von IONOS die perfekte Wahl. Hier erhalten Sie 80 GB Speicherplatz und bis zu 1 Gbit/s Bandbreite. Sollten Sie mehr Ressourcen brauchen, wählen Sie einfach das entsprechende Leistungspaket.

## Mögliche Mastodon-Server-Szenarien und die passenden IONOS-Tarife

Bei der Entscheidung eines geeigneten VPS-Pakets sollten Sie die potenzielle Nutzerzahl Ihrer Mastodon-Instanz einschätzen. Je nach erwartetem Traffic empfehlen wir die folgenden IONOS-Tarife:

<table>
  <thead>
    <tr>
      <th>Mastodon-Server-Szenario</th>
      <th>Passender IONOS-VPS-Server</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>bis zu 100 Personen</td>
      <td>VPS Linux M</td>
    </tr>
    <tr>
      <td>100-1000 Personen</td>
      <td>VPS Linux L</td>
    </tr>
    <tr>
      <td>1000-10000 Personen</td>
      <td>VPS Linux XL</td>
    </tr>
    <tr>
      <td>ab 10000 Personen</td>
      <td>VPS Linux XXL</td>
    </tr>
  </tbody>
</table>

Zusätzlich können Sie Ihren Mastodon-Server auch parallel zu anderen Diensten laufen lassen. Bei einer einfachen Nutzerbasis können Sie bei diesen Tarifen einsteigen:

<table>
  <thead>
    <tr>
      <th>Mastodon-Server-Szenario</th>
      <th>Passender IONOS-VPS-Server</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>Paralleler Betrieb einer einfachen Website</td>
      <td>VPS Linux M</td>
    </tr>
    <tr>
      <td>Paralleler Betrieb eines Voice Servers</td>
      <td>VPS Linux M</td>
    </tr>
    <tr>
      <td>Paralleler Betrieb eines Online-Shops</td>
      <td>VPS Linux L</td>
    </tr>
  </tbody>
</table>

## Mastodon-Server erstellen: Schritt-für-Schritt-Anleitung

### Schritt 1: Server vorbereiten

Die meisten Hosting-Anbieter bieten die Möglichkeit, das Betriebssystem während der Einrichtung zu bestimmen. Mastodon läuft am besten unter Ubuntu 20.04 und Debian 11. Wählen Sie, wenn Sie die Möglichkeit haben, eines dieser Betriebssysteme aus. Nachdem Ihr VPS eingerichtet ist, **verbinden Sie sich per SSH mit Ihrem Server**. Verwenden Sie dazu ein Terminal (Linux/Mac) oder einen SSH-Client wie PuTTY (Windows).

```bash
ssh root@your_server_ip
```

Ersetzen Sie `your_server_ip` durch die IP-Adresse Ihres VPS.

Für den Schutz Ihres Systems sollten Sie SSH-Keys verwenden und Firewall-Regeln mit **iptables** einrichten, um nur die HTTP(S)- und SSH-Ports offenzulassen. Danach müssen Sie den A-Record Ihrer Domain oder Subdomain auf die IP-Adresse des VPS verweisen. Für IPv6 fügen Sie zusätzlich einen AAAA-Record hinzu.

Führen Sie ein Update des Paketmanagers und der Systempakete durch:

```bash
apt update && apt upgrade -y
```

### Schritt 2: Benötigte Pakete installieren

Mastodon erfordert mehrere Pakete und Abhängigkeiten, um ordnungsgemäß zu funktionieren. Diese umfassen unter anderem Node.js, Yarn, PostgreSQL, Redis und Nginx.

Installieren Sie zuerst grundlegende Pakete:

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

**Node.js**

```bash
curl -fsSL https://deb.nodesource.com/gpgkey/nodesource-repo.gpg.key | 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" | tee /etc/apt/sources.list.d/nodesource.list
```

**PostgreSQL**

```bash
wget -O /usr/share/keyrings/postgresql.asc https://www.postgresql.org/media/keys/ACCC4CF8.asc
echo "deb [signed-by=/usr/share/keyrings/postgresql.asc] http://apt.postgresql.org/pub/repos/apt $(lsb_release -cs)-pgdg main" > /etc/apt/sources.list.d/postgresql.list
```

**Systempakete**

```bash
apt update
```

```bash
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 nodejs redis-server redis-tools postgresql postgresql-contrib certbot python3-certbot-nginx libidn11-dev libicu-dev libjemalloc-dev
```

**Yarn**

```bash
corepack enable
yarn set version classic
```

**Ruby**

Mastodon ist in Ruby geschrieben und benötigt daher Ruby und Bundler. Dazu legen Sie zunächst den Nutzer an, unter dem Mastodon laufen soll:

```bash
adduser --disabled-login mastodon
```

Nun wechseln Sie zu dem erstellten Nutzeraccount:

```bash
su - mastodon
```

Installieren Sie `rbenv` und `rbenv-build`:

```bash
git clone https://github.com/rbenv/rbenv.git ~/.rbenv
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
```

Wenn dies abgeschlossen ist, installieren Sie die korrekte Version von Ruby und den Bundler:

```bash
RUBY_CONFIGURE_OPTS=--with-jemalloc rbenv install 3.2.3
rbenv global 3.2.3
gem install bundler --no-document
```

Kehren Sie mit `exit` zum Root-Benutzer zurück.

### Schritt 3: PostgreSQL konfigurieren

PostgreSQL wird vom Mastodon-Server zur Speicherung und Verwaltung von Daten verwendet. Sie haben im vorherigen Schritt den Datenbankserver bereits installiert. Wechseln Sie zum Postgres-Benutzer, um auf die PostgreSQL-Shell zuzugreifen:

```bash
sudo -u postgres psql
```

Mastodon meldet sich bei dem Datenbankserver ohne Passwort an. Daher müssen der Linux-Systembenutzername und der Benutzername für die Datenbank übereinstimmen. Führen Sie in der PostgreSQL-Shell die folgenden Befehle aus, um die Datenbank zu erstellen:

```sql
CREATE USER mastodon CREATEDB;
\q
```

Sie können die Leistung Ihrer PostgreSQL-Datenbank durch Anpassungen an die verfügbaren Systemressourcen verbessern. Ein hilfreiches Werkzeug hierfür ist der Konfigurationsgenerator **pgTune**. Dort geben Sie Informationen wie die Anzahl der CPU-Kerne und die RAM-Größe ein und erhalten eine optimierte PostgreSQL-Konfiguration, die Sie in `postgresql.conf` angeben.

### Schritt 4: Mastodon installieren

Als Nächstes kehren Sie zurück zum Mastodon-Nutzer:

```bash
su - mastodon
```

Laden Sie die neueste stabile Version von Mastodon herunter:

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

Installieren Sie auch die Ruby- und JavaScript-Abhängigkeiten:

```bash
bundle config deployment 'true'
bundle config without 'development test'
bundle install -j$(getconf _NPROCESSORS_ONLN)
yarn install --pure-lockfile
```

Führen Sie den Mastodon Setup Wizard aus:

```bash
RAILS_ENV=production bundle exec rake mastodon:setup
```

Sie werden nun zu verschiedenen Einstellungen befragt, welche am Ende in der Datei `.env.production` gespeichert werden.

- **Domain name**: Domainnamen des VPS-Servers angeben
- **Do you want to enable single user mode?**: N
- **Are you using Docker to run Mastodon?**: N
- **PostgreSQL host**: default - Enter
- **PostgreSQL port**: default - Enter
- **Name of PostgreSQL database**: default - Enter
- **Name of PostgreSQL user**: default - Enter
- **Password of PostgreSQL user**: leer lassen - Enter
- **Redis host**: default - Enter
- **Redis port**: default - Enter
- **Redis password**: default – Enter
- **Do you want to store uploaded files on the cloud?**: N
- **Do you want to send e-mails from localhost?**: N
- **SMTP server**: SMTP-Server angeben
- **SMTP port**: Port des SMTP-Servers angeben
- **SMTP username**: Benutzername für die Anmeldung
- **SMTP authentication**: plain
- **SMTP OpenSSL verify mode**: none
- **E-mail address to send e-mails “from”**: meist wie SMTP-Login
- **Send a test e-mail with this configuration right now?**: Y
- **Send test e-mail to**: beliebige Mail-Adresse als Empfänger angeben
- **Save configuration?**: Y
- **Prepare the database now?**: Y
- **Compile the assets now?**: Y
- **Do you want to create an admin user straight away?**: Y
- **Username**: admin
- **E-Mail**: eigene Mail-Adresse

Wechseln Sie wieder zum Root-Benutzer:

```bash
exit
```

### Schritt 5: SSL-Zertifikat installieren

VPS-Server von IONOS haben standardmäßig bereits ein SSL-Zertifikat inklusive. Sollte in Ihrem Paket aber kein Zertifikat enthalten sein, können Sie dieses einfach nachinstallieren.

Sie können ein kostenloses SSL-Zertifikat von **Let’s Encrypt** erhalten. Let’s Encrypt bietet automatisierte Zertifikate an, die einfach zu installieren und zu erneuern sind.

```bash
certbot certonly --nginx -d example.com
```

Das Zertifikat wird im Ordner `/etc/letsencrypt/live/example.com/` auf Ihrem Mastodon-Server gespeichert.

### Schritt 6: Nginx einrichten

Sie müssen das Konfigurationstemplate für Nginx aus dem Mastodon-Verzeichnis kopieren und in das Verzeichnis `sites-available` von Nginx einfügen:

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

Erstellen Sie einen symbolischen Link von der Konfigurationsdatei in `sites-enabled`, um sie zu aktivieren und entfernen Sie die Standardkonfiguration:

```bash
ln -s /etc/nginx/sites-available/mastodon /etc/nginx/sites-enabled/mastodon
rm /etc/nginx/sites-enabled/default
```

Öffnen Sie die Konfigurationsdatei für Ihren Mastodon-Server:

```bash
nano /etc/nginx/sites-available/mastodon
```

Tragen Sie statt `example.com` Ihren eigenen Domainnamen ein.

Entkommentieren Sie die Zeilen `ssl_certificate` und `ssl_certificate_key`, und ersetzen Sie die Pfade durch die zu Ihrem SSL-Zertifikat. Wenn Sie das **Standard-Selbstsignatur-Zertifikat** benutzen, bleiben die Pfade unverändert:

```bash
ssl_certificate     /etc/ssl/certs/ssl-cert-snakeoil.pem;
ssl_certificate_key /etc/ssl/private/ssl-cert-snakeoil.key;
```

Sobald Sie die Konfiguration angepasst haben, müssen Sie Nginx neu laden, damit die Änderungen wirksam werden:

```bash
systemctl reload nginx
```

### Schritt 7: Systemd-Services einrichten

Wenn Sie die Systemd-Dienste aktivieren, werden die Mastodon-Webanwendung und die Echtzeit-Streaming-Funktionen automatisch gestartet, wenn der Server hochgefahren wird. Dies gewährleistet, dass Ihr Mastodon-Server **permanent verfügbar** ist.

Kopieren Sie die Systemd-Servicetemplates von Mastodon in das entsprechende Verzeichnis:

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

Wenn Sie irgendwann von den Standardwerten abgewichen sind, überprüfen Sie, ob der Benutzername und die Pfade in den Servicevorlagen korrekt sind:

```bash
$EDITOR /etc/systemd/system/mastodon-*.service
```

Starten und aktivieren Sie die Systemd-Dienste:

```bash
systemctl daemon-reload
systemctl enable --now mastodon-web mastodon-sidekiq mastodon-streaming
```

- **systemctl daemon-reload**: Aktualisiert die Konfiguration von Systemd, um die neuen Servicetemplates zu berücksichtigen.
- **systemctl enable --now mastodon-web mastodon-sidekiq mastodon-streaming**: Diese Dienste sind für die Webanwendung, Hintergrundverarbeitung und Echtzeit-Streaming-Funktionen von Mastodon verantwortlich.

### Schritt 8: Zeichenbegrenzung ändern

Indem Sie Ihren eigenen Mastodon-Server betreiben, haben Sie die Freiheit, Einstellungen vorzunehmen, die auf öffentlichen Servern normalerweise nicht möglich sind. Ein Beispiel dafür ist die Anpassung der Zeichenbegrenzung für Beiträge. Standardmäßig ist diese auf 500 Zeichen festgelegt, aber Sie können sie auch erhöhen oder verringern.

Zunächst müssen Sie zum Mastodon-Benutzer in der Konsole wechseln. Dann müssen Sie zwei bestimmte Dateien bearbeiten.

Geben Sie in den folgenden Dateien Ihren gewünschten Wert für die Zeichenbegrenzung ein:

- `compose_form.js` im Verzeichnis `~/live/app/javascript/mastodon/features/compose/components/`
- `status_length_validator.rb` in `~/live/app/validators/`

In der Datei `instance_serializer.rb` im Verzeichnis `~/live/app/serializers/rest/` finden Sie die Zeile, in der `:languages, :registrations,` steht und fügen dahinter `:max_toot_chars,` hinzu.

Außerdem ergänzen Sie unter der Zeile, die mit `private` beginnt, den folgenden Code, wobei Sie den gewünschten Wert einsetzen:

```ruby
def max_toot_chars
    1000
end
```

Nachdem Sie diese Änderungen vorgenommen haben, müssen die Mastodon-Dienste neu gestartet werden. Dies erfolgt als Root-Benutzer mit dem Befehl:

```bash
service mastodon-* restart
```

Nun können Sie Beiträge mit einer Zeichenbegrenzung von 1000 Zeichen schreiben.

### Schritt 9: Moderationsfunktion

Die Moderationsfunktion unter “Einstellungen &gt; Moderation” auf Ihrem Mastodon-Server gestattet es Ihnen als Admin, die Inhalte und Benutzeraktivitäten auf Ihrer Instanz zu überwachen und zu steuern, um die **Community-Richtlinien** einzuhalten und unerwünschte Inhalte zu entfernen.

Sie haben die Möglichkeit, **einzelne Accounts, Domains, IP-Adressen oder E-Mail-Server** zu blockieren, zu entsperren oder Benutzerkonten zu löschen. Zusätzlich können Sie Inhalte moderieren, die von Benutzerinnen und Benutzern veröffentlicht wurden, indem Sie unangemessene oder beleidigende Beiträge entfernen oder bearbeiten.


This is a markdown version of: [https://www.ionos.de/digitalguide/server/knowhow/mastodon-server-erstellen/](https://www.ionos.de/digitalguide/server/knowhow/mastodon-server-erstellen/) for AI/LLM consumption.