---
title: "Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate im Vergleich"
date: 2026-06-04T22:19:05+02:00
modified: 2026-11-22T10:15:24+01:00
category: docker
type: how_to
author: Marcel Schönfelder
canonical: https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud
reading_time: 13
personalize_url: "https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud#tz={tz}&telegram_chat_id={telegram_chat_id}&smtp_host={smtp_host}&smtp_user={smtp_user}&domain={domain}&repo={repo}"
variables:
  - name: tz
    label: "Zeitzone"
    default: "Europe/Berlin"
  - name: telegram_token
    label: "Telegram-Bot-Token"
    default: "<BOT_TOKEN>"
  - name: telegram_chat_id
    label: "Telegram-Chat-ID"
    default: "<CHAT_ID>"
  - name: smtp_host
    label: "SMTP-Server"
    default: "smtp.example.com"
  - name: smtp_user
    label: "SMTP-Benutzer"
    default: "user@example.com"
  - name: smtp_pass
    label: "SMTP-Passwort"
    default: "<PASSWORD>"
  - name: domain
    label: "Ihre Domain"
    default: "example.com"
  - name: wud_auth_admin_password
    label: "WUD-Admin-Passwort"
    generated_in_browser: true
  - name: repo
    label: "GitHub-Repository (Organisation/Name)"
    default: "org/repo"
---

# Docker-Container automatisch aktualisieren nach dem Watchtower-Aus: Diun, WUD und Renovate im Vergleich

## 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 |
| --- | --- | --- |
| `{{tz}}` | Zeitzone | `Europe/Berlin` |
| `{{telegram_token}}` | Telegram-Bot-Token | `<BOT_TOKEN>` |
| `{{telegram_chat_id}}` | Telegram-Chat-ID | `<CHAT_ID>` |
| `{{smtp_host}}` | SMTP-Server | `smtp.example.com` |
| `{{smtp_user}}` | SMTP-Benutzer | `user@example.com` |
| `{{smtp_pass}}` | SMTP-Passwort | `<PASSWORD>` |
| `{{domain}}` | Ihre Domain | `example.com` |
| `{{wud_auth_admin_password}}` | WUD-Admin-Passwort | wird im Browser des Lesers zufällig erzeugt |
| `{{repo}}` | GitHub-Repository (Organisation/Name) | `org/repo` |

Link mit eigenen Werten: https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud#tz=Europe%2FBerlin&telegram_chat_id=%3CCHAT_ID%3E&smtp_host=smtp.example.com&smtp_user=user%40example.com&domain=cloud.example.com&repo=org%2Frepo

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. Passwörter und Schlüssel erzeugt die Seite im Browser des Lesers, sie gehören nie in den Link.

*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.

Am 17. Dezember 2025 archivierten die Maintainer das GitHub-Repository `containrrr/watchtower`, weil sie Docker selbst nicht mehr aktiv einsetzen. Diese Anleitung stellt drei konzeptionell unterschiedliche Nachfolger vor, zeigt, wann welches Tool passt, und nennt die Fallstricke beim Umstieg, allen voran das pauschale automatische Update von Datenbank-Containern.

**Kurzfassung:** Watchtower ist archiviert; als Drop-in-Ersatz gibt es den aktiv gepflegten Community-Fork `nickfedor/watchtower`. Für mehr Kontrolle eignen sich **Diun** (reine Benachrichtigung, kein Eingriff), **WUD, What's Up Docker** (Benachrichtigung plus optionales Auto-Update, Web-Dashboard) oder **Renovate** (GitOps-Ansatz, öffnet Pull Requests im Repository). Datenbank-Container (PostgreSQL, MySQL, MariaDB) dürfen in keinem dieser Tools pauschal automatisch aktualisiert werden, ein fehlgeschlagenes Major-Update kann zu unwiederbringlichem Datenverlust führen. Opt-in per Label und Semver-Filterung (Versionsfilter nach dem Schema Major.Minor.Patch) sind Pflicht.

## Voraussetzungen

- [ ] Docker Engine 24 oder neuer mit `docker compose`-Plugin, x86_64 oder ARM64
- [ ] Ressourcen: Diun und WUD sind schlank; 1 bis 2 CPU-Kerne und 1 GB freier RAM neben den überwachten Diensten reichen
- [ ] Zugriff auf den Docker-Socket (`/var/run/docker.sock`)
- [ ] Git-Repository (GitHub, GitLab, Bitbucket oder Azure DevOps) für Renovate
- [ ] Ein Benachrichtigungskanal: Telegram-Bot-Token + Chat-ID, SMTP, Discord-Webhook oder Slack-Token
- [ ] Backup-Speicher (lokal oder S3-kompatibel) für Datenbankdumps vor manuellen Updates
- [ ] Renovate als gehosteter Dienst (Mend Renovate Community Cloud) ist kostenlos für öffentliche und private Repositories auf GitHub, Bitbucket Cloud und Azure DevOps; alternativ selbst betrieben per GitHub Actions (Schritt 5).

## Schritt 1: Watchtower abschalten und optionalen Drop-in-Fork einrichten

Entfernen Sie zuerst den alten Watchtower-Container, sonst aktualisieren zwei Tools dieselben Container doppelt oder widersprüchlich:

```bash
$ docker rm -f watchtower
```

Für eine Übergangszeit genügt es, in der Compose-Datei nur den Image-Namen zu ändern: Der Community-Fork (GitHub-Projekt `nicholas-fedor/watchtower`: Image `nickfedor/watchtower`) ist ein Drop-in-Ersatz:

```yaml
services:
  watchtower:
    image: nickfedor/watchtower   # statt containrrr/watchtower
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
```

Der Fork wird aktiv gepflegt, ist aber ein Community-Projekt ohne Zusagen zu Sicherheitsupdates. Er übernimmt das Opt-out-Verhalten: Ohne weitere Einstellungen aktualisiert er alle Container, auch Datenbanken. Mittelfristig lohnt der Umstieg auf Diun, WUD oder Renovate mit Opt-in.

> **Prüfen:** `docker ps --filter name=watchtower` zeigt nur noch den neuen Container mit dem Image `nickfedor/watchtower` oder, wenn Sie direkt migrieren, keinen Watchtower-Container mehr.

## Schritt 2: Entscheidung, welches Tool passt zu Ihrer Umgebung?

Die drei Kandidaten unterscheiden sich grundlegend:

| Kriterium | Diun 4.34 | WUD 9.9 | Renovate |
| --- | --- | --- | --- |
| Eingriff in Container | Niemals (nur lesen) | Optional (per Trigger) | Niemals direkt (nur PRs) |
| Git-Repository nötig | Nein | Nein | Ja (Pflicht) |
| Web-Dashboard | Nein | Ja (Port 3000, Anmeldung Pflicht) | Über Git-Plattform |
| Semver-Filterung | Regex per Label (mit `diun.watch_mode`) | Regex per Label | packageRules in JSON |
| Opt-in-Standard | Standard (`watchByDefault: false`) | `WUD_WATCHER_LOCAL_WATCHBYDEFAULT=false` setzen | Konfiguration in renovate.json |
| Benachrichtigungskanäle | 15+ (Telegram, Slack, Ntfy …) | SMTP, Slack, Webhook … | GitHub/GitLab-PR-Kommentare |
| Ideal für | Manuelle Kontrolle, Homelab | Homelab mit selektivem Auto-Update | GitOps, CI/CD-Umgebungen |

> **Prüfen:** Sie haben sich für ein Tool entschieden und wissen, ob Ihre Compose-Dateien in einem Git-Repository liegen. Nur dann kommt Renovate in Frage.

## Schritt 3: Diun einrichten (Benachrichtigung ohne Auto-Update)

Diun überwacht Images und benachrichtigt, greift aber nie in laufende Container ein: die sicherste Option. Legen Sie in einem eigenen Projektordner eine `compose.yaml` an:

Datei: `compose.yaml`

```yaml
services:
  diun:
    image: crazymax/diun:4.34.0
    container_name: diun
    restart: unless-stopped
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro
      - ./diun-data:/data
    environment:
      - TZ={{tz}}
      - LOG_LEVEL=info
      - DIUN_WATCH_WORKERS=10
      - DIUN_WATCH_SCHEDULE=0 */6 * * *
      - DIUN_WATCH_JITTER=30s
      - DIUN_PROVIDERS_DOCKER=true
      - DIUN_PROVIDERS_DOCKER_WATCHBYDEFAULT=false
      - DIUN_NOTIF_TELEGRAM_TOKEN={{telegram_token}}
      - DIUN_NOTIF_TELEGRAM_CHATIDS={{telegram_chat_id}}
```

> **Achtung:** **Wichtig:** `DIUN_PROVIDERS_DOCKER_WATCHBYDEFAULT=false` ist bereits Standard. Setzen Sie es trotzdem ausdrücklich, damit niemand es später auf `true` stellt (Benachrichtigungen für alle Container).

Die Überwachung aktivieren Sie je Container per Label. Ohne weitere Labels meldet Diun nur einen neuen Digest hinter dem verwendeten Tag; neue Versionsnummern erst mit `diun.watch_mode=all`. `diun.include_tags` grenzt die Tags ein (Minor-Pinning):

```yaml
services:
  nginx:
    image: nginx:1.26-alpine
    labels:
      - "diun.enable=true"
      - "diun.watch_mode=all"
      - "diun.max_tags=10"
      # Nur 1.26.x Patches beobachten (Minor-Pinning):
      - "diun.include_tags=^1\\.26\\.\\d+-alpine$"

  postgres:
    image: postgres:16
    labels:
      - "diun.enable=true"
      - "diun.watch_mode=all"
      - "diun.max_tags=10"
      # Nur Patch-Updates innerhalb Major 16:
      - "diun.include_tags=^16\\.\\d+$"
      - "diun.exclude_tags=^(latest|master|main)$"
```

Werte für `{{telegram_token}}` und `{{telegram_chat_id}}` Ihres Telegram-Bots eintragen, dann `docker compose up -d`.

> **Prüfen:** `docker compose logs diun` zeigt nach dem Start „Found N image(s) to analyze“, wobei N der Zahl Ihrer Container mit `diun.enable=true` entspricht, und „Next run in …“. Im Test lief Diun 4.34.0 mit diesen Einstellungen ohne Fehler (`Starting Diun version=v4.34.0`, `Found 1 image(s) to analyze`) und berücksichtigte nur den markierten Container.

Seit Version 4.34.0 ersetzt `diun.watch_mode` das bisherige Label `diun.watch_repo`: aus `diun.watch_repo=true` wird `diun.watch_mode=all`, aus `false` wird `tag`. Das alte Label wirkt weiter, Diun schreibt aber die Warnung `diun.watch_repo is deprecated; use diun.watch_mode (true: all, false: tag)` ins Log. Für das Update von 4.33 auf 4.34 stoppen Sie Diun (`docker compose stop diun`) und sichern den Ordner `./diun-data`, tragen den neuen Image-Tag ein und führen `docker compose pull diun` sowie `docker compose up -d diun` aus. Beim ersten Start migriert Diun seine Datenbank (`Database migration v3...`). Im Update-Test von 4.33.1 auf 4.34.0 blieben die bereits bekannten Images erhalten und wurden nicht erneut gemeldet, und Tags, die nach dem Update neu in den Filter fielen, meldete Diun 4.34.0 wie zuvor per Benachrichtigung.

## Schritt 4: WUD einrichten (Benachrichtigung plus optionales Auto-Update)

WUD ist die komfortabelste Option für Homelabs ohne Git-Repository: Web-Dashboard auf Port 3000, Semver-Filterung per Label, optionales Auto-Update per Trigger. Seit Version 9 ist ein Administratorkonto Pflicht, sonst beendet sich der Container direkt nach dem Start: Die ausführliche Schritt-für-Schritt-Einrichtung mit Compose-Trigger, Benachrichtigung und Umstieg von Watchtower zeigt [WUD statt Watchtower: Docker-Container automatisch aktualisieren](https://s-edv.com/anleitungen/watchtower-docker-automatische-updates).

```yaml
services:
  wud:
    image: getwud/wud:9.9.0
    container_name: wud
    restart: unless-stopped
    ports:
      - 3001:3000   # Port 3000 ist oft belegt, auf 3001 mappen
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock
      - ./wud-store:/store
    environment:
      # WICHTIG: Opt-in statt Opt-out (wie Watchtower)
      - WUD_WATCHER_LOCAL_WATCHBYDEFAULT=false
      - WUD_WATCHER_LOCAL_CRON=0 4 * * *
      # E-Mail-Benachrichtigung
      - WUD_TRIGGER_SMTP_MAIL_HOST={{smtp_host}}
      - WUD_TRIGGER_SMTP_MAIL_PORT=587
      - WUD_TRIGGER_SMTP_MAIL_USER={{smtp_user}}
      - WUD_TRIGGER_SMTP_MAIL_PASS={{smtp_pass}}
      - WUD_TRIGGER_SMTP_MAIL_FROM_ADDRESS=wud@{{domain}}
      - WUD_TRIGGER_SMTP_MAIL_TO=admin@{{domain}}
      # Pflicht seit WUD 9: Administratorkonto fürs Dashboard
      - WUD_AUTH_ADMIN_USER=admin
      - WUD_AUTH_ADMIN_PASSWORD={{wud_auth_admin_password}}
      # Update-Trigger: tauscht Container gegen die neue Version
      - WUD_TRIGGER_DOCKER_UPDATE_PRUNE=true
```

Das Passwort legt WUD beim ersten Start gehasht unter `./wud-store` ab; dieses Verzeichnis gehört ins Backup. Die älteren Variablen `WUD_AUTH_BASIC_…` gelten als veraltet.

Zu überwachende Container bekommen Labels. Datenbank-Container werden nur beobachtet, ohne Auto-Update-Trigger:

```yaml
services:
  nginx:
    image: nginx:stable-alpine
    labels:
      # Diesen Container überwachen
      - "wud.watch=true"
      # Nur exakte SemVer-Tags (kein 'latest')
      - "wud.tag.include=^\\d+\\.\\d+\\.\\d+-alpine$"
      # Auto-Update über den Docker-Trigger aktivieren
      - "wud.trigger.include=docker.update,smtp.mail"

  postgres:
    image: postgres:16
    labels:
      # Nur beobachten, NIEMALS auto-updaten
      - "wud.watch=true"
      - "wud.tag.include=^16\\.\\d+$"
      # Kein Update-Trigger, nur Mail-Benachrichtigung
      - "wud.trigger.exclude=docker.update"
```

> **Achtung:** Wichtig: Jeder Trigger gilt für alle überwachten Container. Der Docker-Trigger aktualisiert also auch die Datenbank, wenn sie ihn nicht per `wud.trigger.exclude=docker.update` ausschließt. Ein SMTP-Trigger verschickt nur E-Mails.

> **Prüfen:** `docker compose ps` zeigt WUD als „healthy“, `http://<host>:3001` fragt nach Benutzer und Passwort, und im Dashboard erscheinen nur die Container mit `wud.watch=true`. Im Test mit WUD 9.2.0 aktualisierte der Docker-Trigger einen markierten Container von 1.26.2 auf die neueste passende Version, der Container mit `wud.trigger.exclude=docker.update` wurde nur als „Update verfügbar“ gemeldet und blieb unverändert. Ein anschließender Start mit WUD 9.5.0 und Administratorkonto lief ebenfalls an (Health-Endpunkt 200, API ohne Login 401).

## Schritt 5: Renovate einrichten (GitOps, Pull-Request-basiert)

Renovate passt, wenn Ihr Stack in einem Git-Repository liegt und Updates nur über geprüfte Merges laufen sollen. Legen Sie im Stammverzeichnis des Repositorys eine `renovate.json` an:

Datei: `renovate.json`

```json
{
  "$schema": "https://docs.renovatebot.com/renovate-schema.json",
  "extends": [
    "config:recommended",
    "docker:pinDigests"
  ],
  "timezone": "{{tz}}",
  "ignoreTests": true,
  "prHourlyLimit": 2,
  "prConcurrentLimit": 5,
  "packageRules": [
    {
      "matchDatasources": ["docker"],
      "matchUpdateTypes": ["minor", "patch", "digest"],
      "minimumReleaseAge": "1 day",
      "automerge": true,
      "automergeType": "branch",
      "automergeSchedule": ["* 0-3 * * *"]
    },
    {
      "matchDatasources": ["docker"],
      "matchPackageNames": ["postgres", "mysql", "mariadb", "mongo"],
      "automerge": false,
      "allowedVersions": "/^\\d+\\.\\d+/"
    },
    {
      "matchDatasources": ["docker"],
      "matchPackageNames": ["postgres", "mysql", "mariadb"],
      "matchUpdateTypes": ["major"],
      "enabled": false
    }
  ]
}
```

`prHourlyLimit` und `prConcurrentLimit`: Nach Aktivierung von `docker:pinDigests` öffnet Renovate je Container einen PR für den SHA256-Digest, in größeren Setups dutzende auf einmal. Die Limits verhindern das.

Für selbst betriebenes Renovate per GitHub Actions legen Sie `.github/workflows/renovate.yml` an:

Datei: `.github/workflows/renovate.yml`

```yaml
name: Renovate
on:
  workflow_dispatch:
  schedule:
    - cron: '0 15 * * *'
jobs:
  renovate:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v7.0.1
      - uses: renovatebot/github-action@v46.3.14
        with:
          token: ${{ secrets.RENOVATE_TOKEN }}
        env:
          RENOVATE_GIT_AUTHOR: 'Renovate Bot <renovate@{{domain}}>'
          RENOVATE_REPOSITORIES: '{{repo}}'
```

Die Actions-Versionen sind fest eingetragen; Renovate hält sie danach aktuell.

> **Prüfen:** Nach einem manuellen Start des Workflows (*Actions → Renovate → Run workflow*) öffnet Renovate im Repository ein Issue „Dependency Dashboard“ und beim ersten Lauf einen Pull Request „Configure Renovate“ oder, wenn `renovate.json` schon vorhanden ist, die ersten Update-PRs.

## Schritt 6: Datenbank-Container schützen und Backup-Pattern einrichten

PostgreSQL, MySQL und MariaDB führen bei Major- und teils Minor-Updates Schema-Migrationen durch, die sich nicht rückgängig machen lassen. Ein automatisches Image-Update ohne vorherigen Dump kann zu dauerhaftem Datenverlust führen. Das Skript sichert die Datenbank vor einem manuellen Update:

```bash
#!/bin/bash
# Datei: /usr/local/bin/backup-and-update.sh
CONTAINER=${1:-postgres}
DATE=$(date +%Y%m%d_%H%M%S)
BACKUP_DIR=/opt/backups

mkdir -p "$BACKUP_DIR"
# Datenbank-Dump erstellen
docker exec "$CONTAINER" pg_dumpall -U postgres > "$BACKUP_DIR/db_${DATE}.sql"
if [ $? -eq 0 ]; then
  echo "Backup OK: $BACKUP_DIR/db_${DATE}.sql"
  docker compose pull "$CONTAINER"
  docker compose up -d "$CONTAINER"
else
  echo "FEHLER: Backup fehlgeschlagen, Update abgebrochen!"
  exit 1
fi
```

Skript mit `chmod +x /usr/local/bin/backup-and-update.sh` ausführbar machen und im Projektordner des Stacks aufrufen, z. B. `backup-and-update.sh postgres`. Das Skript verwendet den übergebenen Namen für `docker exec` (Containername) und für `docker compose pull` (Dienstname). Beide müssen deshalb übereinstimmen, zum Beispiel mit `container_name: postgres` im Dienst `postgres`. Ohne `container_name` heißt der Container etwa `projekt-postgres-1`, und das Skript bricht mit „No such container: postgres“ und „FEHLER: Backup fehlgeschlagen, Update abgebrochen!“ ab.

> **Prüfen:** Das Skript meldet „Backup OK“ mit dem Pfad der Sicherung, `ls -lh /opt/backups` zeigt eine Datei größer als 0 Byte, und `docker compose ps` zeigt den Datenbank-Container danach wieder als laufend.

Automatische Backups: [MySQL/PostgreSQL-Backup automatisieren mit Cron und Cloud](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud) und [Restic-Backup unter Linux und Windows mit Cron automatisieren](https://s-edv.com/anleitungen/restic-backup-linux-windows-automatisieren-cron).

## Schritt 7: Migration von Watchtower zu WUD, Labels umschreiben

Watchtower arbeitete per Opt-out: alle Container überwacht, Ausschluss mit `com.centurylinklabs.watchtower.enable=false`. WUD arbeitet mit Opt-in. Die Migration der Labels:

```yaml
# VORHER (Watchtower Opt-out):
labels:
  - "com.centurylinklabs.watchtower.enable=false"   # Ausschließen
  - "com.centurylinklabs.watchtower.scope=web-tier" # Scope-Gruppen

# NACHHER (WUD Opt-in), Logik umkehren:
labels:
  - "wud.watch=true"   # NUR markierte Container werden überwacht
# Container OHNE Label werden bei WUD_WATCHER_LOCAL_WATCHBYDEFAULT=false ignoriert
# DB-Container: wud.watch=true plus wud.trigger.exclude=docker.update (nur melden)
```

> **Achtung:** Wichtigste Regel: `WUD_WATCHER_LOCAL_WATCHBYDEFAULT=false` ausdrücklich setzen, denn der Standard ist `true`. Sonst überwacht WUD wie Watchtower alle Container.

> **Prüfen:** Im WUD-Dashboard erscheinen nur Container mit `wud.watch=true`. In den Logs meldet `docker compose logs wud` nach dem Start „Cron finished (N containers watched …)“, wobei N der Zahl Ihrer markierten Container entspricht.

Beim Wechsel von WUD 9.4.1 auf 9.5.0 sichern Sie zuerst den Store-Ordner und die Compose-Datei. Ändern Sie anschließend den Image-Tag und führen Sie `docker compose pull wud` sowie `docker compose up -d wud` aus. Version 9.5.0 schließt laut Release Notes eine Open-Redirect-Lücke nach der Anmeldung, beendet aktive Sitzungen gelöschter Benutzer und wiederholt Image-Pulls nach einem Rate-Limit der Registry. Im Test des Updates von 9.4.1 auf 9.5.0 mit der Compose-Datei aus diesem Schritt startete WUD mit `version = 9.5.0`, der Healthcheck antwortete mit HTTP 200, die Container-API ohne Anmeldung mit HTTP 401, und die Trigger `docker.update` und `smtp.mail` waren registriert.

Version 9.7.0 schließt laut Release Notes zwei Sicherheitslücken (Berechtigungsprüfung von API-Tokens, GHSA-xv5r-jpc4-8j2j, und Codeausführung über Link-Vorlagen, GHSA-rrhg-3h69-4fvf). Neu sind die optionale Variable `WUD_AUTH_SESSION_SECRET` für einen festen Sitzungsschlüssel und ein Modus `strict_digest` für den Compose-Trigger; der Compose-Trigger schreibt Dateien jetzt atomar. Neue Pflichtvariablen gibt es nicht. Im Update-Test von 9.6.0 auf 9.7.0 meldete das Log `WUD is starting (version = 9.7.0)`, der Store blieb erhalten, der Healthcheck antwortete mit HTTP 200, die Container-API ohne Anmeldung und mit falschem Passwort mit HTTP 401 und mit dem Administratorkonto mit HTTP 200. Diun 4.33.1 lief im selben Test daneben weiter ohne Fehler.

Version 9.8.0 nennt laut Release Notes keine neuen Pflichtvariablen. Beim Update von 9.7.0 auf 9.8.0 mit der Compose-Datei aus Schritt 4 meldete das Log `WUD is starting (version = 9.8.0)`, die Container-API antwortete ohne Anmeldung und mit falschem Passwort mit HTTP 401 und mit dem Administratorkonto mit HTTP 200. Der Docker-Trigger hatte unter 9.7.0 das neue nginx-Image geladen, WUD 9.8.0 führte den Container danach mit diesem Tag ohne offenes Update, die Datenbank wurde weiterhin nur als aktualisierbar gemeldet.

Version 9.9.0 nennt laut Release Notes ebenfalls keine neuen Pflichtvariablen; neu ist unter anderem, dass die Containerliste das beste verfügbare Update je Art (major, minor, patch) anzeigt. Beim Update von 9.8.0 auf 9.9.0 mit der Compose-Datei aus Schritt 4 meldete das Log `WUD is starting (version = 9.9.0)`, WUD passte den Store selbst an (`Applying DDL migration 6`), und die Container-API antwortete ohne Anmeldung und mit falschem Passwort mit HTTP 401, mit dem Administratorkonto mit HTTP 200. In einer frischen Installation mit 9.9.0 hob der Docker-Trigger den markierten nginx-Container von `1.26.2-alpine` auf `1.31.9-alpine`, die Datenbank wurde nur als aktualisierbar gemeldet.

Grundlagen zum Betrieb finden Sie in [Docker Compose unter Linux: Grundlage für Selfhosting](https://s-edv.com/anleitungen/docker-compose-linux-selfhosting-grundlage) und [Docker Compose absichern: Secrets, Healthchecks, Non-Root](https://s-edv.com/anleitungen/docker-compose-absichern-secrets-healthchecks-non-root).

## Troubleshooting / Typische Fehler

**Doppeltes Update durch parallelen Betrieb**

Watchtower läuft noch. `docker rm -f watchtower` vor dem Start des neuen Tools.

**WUD überwacht trotzdem alle Container**

`WUD_WATCHER_LOCAL_WATCHBYDEFAULT` fehlt oder ist `true`; auf `false` setzen.

**Diun meldet alle Container**

`DIUN_PROVIDERS_DOCKER_WATCHBYDEFAULT=true` (oft in älteren Anleitungen). Auf `false` setzen, Opt-in per `diun.enable=true`.

**WUD-Container beendet sich sofort**

Seit WUD 9 Pflicht: `WUD_AUTH_ADMIN_USER` und `WUD_AUTH_ADMIN_PASSWORD` setzen.

**WUD-Dashboard nicht erreichbar**

Port 3000 belegt. Auf einen freien Port mappen, z. B. `3001:3000`.

**Renovate merged keine PRs automatisch**

Ohne CI wartet Renovate auf Testergebnisse. `"ignoreTests": true` in `renovate.json` setzen.

**Renovate erkennt eine Compose-Datei nicht**

Erkannt werden `compose.yaml`, `docker-compose.yml` und ähnliche Namen. Andere Dateinamen über `managerFilePatterns` (früher `fileMatch`) ergänzen.

**Renovate PR-Flood nach Digest-Aktivierung**

Limits setzen: `"prHourlyLimit": 2` und `"prConcurrentLimit": 5`.

**Kaputtes Image sofort deployed**

Kein `minimumReleaseAge`. Mindestens `"minimumReleaseAge": "1 day"` in Renovate; WUD/Diun-CRON verzögert legen.

**latest-Tag ohne Semver-Kontrolle**

`:latest` erlaubt keine Minor/Major-Unterscheidung. Auf konkrete Tags pinnen (z. B. `nginx:1.26-alpine`).

## Häufige Fragen

### Muss ich sofort von Watchtower wegmigrieren?

Ja. Das Original erhält keine Updates mehr und startete im Test auf Docker Engine 29.8 gar nicht: Watchtower 1.7.1 spricht die Docker-API 1.25 an, die Engine verlangt mindestens 1.40. Übergangsweise hilft der Drop-in-Fork `nickfedor/watchtower` (Schritt 1), für kontrollierte Updates Diun, WUD oder Renovate.

### Was ist der größte konzeptionelle Unterschied zwischen den drei Tools?

Diun liest nur und benachrichtigt. WUD kann zusätzlich direkt auf dem Docker-Host aktualisieren. Renovate öffnet Pull Requests, das Update passiert erst beim Merge; Git bleibt die maßgebliche Quelle („Source of Truth“).

### Welches Tool eignet sich für ein einfaches Homelab ohne Git-Repository?

WUD mit `WUD_WATCHER_LOCAL_WATCHBYDEFAULT=false`: Web-Dashboard unter `http://host:3001`: Opt-in per Label, Semver-Regex-Filterung, optionales Auto-Update. Diun ist die schlankere Alternative, wenn nur Benachrichtigungen gewünscht sind.

### Wie schütze ich Datenbank-Container in allen drei Tools?

Diun: `diun.include_tags` nur auf Patch-Ebene der aktuellen Major-Version. WUD: Update-Trigger ausschließen (`wud.trigger.exclude=docker.update`). Renovate: `"automerge": false` für postgres/mysql/mariadb und `"enabled": false` für Major-Updates. Vor jedem manuellen Update einen Dump erstellen (Schritt 6).

### Kann ich Diun und WUD gleichzeitig betreiben?

Technisch ja, da Diun nur liest; sinnvoll höchstens übergangsweise, sonst doppelte Benachrichtigungen.

### Wie pinne ich auf Minor-Tags und erhalte nur Patch-Updates?

Diun: `diun.watch_mode=all` und `diun.include_tags=^1\.26\.\d+$`. WUD: `wud.tag.include=^1\.26\.\d+$`. Renovate: `"allowedVersions": "1.26.x"` in `packageRules`. Das Image-Tag im Compose-File steht auf `1.26`, nicht `latest`.

### Was passiert, wenn Renovate keine CI-Pipeline findet?

Sie wartet auf nie eintreffende Testergebnisse und merged nie automatisch; Lösung `"ignoreTests": true` (siehe Troubleshooting).

## Fazit

Übertragen Sie pauschale Auto-Updates nicht einfach in ein neues Tool. **Diun** passt für reine Benachrichtigung, **WUD** für Homelabs mit selektivem Auto-Update und Web-Überblick, **Renovate** für GitOps-Setups mit geprüften PRs. Bei allen drei gilt: Opt-in per Label, Semver-Filterung und harter Schutz für Datenbank-Container sind Pflicht.

Zur Absicherung des Docker-Hosts: [Traefik als Docker Reverse Proxy mit HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten) und [Docker-Netzwerke und Volumes verstehen](https://s-edv.com/anleitungen/docker-netzwerke-volumes-verstehen).

## Weiterführende Anleitungen und Quellen

- [Docker-Container automatisch aktualisieren](https://s-edv.com/anleitungen/docker-container-updates-watchtower-nachfolger-diun-wud)
- [WUD statt Watchtower: Docker-Container automatisch aktualisieren](https://s-edv.com/anleitungen/watchtower-docker-automatische-updates)
- [Docker Compose Grundlagen und Stacks](https://s-edv.com/anleitungen/docker-compose-grundlagen-stacks)
- [Traefik als Docker Reverse Proxy mit HTTPS einrichten](https://s-edv.com/anleitungen/traefik-docker-reverse-proxy-https-einrichten)
- [MySQL/PostgreSQL-Backup automatisieren mit Cron und Cloud](https://s-edv.com/anleitungen/mysql-postgresql-backup-automatisieren-cron-cloud)
- [Restic-Backup unter Linux und Windows mit Cron automatisieren](https://s-edv.com/anleitungen/restic-backup-linux-windows-automatisieren-cron)

Quellen: [Watchtower-Archivierungs-Diskussion auf GitHub](https://github.com/containrrr/watchtower/discussions/2135) · [Diun offizielle Dokumentation (crazymax.dev)](https://crazymax.dev/diun/) · [Diun GitHub Repository](https://github.com/crazy-max/diun) · [Watchtower-Fork von Nicholas Fedor](https://github.com/nicholas-fedor/watchtower) · [WUD offizielle Dokumentation](https://getwud.github.io/wud/) · [Renovate Docker-Dokumentation](https://docs.renovatebot.com/docker/) · [Matt Dyson: Automatic Docker Container Updates with Renovate](https://mattdyson.org/blog/2025/02/automatic-updates-with-renovate/) · [Linux Handbook: Watchtower-Alternativen Übersicht](https://linuxhandbook.com/blog/watchtower-like-docker-tools/)
