Docs: tested single-host install, NPM integration, installer --docker
- README: step-by-step installation of web UI and agent on one host, exactly as tested (agent after keygen, all "run" helpers before "up -d", http PUBLIC_URL and TRUSTED_PROXY_HOPS=0 without a proxy) - README: attach to an existing Nginx Proxy Manager in Docker – shared network via docker-compose.override.yaml, no published port, gw_priority so SSH to the agent keeps the source address of the own network (otherwise from= rejects it), TLS settings, test - install.sh --docker: the new manual jail bans in INPUT and DOCKER-USER - Running container: helpers via "docker compose exec … python -m webui" (run fails with "Address already in use"); troubleshooting entries Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
schiwagoaandClaude Opus 5.5 committed
1 parent
d03aa6f0d2
commit
b36499bbf5
8 files changed
+303
-26
No files matched your search
+3
-1
@@ -13,7 +13,8 @@ First public version, generalised from a private single-site tool.
|
||||
- English and German UI with a language dropdown; new languages via `locales/xx.json`
|
||||
- Optional Loki history, Grafana links and GeoIP (DB-IP Lite auto-download)
|
||||
- Origin map: banned IPs as points on a world map (bundled, no external tiles); click filters the list
|
||||
- CLI: `hash-password`, `keygen`, `keyscan`, `check`
|
||||
- CLI: `hash-password`, `keygen`, `keyscan`, `check` (`docker compose exec … python -m webui …` while running)
|
||||
- GeoIP download sends its own user agent (db-ip.com rejects Python's default with 403)
|
||||
- Hardened image: non-root, read-only root filesystem, no pip/setuptools at runtime,
|
||||
SSH client ignores the system ssh_config and never uses GSSAPI
|
||||
- Log lines (`LOGIN_FAILED user=… ip=…`) are safe for fail2ban: user-controlled values
|
||||
@@ -24,3 +25,4 @@ First public version, generalised from a private single-site tool.
|
||||
- Error codes for translated messages, `version` command, fallback for fail2ban without `--with-time`
|
||||
- `install.sh` / `uninstall.sh`: dedicated user with sudo rule (or root), `from=` restriction,
|
||||
custom authorized_keys file, optional manual jail, backups, dry run, self test
|
||||
- `install.sh --docker`: manual jail bans in INPUT and DOCKER-USER (published Docker ports)
|
||||
@@ -74,40 +74,278 @@ danach den Container neu starten).
|
||||
|
||||
### fail2ban-Hosts (Agent)
|
||||
|
||||
- fail2ban ≥ 0.11 (Start-/Endzeiten der Sperren brauchen `--with-time`)
|
||||
- `sudo` für den Standardbenutzer `f2bweb`; mit einem root-Schlüssel nicht nötig
|
||||
- `bash`, `ssh-keygen` (Teil von OpenSSH) für den Installer
|
||||
|
||||
## Installation auf einem Host
|
||||
|
||||
Weboberfläche und Agent auf demselben Docker-Host – so getestet auf Ubuntu 26.04 (LXC).
|
||||
Weitere fail2ban-Hosts kommen später nur mit dem Agenten dazu ([docs/agent.md](docs/agent.md)).
|
||||
Im Beispiel hat der Host die LAN-Adresse `192.168.1.10` – überall durch deine ersetzen.
|
||||
|
||||
### fail2ban vorbereiten
|
||||
|
||||
```bash
|
||||
apt install -y fail2ban python3 sudo openssh-server
|
||||
```
|
||||
|
||||
```bash
|
||||
systemctl enable --now fail2ban
|
||||
```
|
||||
|
||||
```bash
|
||||
fail2ban-client ping # Server replied: pong
|
||||
```
|
||||
|
||||
- fail2ban ≥ 0.11 (Start-/Endzeiten der Sperren brauchen `--with-time`)
|
||||
- `sudo` nur für den Standardbenutzer `f2bweb`; mit einem root-Schlüssel nicht nötig
|
||||
- `bash`, `ssh-keygen` (Teil von OpenSSH) für den Installer
|
||||
### Quellen holen
|
||||
|
||||
## Schnellstart
|
||||
```bash
|
||||
git clone https://git.retronerd.at/schiwagoa/fail2ban-webui.git /opt/fail2ban-webui-src
|
||||
```
|
||||
|
||||
Voraussetzungen siehe oben (Grundpakete, Docker, Agent auf den fail2ban-Hosts).
|
||||
### Weboberfläche einrichten
|
||||
|
||||
```bash
|
||||
mkdir -p /opt/fail2ban-webui/{config,data} && cd /opt/fail2ban-webui
|
||||
curl -fsSLo docker-compose.yaml https://git.retronerd.at/schiwagoa/fail2ban-webui/raw/branch/main/examples/docker-compose.yaml
|
||||
curl -fsSLo .env https://git.retronerd.at/schiwagoa/fail2ban-webui/raw/branch/main/examples/.env.example
|
||||
curl -fsSLo config/hosts.yaml https://git.retronerd.at/schiwagoa/fail2ban-webui/raw/branch/main/examples/hosts.yaml.example
|
||||
chown -R 10050:10050 data
|
||||
```
|
||||
|
||||
```bash
|
||||
docker compose run --rm -it fail2ban-webui hash-password # Zeile in die .env übernehmen
|
||||
nano .env # PUBLIC_URL, Hash, DEFAULT_LANG=de …
|
||||
docker compose run --rm fail2ban-webui keygen # öffentlicher Schlüssel für die Agenten
|
||||
# auf jedem fail2ban-Host den Agenten installieren (docs/agent.md), danach:
|
||||
nano config/hosts.yaml # Beispiel-Hosts durch deine ersetzen!
|
||||
curl -fsSLo docker-compose.yaml https://git.retronerd.at/schiwagoa/fail2ban-webui/raw/branch/main/examples/docker-compose.yaml
|
||||
```
|
||||
|
||||
```bash
|
||||
curl -fsSLo .env https://git.retronerd.at/schiwagoa/fail2ban-webui/raw/branch/main/examples/.env.example
|
||||
```
|
||||
|
||||
Der Container läuft als UID 10050 und muss in `data/` schreiben:
|
||||
|
||||
```bash
|
||||
chown -R 10050:10050 data && chmod 700 data
|
||||
```
|
||||
|
||||
Für den Zugriff direkt im LAN (ohne Reverse Proxy) den Port an die LAN-Adresse binden –
|
||||
hinter einem Nginx Proxy Manager diesen Schritt [weglassen](#hinter-einem-vorhandenen-nginx-proxy-manager-docker):
|
||||
|
||||
```bash
|
||||
sed -i 's/"127.0.0.1:8080:8080"/"192.168.1.10:8080:8080"/' docker-compose.yaml
|
||||
```
|
||||
|
||||
Adresse, Sprache und Proxy-Einstellung setzen. Ohne TLS muss `PUBLIC_URL` mit `http://`
|
||||
beginnen, sonst schickt der Browser das Sitzungs-Cookie nicht mit; ohne Proxy gehört
|
||||
`TRUSTED_PROXY_HOPS` auf `0`:
|
||||
|
||||
```bash
|
||||
sed -i -e 's|^PUBLIC_URL=.*|PUBLIC_URL=http://192.168.1.10:8080|' -e 's|^DEFAULT_LANG=.*|DEFAULT_LANG=de|' -e 's|^TRUSTED_PROXY_HOPS=.*|TRUSTED_PROXY_HOPS=0|' .env
|
||||
```
|
||||
|
||||
Passwort-Hash erzeugen (mindestens 12 Zeichen, zweimal eingeben):
|
||||
|
||||
```bash
|
||||
docker compose run --rm -it fail2ban-webui hash-password
|
||||
```
|
||||
|
||||
Die ausgegebene Zeile `AUTH_PASSWORD_HASH='scrypt:…'` kopieren und in der `.env` die Zeile
|
||||
`AUTH_PASSWORD_HASH='scrypt:...'` damit ersetzen – die einfachen Anführungszeichen bleiben:
|
||||
|
||||
```bash
|
||||
nano .env
|
||||
```
|
||||
|
||||
SSH-Schlüssel der Weboberfläche erzeugen:
|
||||
|
||||
```bash
|
||||
docker compose run --rm fail2ban-webui keygen
|
||||
```
|
||||
|
||||
### Agent installieren
|
||||
|
||||
Probelauf – zeigt nur, was passieren würde. `172.23.51.10` ist die feste Adresse der
|
||||
Weboberfläche in ihrem Docker-Netz:
|
||||
|
||||
```bash
|
||||
bash /opt/fail2ban-webui-src/agent/install.sh --key-file /opt/fail2ban-webui/data/ssh/id_ed25519.pub --from 172.23.51.10 --dry-run
|
||||
```
|
||||
|
||||
Installieren und mit `y` bestätigen – am Ende meldet der Selbsttest
|
||||
`2 jails, 0 bans: manual-block, sshd`. Laufen auf dem Host weitere Docker-Dienste mit
|
||||
veröffentlichten Ports (z. B. ein Nginx Proxy Manager), zusätzlich `--docker` anhängen,
|
||||
damit manuelle Sperren auch dort greifen:
|
||||
|
||||
```bash
|
||||
bash /opt/fail2ban-webui-src/agent/install.sh --key-file /opt/fail2ban-webui/data/ssh/id_ed25519.pub --from 172.23.51.10
|
||||
```
|
||||
|
||||
### Host eintragen und testen
|
||||
|
||||
```bash
|
||||
cat > config/hosts.yaml <<'EOF'
|
||||
hosts:
|
||||
- name: srv200
|
||||
address: host.docker.internal
|
||||
EOF
|
||||
```
|
||||
|
||||
Host-Schlüssel holen – die Fingerprints werden angezeigt, mit `y` bestätigen:
|
||||
|
||||
```bash
|
||||
docker compose run --rm -it fail2ban-webui keyscan
|
||||
```
|
||||
|
||||
Verbindung testen – erwartet: `OK srv200 agent 1.0.0, 2 jails, 0 bans`:
|
||||
|
||||
```bash
|
||||
docker compose run --rm fail2ban-webui check
|
||||
```
|
||||
|
||||
### Starten
|
||||
|
||||
```bash
|
||||
docker compose up -d
|
||||
```
|
||||
|
||||
Die Oberfläche lauscht auf `127.0.0.1:8080` – davor gehört ein Reverse Proxy mit TLS.
|
||||
```bash
|
||||
docker compose ps # Up … (healthy) nach etwa 30 Sekunden
|
||||
```
|
||||
|
||||
```bash
|
||||
docker compose logs fail2ban-webui # hosts: srv200 – auth: local – geoip: on, danach "GeoIP database updated"
|
||||
```
|
||||
|
||||
Im Browser `http://192.168.1.10:8080` öffnen und mit `admin` und dem Passwort von oben anmelden.
|
||||
|
||||
> `docker compose run` funktioniert nur, solange der Dienst **nicht** läuft – die feste
|
||||
> IP-Adresse wäre sonst doppelt vergeben (`Address already in use`). Im laufenden Betrieb
|
||||
> die Hilfsbefehle mit `exec` aufrufen, z. B. `docker compose exec fail2ban-webui python -m webui check`.
|
||||
|
||||
## Hinter einem vorhandenen Nginx Proxy Manager (Docker)
|
||||
|
||||
Ausgangslage: Nginx Proxy Manager (NPM) läuft auf demselben Host als Docker-Container,
|
||||
fail2ban ist auf dem Host installiert. Die Weboberfläche bekommt dann **keinen**
|
||||
veröffentlichten Port, sondern hängt zusätzlich im Docker-Netz von NPM; erreichbar ist sie
|
||||
nur über NPM mit TLS.
|
||||
|
||||
Voraussetzung: Docker Engine ≥ 28 und Compose ≥ 2.33 (für `gw_priority`, siehe Schritt 3).
|
||||
|
||||
### 1. Manuelle Sperren auch für Docker-Ports
|
||||
|
||||
Verkehr zu veröffentlichten Docker-Ports – also auch zu NPM – läuft nicht über die Kette
|
||||
`INPUT`, sondern über `DOCKER-USER`. Den Agenten deshalb mit `--docker` installieren:
|
||||
|
||||
```bash
|
||||
bash /opt/fail2ban-webui-src/agent/install.sh --key-file /opt/fail2ban-webui/data/ssh/id_ed25519.pub --from 172.23.51.10 --docker
|
||||
```
|
||||
|
||||
War der Agent schon ohne `--docker` installiert, lässt der Installer das vorhandene Jail
|
||||
unverändert. Dann die Datei sichern, die zwei `action`-Zeilen ergänzen und fail2ban neu laden:
|
||||
|
||||
```bash
|
||||
mkdir -p /backups/config_backups && cp -a /etc/fail2ban/jail.d/manual-block.local /backups/config_backups/manual-block.local_$(date +%F_%H-%M)
|
||||
```
|
||||
|
||||
```bash
|
||||
nano /etc/fail2ban/jail.d/manual-block.local
|
||||
```
|
||||
|
||||
```ini
|
||||
action = iptables-allports[name=manual-block]
|
||||
iptables-allports[name=manual-block-docker, chain=DOCKER-USER]
|
||||
```
|
||||
|
||||
```bash
|
||||
fail2ban-client reload && fail2ban-client status manual-block
|
||||
```
|
||||
|
||||
### 2. Docker-Netz von NPM ermitteln
|
||||
|
||||
```bash
|
||||
docker ps --format '{{.Names}} {{.Image}}' | grep -iE 'npm|proxy-manager'
|
||||
```
|
||||
|
||||
```bash
|
||||
docker inspect <NPM-Container> --format '{{range $n, $c := .NetworkSettings.Networks}}{{$n}}{{"\n"}}{{end}}'
|
||||
```
|
||||
|
||||
### 3. Weboberfläche ins NPM-Netz hängen
|
||||
|
||||
Den veröffentlichten Port entfernen – erreichbar ist die Oberfläche danach nur noch über NPM:
|
||||
|
||||
```bash
|
||||
cd /opt/fail2ban-webui && sed -i '/^ ports:$/,/8080:8080"$/d' docker-compose.yaml
|
||||
```
|
||||
|
||||
Das NPM-Netz kommt in eine eigene Datei `docker-compose.override.yaml`, die Docker Compose
|
||||
automatisch dazulädt. Den Netznamen aus Schritt 2 in `NPM_NET` setzen:
|
||||
|
||||
```bash
|
||||
NPM_NET=npm_default
|
||||
```
|
||||
|
||||
```bash
|
||||
cat > docker-compose.override.yaml <<EOF
|
||||
# fail2ban-webui hinter Nginx Proxy Manager: zusätzlich im Netz von NPM.
|
||||
# gw_priority hält die Standardroute im eigenen Netz – sonst kommt die
|
||||
# SSH-Verbindung zum Agenten mit der Adresse aus dem NPM-Netz an und
|
||||
# --from 172.23.51.10 lehnt sie ab.
|
||||
services:
|
||||
fail2ban-webui:
|
||||
networks:
|
||||
fail2ban-webui.dockernetwork.local:
|
||||
gw_priority: 1
|
||||
npm: {}
|
||||
|
||||
networks:
|
||||
npm:
|
||||
name: ${NPM_NET}
|
||||
external: true
|
||||
EOF
|
||||
```
|
||||
|
||||
```bash
|
||||
docker compose config --quiet && echo "Konfiguration ok"
|
||||
```
|
||||
|
||||
### 4. Adresse und Proxy-Einstellung
|
||||
|
||||
```bash
|
||||
sed -i -e 's|^PUBLIC_URL=.*|PUBLIC_URL=https://fail2ban.example.org|' -e 's|^TRUSTED_PROXY_HOPS=.*|TRUSTED_PROXY_HOPS=1|' .env
|
||||
```
|
||||
|
||||
### 5. Neu starten und prüfen
|
||||
|
||||
```bash
|
||||
docker compose up -d
|
||||
```
|
||||
|
||||
```bash
|
||||
docker compose exec fail2ban-webui python -m webui check
|
||||
```
|
||||
|
||||
### 6. DNS und Proxy-Host in NPM
|
||||
|
||||
- DNS: `fail2ban.example.org` auf die Adresse des Hosts zeigen lassen.
|
||||
- NPM → **Hosts → Proxy Hosts → Add Proxy Host**:
|
||||
|
||||
| Feld | Wert |
|
||||
|---|---|
|
||||
| Domain Names | `fail2ban.example.org` |
|
||||
| Scheme / Forward Hostname / Port | `http` · `fail2ban-webui` · `8080` |
|
||||
| Block Common Exploits | an |
|
||||
| SSL | Zertifikat anfordern (für interne Namen wie `*.int`: eigenes Zertifikat oder DNS-Challenge), *Force SSL*, *HTTP/2*, *HSTS* |
|
||||
| Access List | empfohlen: nur deine IP-Adressen |
|
||||
|
||||
### 7. Testen
|
||||
|
||||
```bash
|
||||
curl -sI https://fail2ban.example.org/login | grep -iE '^(HTTP|set-cookie)'
|
||||
```
|
||||
|
||||
Erwartet: `HTTP/2 200` und ein Cookie mit `Secure; HttpOnly; SameSite=Lax`. Im Protokoll der
|
||||
Weboberfläche steht nach einer Aktion die echte Client-Adresse, nicht die von NPM.
|
||||
|
||||
Optional: fehlgeschlagene Anmeldungen von fail2ban sperren lassen – siehe
|
||||
[Login mit fail2ban absichern](docs/operations.md#login-mit-fail2ban-absichern)
|
||||
(Banaction dort ebenfalls mit `chain=DOCKER-USER`).
|
||||
|
||||
## Dokumentation
|
||||
|
||||
|
||||
@@ -29,6 +29,7 @@ FROM=""
|
||||
AK_FILE=""
|
||||
MANUAL_JAIL=manual-block
|
||||
BANACTION=""
|
||||
DOCKER_CHAIN=0
|
||||
PROTECT=""
|
||||
INSTALL_JAIL=1
|
||||
FORCE_CONFIG=0
|
||||
@@ -56,6 +57,9 @@ Options:
|
||||
--manual-jail NAME jail for manual bans (default: manual-block)
|
||||
--banaction ACTION banaction for a newly created manual jail
|
||||
(default: the banaction of your jail.local)
|
||||
--docker Docker host: the new manual jail bans in INPUT and in
|
||||
DOCKER-USER, so published container ports (e.g. a
|
||||
Nginx Proxy Manager) are blocked as well (iptables)
|
||||
--protect NETWORKS additional addresses that must never be banned
|
||||
(comma separated, e.g. your home IP)
|
||||
--no-jail do not create the manual jail
|
||||
@@ -81,6 +85,7 @@ while [ $# -gt 0 ]; do
|
||||
--authorized-keys-file) need "$@"; AK_FILE="$2"; shift 2 ;;
|
||||
--manual-jail) need "$@"; MANUAL_JAIL="$2"; shift 2 ;;
|
||||
--banaction) need "$@"; BANACTION="$2"; shift 2 ;;
|
||||
--docker) DOCKER_CHAIN=1; shift ;;
|
||||
--protect) need "$@"; PROTECT="$2"; shift 2 ;;
|
||||
--no-jail) INSTALL_JAIL=0; shift ;;
|
||||
--force-config) FORCE_CONFIG=1; shift ;;
|
||||
@@ -108,6 +113,8 @@ SSHD=$(command -v sshd || echo /usr/sbin/sshd)
|
||||
[ -z "$FROM" ] || [[ "$FROM" =~ ^[0-9A-Fa-f.:/,*?!]+$ ]] || die "invalid --from: $FROM"
|
||||
[ -z "$PROTECT" ] || [[ "$PROTECT" =~ ^[0-9A-Fa-f.:/,]+$ ]] || die "invalid --protect: $PROTECT"
|
||||
[ -z "$BANACTION" ] || [[ "$BANACTION" != *$'\n'* ]] || die "invalid --banaction"
|
||||
[ -z "$BANACTION" ] || [ $DOCKER_CHAIN -eq 0 ] || die "--banaction and --docker cannot be combined"
|
||||
[ $DOCKER_CHAIN -eq 0 ] || command -v iptables >/dev/null || die "--docker needs iptables (installed together with Docker)"
|
||||
|
||||
if [ -n "$KEY_FILE" ]; then
|
||||
[ -r "$KEY_FILE" ] || die "cannot read $KEY_FILE"
|
||||
@@ -166,6 +173,7 @@ fail2ban-webui agent $AGENT_VERSION – fail2ban $F2B_VERSION – $(hostname
|
||||
key $KEY_FP
|
||||
allowed from ${FROM:-ANY ADDRESS (consider --from)}
|
||||
manual jail $MANUAL_JAIL $( [ $JAIL_EXISTS -eq 1 ] && echo "(exists, kept)" || { [ $INSTALL_JAIL -eq 1 ] && echo "(will be created)" || echo "(MISSING – bans will fail)"; } )
|
||||
ban chains $( [ $DOCKER_CHAIN -eq 1 ] && echo "INPUT + DOCKER-USER (--docker)" || echo "from the banaction in jail.local" )
|
||||
backups $BACKUP_DIR
|
||||
EOF
|
||||
echo
|
||||
@@ -282,6 +290,11 @@ EOF
|
||||
echo "maxretry = 1"
|
||||
echo "bantime = -1"
|
||||
[ -z "$BANACTION" ] || echo "banaction = $BANACTION"
|
||||
if [ $DOCKER_CHAIN -eq 1 ]; then
|
||||
# published Docker ports bypass INPUT and pass DOCKER-USER instead
|
||||
echo "action = iptables-allports[name=$MANUAL_JAIL]"
|
||||
echo " iptables-allports[name=$MANUAL_JAIL-docker, chain=DOCKER-USER]"
|
||||
fi
|
||||
} > "/etc/fail2ban/jail.d/$MANUAL_JAIL.local"
|
||||
fail2ban-client reload >/dev/null || die "fail2ban reload failed – check: fail2ban-client -t"
|
||||
fail2ban-client status "$MANUAL_JAIL" >/dev/null 2>&1 || die "jail $MANUAL_JAIL did not start – check the fail2ban log"
|
||||
|
||||
+15
-5
@@ -101,6 +101,7 @@ Schlüsseleintrag und lässt deine Konfiguration unverändert.
|
||||
| `--authorized-keys-file PFAD` | `~USER/.ssh/authorized_keys` | wohin der Schlüsseleintrag kommt – siehe [verwaltete Schlüssel](#hosts-mit-verwalteten-authorized_keys) |
|
||||
| `--manual-jail NAME` | `manual-block` | Jail für manuelle Sperren |
|
||||
| `--banaction AKTION` | aus `jail.local` | Banaction für ein neu angelegtes manuelles Jail |
|
||||
| `--docker` | – | Docker-Host: das neue manuelle Jail sperrt in `INPUT` **und** `DOCKER-USER` (iptables) – nicht mit `--banaction` kombinierbar |
|
||||
| `--protect NETZE` | – | zusätzliche geschützte Adressen (nur wenn die Konfigurationsdatei geschrieben wird) |
|
||||
| `--no-jail` | – | kein manuelles Jail anlegen |
|
||||
| `--force-config` | – | vorhandene `/etc/f2b-webctl.conf` überschreiben |
|
||||
@@ -150,18 +151,27 @@ manuelle Sperren, dessen Namen mit `--manual-jail` übergeben.
|
||||
|
||||
Die Standardaktionen von fail2ban sperren in der Kette `INPUT`. Verkehr zu **veröffentlichten
|
||||
Docker-Ports** läuft aber nicht über `INPUT`, sondern über `FORWARD` → `DOCKER-USER`; solche
|
||||
Sperren würden deine Container also nicht schützen. Auf einem Docker-Host das manuelle Jail
|
||||
deshalb mit einer Aktion anlegen, die die Kette `DOCKER-USER` nutzt, z. B. mit iptables:
|
||||
Sperren würden deine Container also nicht schützen. Auf einem Docker-Host den Agenten deshalb
|
||||
mit `--docker` installieren – das manuelle Jail sperrt dann in beiden Ketten:
|
||||
|
||||
```bash
|
||||
bash install.sh --key-file /tmp/webui.pub --from 198.51.100.10 \
|
||||
--banaction "iptables-allports[chain=DOCKER-USER]"
|
||||
bash install.sh --key-file /tmp/webui.pub --from 198.51.100.10 --docker
|
||||
```
|
||||
|
||||
Das erzeugt im Jail:
|
||||
|
||||
```ini
|
||||
action = iptables-allports[name=manual-block]
|
||||
iptables-allports[name=manual-block-docker, chain=DOCKER-USER]
|
||||
```
|
||||
|
||||
Ein schon vorhandenes Jail ändert der Installer nicht; die zwei Zeilen dann von Hand in
|
||||
`/etc/fail2ban/jail.d/manual-block.local` eintragen und `fail2ban-client reload` ausführen.
|
||||
|
||||
Nach der ersten Sperre prüfen:
|
||||
|
||||
```bash
|
||||
iptables -S DOCKER-USER | head
|
||||
iptables -S DOCKER-USER | grep f2b
|
||||
```
|
||||
|
||||
Läuft die Weboberfläche auf demselben Docker-Host, in `hosts.yaml` `address: host.docker.internal`
|
||||
|
||||
@@ -21,9 +21,9 @@ hosts:
|
||||
Nach dem Hinzufügen eines Hosts `keyscan` erneut ausführen, dann neu starten:
|
||||
|
||||
```bash
|
||||
docker compose run --rm -it fail2ban-webui keyscan
|
||||
docker compose run --rm fail2ban-webui check
|
||||
docker compose up -d --force-recreate
|
||||
docker compose exec -it fail2ban-webui python -m webui keyscan
|
||||
docker compose exec fail2ban-webui python -m webui check
|
||||
docker compose restart
|
||||
```
|
||||
|
||||
`F2B_HOSTS=name=adresse,name2=adresse2` (Port 22, Benutzer `SSH_USER`) wird aus
|
||||
|
||||
@@ -229,6 +229,13 @@ docker compose logs -f fail2ban-webui # mit Strg+C verlassen
|
||||
Das Log zeigt eine Zusammenfassung wie
|
||||
`fail2ban-webui 1.0.0 – hosts: web01, lxc-proxy, dockerhost – auth: local – loki: off – geoip: on`.
|
||||
|
||||
Ab jetzt läuft der Dienst. `docker compose run …` würde wegen der festen IP-Adresse mit
|
||||
`Address already in use` scheitern – Hilfsbefehle deshalb im laufenden Container aufrufen:
|
||||
|
||||
```bash
|
||||
docker compose exec fail2ban-webui python -m webui check
|
||||
```
|
||||
|
||||
Lokaler Test ohne Proxy:
|
||||
|
||||
```bash
|
||||
|
||||
+4
-2
@@ -8,7 +8,7 @@ Alle Befehle im Verzeichnis mit der `docker-compose.yaml` ausführen (z. B. `/op
|
||||
docker compose ps # Up … (healthy)
|
||||
docker compose logs --tail 100 fail2ban-webui
|
||||
docker compose logs -f fail2ban-webui | grep -E 'AUDIT|LOGIN|ERROR|WARNING'
|
||||
docker compose run --rm fail2ban-webui check # jeder Agent erreichbar?
|
||||
docker compose exec fail2ban-webui python -m webui check # jeder Agent erreichbar?
|
||||
```
|
||||
|
||||
Wichtige Logzeilen:
|
||||
@@ -39,7 +39,7 @@ cp -a .env docker-compose.yaml config /backups/fail2ban-webui_$(date +%F)/ # o
|
||||
docker compose pull
|
||||
docker compose up -d
|
||||
docker compose ps
|
||||
docker compose run --rm fail2ban-webui check
|
||||
docker compose exec fail2ban-webui python -m webui check
|
||||
```
|
||||
|
||||
Vorher das [Changelog](../CHANGELOG.md) lesen – nennt es eine neue Agent-Version, auch die
|
||||
@@ -134,6 +134,8 @@ ein präparierter Benutzername kann also keine zweite Logzeile einschleusen.
|
||||
| Symptom | Ursache / Lösung |
|
||||
|---|---|
|
||||
| `curl: command not found` / `git: command not found` | frisches Minimal-System (z. B. LXC-Template) → `apt install -y curl git` |
|
||||
| `failed to set up container networking: Address already in use` | `docker compose run …` bei laufendem Dienst – die feste IP ist belegt → `docker compose exec fail2ban-webui python -m webui <befehl>` |
|
||||
| `Permission denied (publickey)` nur hinter NPM | Container hängt in zwei Netzen und verbindet mit der Adresse aus dem NPM-Netz → `gw_priority: 1` am eigenen Netz, siehe [README](../README.md#3-weboberfläche-ins-npm-netz-hängen) |
|
||||
| `docker: 'compose' is not a docker command` | nur das eigenständige `docker-compose` vorhanden → `apt install -y docker-compose-plugin` |
|
||||
| Container beendet sich: `… is not writable for UID 10050` | `chown -R 10050:10050 data` |
|
||||
| Container beendet sich: `AUTH_MODE=local needs AUTH_PASSWORD_HASH` | `hash-password` ausführen, Zeile mit einfachen Anführungszeichen einfügen |
|
||||
|
||||
@@ -14,6 +14,11 @@ IP-Adressen zu beschränken kostet wenig und ist dringend empfohlen.
|
||||
|
||||
## Nginx Proxy Manager
|
||||
|
||||
Läuft NPM als Docker-Container auf demselben Host: die getestete Schritt-für-Schritt-Anleitung
|
||||
steht im [README](../README.md#hinter-einem-vorhandenen-nginx-proxy-manager-docker) (gemeinsames
|
||||
Docker-Netz, kein veröffentlichter Port, `gw_priority`, Sperren in `DOCKER-USER`).
|
||||
Für NPM auf einem anderen Host:
|
||||
|
||||
**Hosts → Proxy Hosts → Add Proxy Host**
|
||||
|
||||
| Feld | Wert |
|
||||
|
||||
Reference in new issue
Block a user