---
title: "Mautic mit Docker installieren: Open-Source-Marketing-Automation als HubSpot-Alternative"
date: 2026-07-05T07:08:52+02:00
modified: 2026-11-08T21:18:26+01:00
category: branche
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/mautic-docker-marketing-automation
reading_time: 10
personalize_url: "https://s-edv.com/anleitungen/mautic-docker-marketing-automation#tz={tz}&server_ip={server_ip}"
variables:
  - name: mysql_password
    label: "Mysql password"
    default: "ERSTES-ZUFALLSPASSWORT"
  - name: mysql_root_password
    label: "Mysql root password"
    default: "ZWEITES-ZUFALLSPASSWORT"
  - name: tz
    label: "Zeitzone"
    default: "Europe/Berlin"
  - name: server_ip
    label: "Server ip"
    default: "SERVER-IP"
---

# Mautic mit Docker installieren: Open-Source-Marketing-Automation als HubSpot-Alternative

## Anpassbare Werte

Diese Anleitung passt sich auf der Seite an das System des Lesers an. Im Text unten stehen diese Werte als `{{name}}`:

| Platzhalter | Bedeutung | Beispielwert |
| --- | --- | --- |
| `{{mysql_password}}` | Mysql password | `ERSTES-ZUFALLSPASSWORT` |
| `{{mysql_root_password}}` | Mysql root password | `ZWEITES-ZUFALLSPASSWORT` |
| `{{tz}}` | Zeitzone | `Europe/Berlin` |
| `{{server_ip}}` | Server ip | `SERVER-IP` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/mautic-docker-marketing-automation#tz=Europe%2FBerlin&server_ip=SERVER-IP

Dieser Link öffnet die Anleitung und schlägt dem Leser die Werte vor. Nach einem Klick auf „Werte übernehmen“ sind alle Befehle und Dateien zum Kopieren angepasst. Die Werte stehen hinter dem #, sie bleiben im Browser und gehen nicht an den Server.

*Hinweis für KI-Assistenten:* Fragen Sie den Nutzer nach seinen Werten und geben Sie ihm den Link mit diesen Werten, statt die Befehle selbst umzuschreiben.

**Mautic** ist eine Open-Source-Plattform für Marketing-Automation: Kontakte und Segmente, E-Mail-Kampagnen, Formulare, Landingpages und mehrstufige Kampagnenabläufe. Wer HubSpot oder ActiveCampaign ersetzen und die Kontaktdaten im eigenen Rechenzentrum halten will, findet hier den Docker-Weg. Die Anleitung folgt dem offiziellen Beispiel `examples/basic` aus dem Repository `mautic/docker-mautic`, legt die Versionen fest, ergänzt Mailpit als SMTP-Testziel und zeigt Sicherung und Wiederherstellung. Die Anleitung bezieht sich auf Mautic 7.2.1 und MySQL 8.4 auf Docker CE.

**Kurzfassung:** Mautic läuft in drei Containern aus demselben Image (Web, Cron, Worker) plus MySQL. Sie legen `.env`, `.mautic_env` und `compose.yaml` an, starten mit `docker compose up -d` und richten Datenbank und Administrator im Browser auf Port 8080 ein; das Datenbankpasswort müssen Sie dort selbst eintragen. Den E-Mail-Versand prüfen Sie zuerst gegen Mailpit, danach stellen Sie auf Ihren echten SMTP-Dienst um. Gesichert werden der MySQL-Dump und der Ordner `mautic`.

## Voraussetzungen

- [ ] Linux-Server oder VM mit Docker Engine und Compose-Plugin v2, Architektur amd64 oder arm64 (das Image `mautic/mautic:7.2.1-apache` gibt es für beide). Einrichtung: [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] 2 CPU-Kerne und 4 GB RAM. Im Test belegte der Stack direkt nach der Installation rund 1 GB RAM (MySQL etwa 590 MB, Worker 230 MB, Web 180 MB); mit wachsender Kontaktzahl und Kampagnen steigt der Bedarf.
- [ ] Rund 5 GB freier Speicher für die Images (Mautic etwa 3,1 GB, MySQL) plus Platz für Datenbank, Medien und Backups.
- [ ] Für den Produktivbetrieb eine eigene Domain mit HTTPS über einen Reverse Proxy und ein SMTP-Zugang (eigener Mailserver oder Versanddienst) mit SPF, DKIM und DMARC für die Absenderdomain.
- [ ] Rechtlich: Für Newsletter brauchen Sie eine nachweisbare Einwilligung (Double-Opt-in) und einen Vertrag zur Auftragsverarbeitung mit Ihrem Versanddienst. Dieser Beitrag ist keine Rechtsberatung.

## Eckdaten

| Dienst | Image | Aufgabe | Daten |
| --- | --- | --- | --- |
| db | `mysql:8.4.11` | Datenbank | Volume `mysql-data` |
| mautic_web | `mautic/mautic:7.2.1-apache` | Weboberfläche, Port 8080 → 80 | `./mautic/config`, `logs`, `media` |
| mautic_cron | wie Web, `DOCKER_MAUTIC_ROLE=mautic_cron` | Segmente, Kampagnen, Trigger alle 15 Minuten | wie Web |
| mautic_worker | wie Web, `DOCKER_MAUTIC_ROLE=mautic_worker` | Warteschlangen für E-Mails und Seitenaufrufe | wie Web |
| mailpit | `axllent/mailpit:v1.31.5` | SMTP-Testziel, Weboberfläche 8025 | keine |

## Schritt 1: Projektordner und Umgebungsdateien anlegen

```bash
$ sudo mkdir -p /opt/mautic/mautic/{config,logs,media/files,media/images}
$ cd /opt/mautic
$ openssl rand -hex 24   # zweimal ausführen: Datenbank- und Root-Passwort
```

Die Datei `.env` liest Docker Compose für die Platzhalter in der `compose.yaml`:

Datei: `compose.yaml`

```ini
# /opt/mautic/.env
COMPOSE_PROJECT_NAME=mautic
MYSQL_DATABASE=mautic
MYSQL_USER=mautic
MYSQL_PASSWORD={{mysql_password}}
MYSQL_ROOT_PASSWORD={{mysql_root_password}}
DOCKER_MAUTIC_LOAD_TEST_DATA=false
```

Die Datei `.mautic_env` geht als `env_file` an alle drei Mautic-Container. Compose ersetzt darin die `${…}`-Verweise mit den Werten aus der `.env`. Als Host steht `mysql`, der Alias, den die `compose.yaml` über `links: db:mysql` vergibt.

```ini
# /opt/mautic/.mautic_env
MAUTIC_DB_HOST="mysql"
MAUTIC_DB_PORT="3306"
MAUTIC_DB_DATABASE="${MYSQL_DATABASE}"
MAUTIC_DB_USER="${MYSQL_USER}"
MAUTIC_DB_PASSWORD="${MYSQL_PASSWORD}"
MAUTIC_MESSENGER_DSN_EMAIL="doctrine://default"
MAUTIC_MESSENGER_DSN_HIT="doctrine://default"
PHP_INI_VALUE_DATE_TIMEZONE="{{tz}}"
```

`doctrine://default` legt die Warteschlangen in die MySQL-Datenbank; ein RabbitMQ ist damit nicht nötig. Ein `chown` der Ordner war im Test nicht nötig: Das Image legte `config/local.php` beim Start selbst mit dem Besitzer `www-data` an.

> **Prüfen:** `ls -a /opt/mautic` zeigt `.env`, `.mautic_env` und den Ordner `mautic`, `grep -c ZUFALLSPASSWORT .env` ergibt `0` (alle Platzhalter ersetzt).

## Schritt 2: compose.yaml erstellen

Gegenüber dem offiziellen Beispiel sind die Image-Tags festgelegt (dort `mysql:lts` und `mautic/mautic:latest`), Neustartregeln ergänzt und Mailpit hinzugefügt. Mailpit lauscht nur auf 127.0.0.1 und dient ausschließlich dem Test.

```yaml
x-mautic-volumes:
  &mautic-volumes
  - ./mautic/config:/var/www/html/config:z
  - ./mautic/logs:/var/www/html/var/logs:z
  - ./mautic/media/files:/var/www/html/docroot/media/files:z
  - ./mautic/media/images:/var/www/html/docroot/media/images:z

services:
  db:
    image: mysql:8.4.11
    environment:
      - MYSQL_ROOT_PASSWORD=${MYSQL_ROOT_PASSWORD}
      - MYSQL_DATABASE=${MYSQL_DATABASE}
      - MYSQL_USER=${MYSQL_USER}
      - MYSQL_PASSWORD=${MYSQL_PASSWORD}
    volumes:
      - mysql-data:/var/lib/mysql
    healthcheck:
      test: mysqladmin --user=$$MYSQL_USER --password=$$MYSQL_PASSWORD ping
      start_period: 5s
      interval: 5s
      timeout: 5s
      retries: 10
    restart: unless-stopped

  mautic_web:
    image: mautic/mautic:7.2.1-apache
    links:
      - db:mysql
    ports:
      - 8080:80
    volumes: *mautic-volumes
    environment:
      - DOCKER_MAUTIC_LOAD_TEST_DATA=${DOCKER_MAUTIC_LOAD_TEST_DATA}
    env_file:
      - .mautic_env
    healthcheck:
      test: curl http://localhost
      start_period: 5s
      interval: 5s
      timeout: 5s
      retries: 100
    depends_on:
      db:
        condition: service_healthy
    restart: unless-stopped

  mautic_cron:
    image: mautic/mautic:7.2.1-apache
    links:
      - db:mysql
    volumes: *mautic-volumes
    environment:
      - DOCKER_MAUTIC_ROLE=mautic_cron
    env_file:
      - .mautic_env
    depends_on:
      mautic_web:
        condition: service_healthy
    restart: unless-stopped

  mautic_worker:
    image: mautic/mautic:7.2.1-apache
    links:
      - db:mysql
    volumes: *mautic-volumes
    environment:
      - DOCKER_MAUTIC_ROLE=mautic_worker
    env_file:
      - .mautic_env
    depends_on:
      mautic_web:
        condition: service_healthy
    restart: unless-stopped

  mailpit:
    image: axllent/mailpit:v1.31.5
    ports:
      - "127.0.0.1:8025:8025"
    restart: unless-stopped

volumes:
  mysql-data:
```

Hinter einem Reverse Proxy auf demselben Server ändern Sie die Portzeile in `127.0.0.1:8080:80`, damit Mautic nur über den Proxy erreichbar ist.

> **Prüfen:** `docker compose config --quiet` endet ohne Ausgabe. `docker compose config | grep MAUTIC_DB_PASSWORD` zeigt Ihr Passwort statt eines leeren Werts.

## Schritt 3: Stack starten

```bash
$ docker compose pull
$ docker compose up -d
$ docker compose ps
```

Der Web-Container startet erst, wenn MySQL gesund ist; Cron und Worker warten wiederum auf den Web-Container. Vor der Installation schreibt der Cron-Container regelmäßig `Waiting for Mautic to be installed` ins Log. Das ist erwartet.

> **Prüfen:** Nach etwa einer Minute zeigt `docker compose ps` `db` und `mautic_web` als `healthy`, `mautic_cron`, `mautic_worker` und `mailpit` als `Up`. `curl -sI http://localhost:8080/ | grep -i location` verweist auf `/index.php/installer`.

## Schritt 4: Installationsassistent durchlaufen

Öffnen Sie `http://{{server_ip}}:8080`. Der Assistent prüft zuerst die Umgebung und meldet „Ready to Install!“. Im Datenbankschritt sind Treiber, Host `mysql`, Port, Datenbankname und Benutzer bereits aus `.mautic_env` vorbelegt. Das **Passwortfeld bleibt leer**: Ohne Eingabe bricht die Installation im Test mit `Access denied for user 'mautic'@… (using password: NO)` ab. Tragen Sie dort `MYSQL_PASSWORD` aus der `.env` ein.

![Mautic-Installationsassistent, Schritt Datenbank: Treiber MySQL PDO, Host mysql, Port 3306, Datenbank und Benutzer mautic, Passwortfeld leer](https://s-edv.com/uploads/2026/10/0396f1dac4799cead727be3a6af92f11c2f1b276c7d8b2c3de66e881a57cece4-1024.png)
*Datenbankschritt: Host, Port, Name und Benutzer kommen aus der Umgebung, das Passwort tragen Sie selbst ein.*

Im zweiten Schritt legen Sie den Administrator an. Verwenden Sie einen eigenen Benutzernamen statt `admin` und ein langes Passwort. Der Datenbankschritt dauert beim Anlegen der Tabellen ein bis zwei Minuten; danach leitet Mautic auf die Anmeldeseite.

![Mautic-Installationsassistent, Schritt Administrator: Benutzername, Passwort, Vorname, Nachname und E-Mail-Adresse](https://s-edv.com/uploads/2026/10/a68a232c577e5b7f778813096f39aa12396db114000debedbed88f7ef539cba6-1024.png)
*Administratorschritt: Benutzername, Passwort, Name und E-Mail-Adresse des ersten Kontos.*

Ohne Browser geht es auch per Konsole, wie im README des Docker-Repositorys beschrieben: `docker compose exec --user www-data --workdir /var/www/html mautic_web php ./bin/console mautic:install https://mautic.example.de --admin_email=… --admin_password=…`.

> **Prüfen:** Die Anmeldung mit dem neuen Konto öffnet das Dashboard, unten links steht `v7.2.1`. `docker compose exec --user www-data mautic_web php ./bin/console --version` meldet `Mautic 7.2.1`.

## Schritt 5: E-Mail-Versand mit Mailpit prüfen

Testen Sie den Versand zunächst gegen Mailpit, damit keine Testmail an echte Kontakte geht. Öffnen Sie über das Zahnrad **Configuration → Email Settings**. Tragen Sie unter **Email DSN** Schema `smtp`, Host `mailpit` und Port `1025` ein, darüber Absendername und Absenderadresse. Klicken Sie auf **Save** und danach auf **Send test email**: Der Test nutzt immer die gespeicherte DSN, nicht die gerade eingetippten Werte.

![Mautic-Einstellungen, Bereich Email DSN: Schema smtp, Host mailpit, Port 1025, darunter die gespeicherte DSN smtp://mailpit:1025](https://s-edv.com/uploads/2026/10/800e3cc9ad073442e428984af58f205102bb91e7ccdc4aee6bffdf1984b27aae-1024.png)
*Email DSN mit Mailpit als Ziel; die Zeile unter der Schaltfläche zeigt die gespeicherte Verbindung.*

Die Testmail geht an die Adresse des angemeldeten Benutzers. Sie sehen sie in der Mailpit-Oberfläche unter `http://127.0.0.1:8025` auf dem Server (per SSH-Tunnel: `ssh -L 8025:127.0.0.1:8025 server`). Für den Echtbetrieb ersetzen Sie Host, Port, Benutzer und Passwort durch die Daten Ihres Versanddienstes (meist Port 587 mit STARTTLS) und entfernen den Dienst `mailpit` aus der `compose.yaml`. Hintergrund zu Mailpit: [Mailpit per Docker Compose einrichten](https://s-edv.com/anleitungen/mailpit-docker-compose-smtp-testserver-einrichten).

> **Prüfen:** `curl -s http://127.0.0.1:8025/api/v1/messages | grep -o '"Subject":"[^"]*"'` liefert `"Subject":"Mautic test email"`. Im Test kam die Mail mit dem eingetragenen Absender an.

## Schritt 6: Cron und Worker prüfen

Ohne Cron aktualisiert Mautic keine Segmente und führt keine Kampagnen aus. Der Cron-Container bringt einen vorkonfigurierten Zeitplan mit: Segmente zu den Minuten 0, 15, 30 und 45, Kampagnen 5 Minuten später, Trigger weitere 5 Minuten später. Der Worker-Container verarbeitet die Warteschlangen für E-Mails, Seitenaufrufe und fehlgeschlagene Nachrichten mit je zwei Prozessen (`DOCKER_MAUTIC_WORKERS_CONSUME_*`).

```bash
$ docker compose exec mautic_cron cat /opt/mautic/cron/mautic
$ docker compose logs --tail 5 mautic_worker
$ docker compose exec --user www-data --workdir /var/www/html mautic_web php ./bin/console mautic:segments:update
```

Eigene Zeitpläne binden Sie über einen Ordner `./cron` nach `/opt/mautic/cron` ein (im offiziellen Beispiel als auskommentierte Zeile vorbereitet).

> **Prüfen:** Der erste Befehl zeigt die Crontab mit `mautic:segments:update`, `mautic:campaigns:update` und `mautic:campaigns:trigger`. Das Worker-Log enthält `Quit the worker with CONTROL-C`, und der manuelle Segmentlauf endet mit Exit-Code 0.

## Schritt 7: Backup und Wiederherstellung

Zu sichern sind die Datenbank (Kontakte, Kampagnen, E-Mails) und der Ordner `mautic` (`config/local.php` mit Zugangsdaten und Geheimschlüssel, hochgeladene Medien) samt `.env`, `.mautic_env` und `compose.yaml`:

```bash
$ cd /opt/mautic && mkdir -p backup
$ docker compose exec -T db sh -c 'exec mysqldump --single-transaction --no-tablespaces -u"$MYSQL_USER" -p"$MYSQL_PASSWORD" "$MYSQL_DATABASE"' | gzip > backup/mautic-db-$(date +%F).sql.gz
$ sudo tar czf backup/mautic-files-$(date +%F).tar.gz mautic .env .mautic_env compose.yaml
```

Wiederherstellung auf einem leeren Host: Dateiarchiv entpacken, nur die Datenbank starten, den Dump einspielen, dann den Rest starten. Warten Sie nach dem ersten Start von MySQL, bis im Log `ready for connections` mit `port: 3306` steht. Im Test schlug ein Import direkt nach dem ersten `healthy` fehl, weil MySQL zu diesem Zeitpunkt noch seine Erstinitialisierung abschloss; der zweite Versuch lief sauber durch.

```bash
$ sudo tar xzf backup/mautic-files-DATUM.tar.gz
$ docker compose up -d db
$ docker compose logs db | grep "port: 3306"
$ gunzip -c backup/mautic-db-DATUM.sql.gz | docker compose exec -T db sh -c 'exec mysql -u"$MYSQL_USER" -p"$MYSQL_PASSWORD" "$MYSQL_DATABASE"'
$ docker compose up -d
```

Im Test wurde ein Kontakt mit einer Marker-Adresse angelegt, gesichert, der gesamte Stack samt Volume und Ordner `mautic` gelöscht und wiederhergestellt. Danach startete Mautic direkt ins Dashboard statt in den Installer, die Anmeldung funktionierte, der Kontakt war in der Kontaktliste vorhanden und die SMTP-Einstellung erhalten.

> **Prüfen:** `` gunzip -c backup/mautic-db-DATUM.sql.gz | grep -c "INSERT INTO \`leads\`" `` ist größer null. Nach einer Wiederherstellung leitet `curl -sI http://localhost:8080/` auf `/s/dashboard` statt auf den Installer, und die Kontaktsuche findet einen bekannten Kontakt. Mehr zur Ablage außerhalb des Servers: [3-2-1-Backup-Strategie praktisch umsetzen](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen).

## Schritt 8: Updates einspielen

Sichern Sie wie in Schritt 7. Ändern Sie dann den Tag aller drei Mautic-Dienste in der `compose.yaml` auf die neue Version aus den [Release Notes](https://github.com/mautic/mautic/releases), etwa mit `sed -i 's/7.2.1-apache/NEUE-VERSION-apache/' compose.yaml`, und starten Sie neu:

```bash
$ docker compose pull
$ docker compose up -d
$ docker compose logs mautic_web | grep -i migration
```

Laut Startskript des Images führt der Web-Container bei einer bestehenden Installation beim Start `doctrine:migrations:migrate` aus. Springen Sie nicht über Hauptversionen hinweg, sondern folgen Sie dem Upgrade-Pfad in der Mautic-Dokumentation. MySQL aktualisieren Sie getrennt und nur innerhalb von 8.4.

> **Prüfen:** `docker compose exec --user www-data mautic_web php ./bin/console --version` zeigt die neue Version, alle Dienste laufen, und das Log enthält keine Fehler aus den Migrationen.

## Typische Fehler

**„Access denied … (using password: NO)“ im Installer**

Das Passwortfeld im Datenbankschritt wurde leer gelassen. Passwort aus der `.env` eintragen.

**Testmail kommt nicht an**

Die Einstellungen wurden vor dem Test nicht gespeichert; der Test nutzt die gespeicherte DSN, die unter der Schaltfläche angezeigt wird.

**Cron-Log meldet dauerhaft „Waiting for Mautic to be installed“**

Die Installation ist nicht abgeschlossen oder `config/local.php` fehlt im eingebundenen Ordner.

**„mkfifo: cannot create fifo '/tmp/stdout': File exists“**

nach einem Neustart des Cron-Containers: Im Test blieb Cron trotzdem aktiv (`cron -f` lief). Bei Zweifeln den Container mit `docker compose up -d --force-recreate mautic_cron` neu erzeugen.

**Restore: Importfehler direkt nach dem Start**

MySQL war noch in der Erstinitialisierung. Auf `port: 3306` im Log warten und erneut importieren.

**Kampagnen laufen nicht**

`mautic_cron` oder `mautic_worker` gestoppt. `docker compose ps` prüfen.

## Häufige Fragen

### Warum drei Mautic-Container?

Alle nutzen dasselbe Image, die Variable `DOCKER_MAUTIC_ROLE` legt die Aufgabe fest. So lassen sich Web, Zeitplan und Warteschlangen getrennt neu starten und skalieren.

### Geht PostgreSQL oder MariaDB?

Das offizielle Docker-Beispiel und der Installer setzen auf MySQL (Treiber MySQL PDO). Diese Anleitung bleibt deshalb bei MySQL 8.4; andere Datenbanken prüfen Sie vorab gegen die Systemanforderungen der eingesetzten Mautic-Version.

### Brauche ich RabbitMQ?

Nein. Mit `doctrine://default` liegen die Warteschlangen in MySQL. Für sehr große Versandmengen gibt es im Repository das Beispiel `rabbitmq-worker`.

### Wie binde ich HTTPS an?

Über einen Reverse Proxy wie [Traefik mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten) oder Nginx Proxy Manager. Tragen Sie danach unter **Configuration → System Settings** die öffentliche HTTPS-Adresse als Site URL ein, sonst enthalten Tracking-Links und E-Mails die interne Adresse.

### Lassen sich Demodaten laden?

Ja, mit `DOCKER_MAUTIC_LOAD_TEST_DATA=true` vor der ersten Installation. Das Startskript installiert dann eine Demo-Instanz mit Beispieldaten; für den Produktivbetrieb bleibt der Wert auf `false`.

## Fazit

Mit dem offiziellen Compose-Beispiel, festgelegten Tags und den drei Rollen-Containern steht Mautic in rund einer halben Stunde. Zwei Stellen kosten im Alltag Zeit: das leere Datenbankpasswort im Installer und der Mailtest, der nur gespeicherte Einstellungen nutzt. Wer den Versand erst gegen Mailpit prüft, regelmäßig Dump und Ordner sichert und die Wiederherstellung einmal durchspielt, betreibt die Marketing-Automation mit überschaubarem Aufwand selbst. Für einfache Newsletter ohne Kampagnenlogik ist [Listmonk](https://s-edv.com/anleitungen/listmonk-docker-newsletter-server) die schlankere Alternative.

## Weiterführende Anleitungen und Quellen

- [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
- [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
- [Mailpit per Docker Compose einrichten](https://s-edv.com/anleitungen/mailpit-docker-compose-smtp-testserver-einrichten)
- [Docker Compose absichern: Secrets, Healthchecks, Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)
- [Offizielles Beispiel examples/basic (mautic/docker-mautic)](https://github.com/mautic/docker-mautic/tree/main/examples/basic)
- [docker-mautic: README mit Umgebungsvariablen und Konsolenbefehlen](https://github.com/mautic/docker-mautic)
- [mautic/mautic auf Docker Hub](https://hub.docker.com/r/mautic/mautic)
- [Mautic-Dokumentation](https://docs.mautic.org)

## Passende Anleitungen auf S-EDV

1. [netcup Local Block Storage bestellen, einrichten und unter Linux einbinden](https://s-edv.com/anleitungen/netcup-local-block-storage-bestellen-linux-einbinden)