---
title: "Apache Answer mit Docker installieren: Q&A-Community-Plattform im Stack-Overflow-Stil"
date: 2026-07-05T06:56:16+02:00
modified: 2026-11-08T21:18:38+01:00
category: netzwerk
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/apache-answer-docker-qa-plattform
reading_time: 9
personalize_url: "https://s-edv.com/anleitungen/apache-answer-docker-qa-plattform#domain={domain}"
variables:
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
---

# Apache Answer mit Docker installieren: Q&A-Community-Plattform im Stack-Overflow-Stil

## 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 |
| --- | --- | --- |
| `{{domain}}` | Ihre Domain | `example.com` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/apache-answer-docker-qa-plattform#domain=cloud.example.com

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.

Wer intern Wissen strukturiert sammeln will, etwa als IT-FAQ, Entwickler-Wissensdatenbank oder Support-Helpdesk, braucht mehr als ein Wiki. **Apache Answer** ist eine Q&A-Plattform im Stil von Stack Overflow, entwickelt von der Apache Software Foundation: Fragen stellen, antworten, abstimmen, taggen und suchen. Das Backend ist in Go geschrieben, das Docker-Image rund 58 MB groß. Diese Anleitung installiert Apache Answer per Docker Compose auf einem Linux-Host, von der `compose.yaml` bis zum abgeschlossenen Setup-Wizard.

**Kurzfassung:** Sie erstellen unter `/opt/answer/` eine `compose.yaml` mit dem Image `apache/answer:2.0.2`, starten den Container per `docker compose up -d` und rufen `http://localhost:9080/install` im Browser auf. Der Setup-Wizard richtet Datenbank (Standard: SQLite), Admin-Konto und Site-URL ein. Alle Daten liegen im Named Volume `answer-data`, das Sie deshalb regelmäßig sichern. Für den Produktivbetrieb schalten Sie einen Reverse Proxy vor und nutzen MySQL oder PostgreSQL statt SQLite.

## Voraussetzungen

- [ ] **Docker Engine 20.10+** und **Docker Compose V2** (Befehl `docker compose`, nicht das veraltete `docker-compose`). Noch nicht installiert? Siehe [Docker und Docker Compose auf Linux installieren](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage).
- [ ] Linux-Host, VM oder NAS mit Docker-Unterstützung (Ubuntu, Debian, Raspberry Pi OS, Synology DSM 7 mit Container Manager o.ä.). Unterstützte Architekturen: `linux/amd64` und `linux/arm64`.
- [ ] Mindestens **512 MB RAM** (1 GB empfohlen), mindestens 1 GB freier Speicherplatz.
- [ ] Internetverbindung für den Image-Pull (ca. 58 MB).
- [ ] Für den Produktivbetrieb mit eigener Domain: ein Reverse Proxy mit TLS. Siehe [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten).
- [ ] Optional: SMTP-Zugangsdaten für E-Mail-Benachrichtigungen (werden später im Admin-Panel konfiguriert).

## Eckdaten im Überblick

| Parameter | Wert | Hinweis |
| --- | --- | --- |
| Image | `apache/answer:2.0.2` | Stabile Version (Juli 2026), `:latest` zeigt derzeit darauf |
| Architekturen | amd64, arm64 | Alle stabilen Tags ab 1.5.1 |
| Image-Größe | ca. 58 MB | Single-Container, kein externer DB-Service nötig |
| Host-Port (Standard) | 9080 | Frei wählbar; Container-intern immer Port 80 |
| Volume | `answer-data:/data` | Config, SQLite-DB, Uploads, Logs: niemals löschen! |
| Env-Variable | `INSTALL_PORT=80` | Optional; gibt den internen Installer-Port an |
| Setup-Wizard | `/install` | Zwingend erforderlich beim ersten Start |
| Lizenz | Apache 2.0 | Open Source, Apache Software Foundation |

## Schritt 1: Projektordner anlegen

Legen Sie einen eigenen Ordner für den Stack an. `/opt/answer/` eignet sich für systemweite Instanzen; im Home-Verzeichnis (`~/answer/`) reicht es für einzelne Nutzer:

```bash
$ sudo mkdir -p /opt/answer
$ cd /opt/answer
```

Der Ordner muss nur die `compose.yaml` enthalten: alle persistenten Daten speichert Docker im Named Volume `answer-data` automatisch unter `/var/lib/docker/volumes/`.

> **Prüfen:** `ls -la /opt/answer/` zeigt den leeren Ordner ohne Fehlermeldung. Der aktuelle Benutzer muss Schreibrechte haben, falls nicht: `sudo chown $USER /opt/answer`.

## Schritt 2: compose.yaml erstellen

Erstellen Sie die Datei `/opt/answer/compose.yaml`. Für den Einstieg braucht Apache Answer keinen eigenen Datenbank-Dienst:

Datei: `/opt/answer/compose.yaml`

```yaml
services:
  answer:
    image: apache/answer:2.0.2
    container_name: answer
    restart: on-failure
    ports:
      - "9080:80"
    volumes:
      - answer-data:/data

volumes:
  answer-data:
```

Der Wert `restart: on-failure` entspricht dem offiziellen Image-Standard. Er bedeutet, dass der Container nach einem Absturz neu startet, aber *nicht* automatisch nach einem bewussten `docker compose down`. Für den Dauerbetrieb stellen Sie das auf `restart: unless-stopped` um. Der Host-Port `9080` lässt sich beliebig anpassen, zum Beispiel auf `8090:80` falls 9080 bereits belegt ist.

> **Prüfen:** `cat /opt/answer/compose.yaml` zeigt die Datei fehlerfrei. Optionaler Syntax-Check im Ordner: `docker compose config`: die normalisierte YAML wird ohne Fehlermeldung ausgegeben.

## Schritt 3: Container starten

Starten Sie den Stack im Projektordner:

```bash
$ cd /opt/answer
$ docker compose up -d
```

Docker lädt das Image herunter (ca. 58 MB beim ersten Mal) und startet den Container im Hintergrund. Das Named Volume `answer-data` wird automatisch angelegt.

> Prüfen Sie den Status direkt nach dem Start:
>
> ```bash
> $ docker compose ps
> ```

Erwartete Ausgabe (gekürzt):

Ausgabe:

```plaintext
NAME      IMAGE                    SERVICE   STATUS    PORTS
answer    apache/answer:2.0.2      answer    Up        0.0.0.0:9080->80/tcp
```

Zeigt die Spalte `STATUS` den Wert `Up`, läuft der Container. Meldet `docker compose up` „port is already allocated“, ist Port 9080 belegt. Lösung: Port in der `compose.yaml` ändern und `docker compose up -d` erneut ausführen.

Ergänzend prüfen Sie per HTTP, ob der Installer antwortet:

```bash
$ curl -s http://localhost:9080/installation/config-file/check
```

Erwartet vor dem Setup: JSON mit `"config_file_exist":false`. Hinweis: `curl -I` (HEAD-Anfrage) liefert eine Weiterleitung auf `/50x`, das ist kein Fehler.

## Schritt 4: Setup-Wizard abschließen

Dieser Schritt ist zwingend erforderlich. Ohne abgeschlossenen Wizard ist Apache Answer nicht nutzbar und zeigt beim Aufruf der Startseite Fehler an.

Öffnen Sie im Browser:

```bash
http://localhost:9080/install
```

Der Wizard führt durch vier Schritte:

1. **Sprache wählen**: Deutsch ist verfügbar.
2. **Datenbankverbindung konfigurieren:** Für den Einstieg und kleine Teams wählen Sie *SQLite*; die Datenbankdatei liegt dann unter `/data/answer.db` im Volume. Für den Produktivbetrieb mit mehreren gleichzeitigen Nutzern wählen Sie *MySQL 8+* oder *PostgreSQL 14+* und geben Sie die Verbindungsdaten Ihrer Datenbank ein.
3. **Site-Grunddaten:** Name der Community, Site-URL (die URL, unter der Answer dauerhaft erreichbar ist, z. B. `https://qa.{{domain}}`; eine spätere Änderung erfordert einen manuellen Eingriff in `/data/conf/config.yaml`), Admin-E-Mail und Passwort.
4. **Fertig:** Der Wizard speichert alles in `/data/conf/config.yaml` und leitet auf die Startseite weiter.

Danach melden Sie sich unter `http://localhost:9080` mit den Admin-Zugangsdaten an und nehmen unter */admin* weitere Einstellungen vor (SMTP, Tags, Benutzerrollen).

> **Prüfen:** Die Startseite zeigt das Answer-Interface ohne Fehlermeldung. Login mit Admin-Zugangsdaten funktioniert. Logs prüfen:
>
> ```bash
> $ docker compose logs --tail=20 answer
> ```

Erwartete Ausgabe: Zeilen mit `INFO`-Level, kein `FATAL` oder `ERROR` bezüglich Datenbank oder Konfiguration.

## Schritt 5: Reverse Proxy und HTTPS einrichten (Produktivbetrieb)

Für den internen Laborbetrieb reicht HTTP auf Port 9080. Ist Answer aus dem Internet erreichbar, brauchen Sie einen Reverse Proxy mit TLS.

Binden Sie den Container-Port nur an `127.0.0.1`, damit er nicht direkt von außen erreichbar ist:

```yaml
ports:
  - "127.0.0.1:9080:80"
```

Schalten Sie Traefik, Caddy oder Nginx davor, siehe [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten). Setzen Sie im Setup-Wizard (oder nachträglich in `/data/conf/config.yaml`) die Site-URL auf die öffentliche Domain, z. B. `https://qa.{{domain}}`.

> **Prüfen:** Nach Reverse-Proxy-Konfiguration: `curl -I https://qa.{{domain}}` liefert `HTTP/2 200`. Das Schloss-Symbol im Browser zeigt ein gültiges TLS-Zertifikat. Interne Links in Answer (E-Mail-Benachrichtigungen, Bild-URLs) verwenden die korrekte Domain.

## Schritt 6: Backup und Update

### Daten sichern

Das gesamte Named Volume `answer-data` enthält alle persistenten Daten: Konfiguration, SQLite-Datenbank (falls gewählt), Uploads und Logs. Ein vollständiges Backup erstellen Sie mit:

```bash
docker run --rm \
  -v answer-data:/data \
  -v /backup:/backup \
  alpine \
  tar czf /backup/answer-$(date +%Y%m%d).tar.gz /data
```

Ersetzen Sie `/backup` durch Ihren Backup-Pfad. Compose stellt dem Volume-Namen den Projektnamen voran (hier `answer_answer-data`); prüfen Sie ihn mit `docker volume ls`. Stoppen Sie bei SQLite vorher den Container mit `docker compose stop`. Bei MySQL oder PostgreSQL erstellen Sie zusätzlich einen Datenbank-Dump. Zur Automatisierung eignet sich ein Cron-Job, eingebettet in eine Backup-Strategie wie in [3-2-1-Backup-Strategie umsetzen](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen) beschrieben.

> **Prüfen:** `tar tzf /backup/answer-*.tar.gz | head` listet `data/answer.db` und `data/conf/config.yaml`.

### Update auf eine neue Version

Das Update läuft in drei Befehlen: die Datenmigration erfolgt automatisch beim Container-Neustart. Passen Sie vorher das Image-Tag in der `compose.yaml` auf die neue Version an (z. B. auf die nächste Version laut Docker Hub):

```bash
$ cd /opt/answer
$ docker compose pull
$ docker compose down
$ docker compose up -d
```

> **Wichtig:** Sichern Sie vor jedem Update das Volume.

> **Prüfen:** `docker compose ps` zeigt den Container im Status `Up`. `docker compose logs --tail=30 answer` zeigt keine Migrationsfehler. Die Weboberfläche ist erreichbar und die Admin-Anmeldung funktioniert.

## Troubleshooting / Typische Fehler

**Container startet nicht, „port is already allocated“**

Port 9080 ist belegt. Prüfen Sie mit `ss -tlnp | grep 9080`, welcher Prozess den Port nutzt. Lösung: Port in der `compose.yaml` ändern (z. B. `8090:80`) und `docker compose up -d` erneut ausführen.

**Browser zeigt Fehler statt Setup-Wizard**

Vor Abschluss des Wizards leitet die Startseite auf `/50x` um. Rufen Sie `http://localhost:9080/install` auf und schließen Sie den Wizard ab.

**Nach Update sind alle Daten weg**

Das Volume `answer-data` wurde versehentlich mit `docker compose down -v` gelöscht. Das Flag `-v` entfernt Named Volumes: niemals verwenden, solange Sie die Daten brauchen. Ohne Backup sind die Daten nicht wiederherstellbar.

**Site-URL falsch gesetzt, interne Links zeigen auf falsche Domain**

Lesen Sie `/data/conf/config.yaml` im Volume aus: `docker run --rm -v answer-data:/data alpine cat /data/conf/config.yaml`. Passen Sie `site_url` an und starten Sie danach `docker compose restart answer`.

**ARM64 (Raspberry Pi, Apple Silicon): Container startet nicht**

Vermutlich nutzen Sie den `:test`-Tag, der nur für amd64 existiert. Verwenden Sie stabile Tags wie `:2.0.2` oder `:latest`. Diese unterstützen beide Architekturen.

**E-Mail-Benachrichtigungen funktionieren nicht**

SMTP muss nach dem Wizard-Abschluss im Admin-Panel unter *Admin → E-Mail* konfiguriert werden. Prüfen Sie dort Hostname, Port (587 oder 465), Benutzername und Passwort Ihres SMTP-Dienstes.

**Plugin lässt sich nicht aktivieren**

Apache Answer lädt Plugins nicht dynamisch nach. Ein neues Image muss mit dem gewünschten Plugin kompiliert werden (`answer build --with github.com/apache/answer-plugins/[plugin-name]`). Dieses eigene Image ersetzt dann `apache/answer:2.0.2` in der `compose.yaml`.

## Häufige Fragen

### Welche Datenbank soll ich wählen?

Für erste Tests, kleine Teams oder den internen Einsatz mit wenigen gleichzeitigen Nutzern ist **SQLite** ausreichend. Rechnen Sie mit mehr als zehn gleichzeitigen Nutzern oder hoher Schreiblast, nehmen Sie **MySQL 8+** oder **PostgreSQL 14+**. Diese Datenbanken konfigurieren Sie im Setup-Wizard; die Verbindungsdaten werden in `/data/conf/config.yaml` gespeichert.

### Kann ich Answer hinter Traefik oder Nginx betreiben?

Ja. Binden Sie den Port an `127.0.0.1:9080:80`, leiten Sie den Reverse Proxy auf diesen Port und setzen Sie die Site-URL auf die öffentliche HTTPS-Domain (siehe Schritt 5).

### Wie läuft das Upgrade ab?

Volume sichern, Image-Tag in der `compose.yaml` anpassen, dann `docker compose pull && docker compose down && docker compose up -d`. Die Migration läuft beim ersten Start des neuen Containers automatisch.

### Wie installiere ich Plugins?

Plugins können nicht per Klick nachinstalliert werden. Da das Backend in Go (statisch kompiliert) geschrieben ist, bauen Sie ein eigenes Docker-Image: Ein `Dockerfile`, das `FROM apache/answer` erweitert und `RUN answer build --with github.com/apache/answer-plugins/[plugin-name]` ausführt. Dieses Image tragen Sie statt des offiziellen in die `compose.yaml` ein.

### Wie sichere ich alle Daten zuverlässig?

Das Named Volume `answer-data` enthält alles: Config, Datenbank, Uploads. Das oben gezeigte `docker run ... alpine tar czf ...`-Kommando packt das gesamte Volume in ein komprimiertes Archiv. Automatisieren Sie ihn als Cron-Job. Bei MySQL oder PostgreSQL ergänzen Sie einen regulären Datenbank-Dump per `mysqldump` oder `pg_dump`.

### Was passiert, wenn ich die Site-URL später ändern muss?

Die beim Wizard eingetragene URL ist in `/data/conf/config.yaml` gespeichert. Bearbeiten Sie die Datei über einen temporären Alpine-Container mit eingebundenem Volume und starten Sie Answer neu. Alle internen Links, E-Mail-Benachrichtigungen und OAuth-Callbacks verwenden danach die neue URL.

## Fazit

Apache Answer ist eine schlanke Open-Source-Alternative zu kommerziellen Q&A- und Helpdesk-Lösungen: ein Container mit rund 58 MB, eingerichtet über einen Setup-Wizard im Browser. Für kleine Teams und interne Wissensdatenbanken genügt SQLite; größere Installationen wählen im Wizard PostgreSQL oder MySQL. Entscheidend ist das Volume `answer-data`: Es enthält Konfiguration, Datenbank und Uploads und gehört ins regelmäßige Backup. Mit Reverse Proxy und den Härtungsschritten aus [Docker Compose absichern: Secrets, Healthchecks und Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root) ist der Stack für den Produktivbetrieb vorbereitet.

## Weiterführende Anleitungen und Quellen

1. [Docker und Docker Compose auf Linux installieren: die Self-Hosting-Grundlage](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage)
2. [Traefik als Docker-Reverse-Proxy mit automatischem HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
3. [3-2-1-Backup-Strategie umsetzen: Anleitung mit Restic, USB-Disk und S3-Cloud](https://s-edv.com/anleitungen/3-2-1-backup-strategie-praktisch-umsetzen)
4. [Docker Compose absichern: Secrets, Healthchecks, Non-Root und Read-Only für den Produktivbetrieb](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root)

Offizielle Quellen: [Apache Answer Installationsdokumentation](https://answer.apache.org/docs/installation), [GitHub-Repository apache/answer](https://github.com/apache/answer), [Docker Hub apache/answer](https://hub.docker.com/r/apache/answer/tags), [Upgrade-Dokumentation](https://answer.apache.org/docs/upgrade).

## Passende Anleitungen auf S-EDV

1. [PCI DSS 4.0.1: Checkout-Skripte als Sicherheitsrisiko: was Admins jetzt prüfen](https://s-edv.com/news/pci-dss-checkout-skripte-admin-pflicht)
2. [WordPress-Sicherheit: Plugin-Risiken brauchen feste Update- und Prüfprozesse](https://s-edv.com/news/wordpress-plugin-risiken-update-pruefprozess)
3. [OpenSSL: Neun Schwachstellen im Sicherheitsrelease vom 9. Juni 2026, darunter Hi](https://s-edv.com/news/openssl-9-schwachstellen-juni-2026-patch-pkcs7)
