vellis/wiki

Fork 0

Files

T

vellis bda02d587f Initial vault setup

2026-06-09 18:40:21 +02:00

7.0 KiB

Raw Blame History

title: Diun created: 2026-06-07 updated: 2026-06-07 type: app tags: [catalogue, docker, container, update, monitoring-docker, notifications, cron] confidence: high contested: false sources: [https://selfh.st/apps/?tag=Docker, https://github.com/crazy-max/diun]

🐳 Diun

Le notificateur d'updates d'images Docker en Go — soyez prévenu à chaque nouvelle version disponible sur le registry.

📋 Informations Générales

Champ	Valeur
Site web	crazymax.dev/diun
GitHub	crazy-max/diun
License	MIT
Langage	Go
Étoiles GitHub	4,7k ⭐
Dernière MAJ	2026-06-05
Catégorie	cat-docker

📝 Description

Diun (Docker Image Update Notifier) est un outil écrit en Go qui scanne périodiquement les images Docker que vous utilisez (via votre docker-compose.yml ou ses propres labels) et vous notifie quand une nouvelle version est disponible sur le registry (Docker Hub, GHCR, Quay, ECR, registries privés…). C'est le complément idéal de app-wud avec un focus sur la détection seule, pas la mise à jour automatique.

Diun est léger (binaire statique < 20 Mo), configurable via YAML, et supporte +90 providers de notification (Discord, Telegram, Slack, Matrix, email, webhook, Gotify, Ntfy, Pushover…). Il sait aussi comparer les tags par regex, suivre les tags latest/stable, et ignorer certaines images (jeux de données, images locales).

✅ Scan périodique configurable (par défaut : 6h)
✅ Multi-registries : Docker Hub, GHCR, Quay, ECR, ACR, GCR, Harbor, registries privés
✅ Multi-providers de notification : Discord, Telegram, Slack, Matrix, email, Gotify, Ntfy, +80 autres
✅ Comparaison par tag exact, regex, ou semver
✅ Labels Docker : diun.enable=true pour scanner une image, diun.include_tags pour filtrer
✅ Cron interne (pas de dépendance externe)
✅ API HTTP (statut, déclenchement manuel)
✅ Base SQLite (zéro config)
✅ Watchtower-compatible : peut notifier Watchtower pour déclencher l'update

Public cible : homelabers et équipes DevOps qui veulent savoir quand des MAJ sont dispos, sans pour autant auto-updater. Sépare clairement la détection (Diun) de l'action (Watchtower, Diun auto-update…).

Alternatives directes : app-wud (notification + auto-update), Watchtower (update auto, pas de notif fine), Cupdate (zero-config, plus simple), Cup (alertes simples).

🚀 Installation

Option 1 : Docker Compose (recommandé)

# docker-compose.yml
version: '3.8'
services:
  diun:
    image: crazymax/diun:latest
    container_name: diun
    restart: unless-stopped
    security_opt:
      - no-new-privileges:true
    command: serve
    environment:
      - DIUN_WATCH_SCHEDULE=0 9 * * *    # tous les jours à 9h
      - DIUN_WATCH_JITTER=30s
      - DIUN_PROVIDERS_DOCKER=true
      - DIUN_PROVIDERS_DOCKER_WATCHBYDEFAULT=true
      - DIUN_NOTIF_DISCORD_WEBHOOKURL=https://discord.com/api/webhooks/...
    volumes:
      - /var/run/docker.sock:/var/run/docker.sock:ro  # read-only suffit
      - diun_data:/data
      - /var/lib/docker/volumes:/var/lib/docker/volumes:ro  # pour scanner les stacks
      - ./diun.yml:/etc/diun/diun.yml:ro  # config optionnelle

volumes:
  diun_data:

Option 2 : Binaire natif

curl -L https://github.com/crazy-max/diun/releases/latest/download/diun-linux-amd64 -o diun
chmod +x diun
./diun serve

Fichier de config `diun.yml` (optionnel mais recommandé)

providers:
  docker:
    watchByDefault: true
    watchStopped: true

notif:
  discord:
    webhookURL: https://discord.com/api/webhooks/...
  telegram:
    token: "123456:ABC-DEF..."
    chatID: -1001234567890

⚙️ Configuration Initiale

Choisir sa méthode de scan : par défaut, Diun lit le socket Docker et scanne tous les conteneurs en cours.
Ajouter des labels sur les stacks à surveiller (par ex. diun.enable=true, diun.include_tags=^v[0-9.]+$).
Configurer au moins un provider de notification : Discord recommandé pour débuter, Gotify ou Ntfy pour du self-hosted pur.
Tester la notif : docker exec diun diun notify (depuis le conteneur).
Définir le cron : DIUN_WATCH_SCHEDULE=0 */6 * * * = toutes les 6h.
Vérifier l'API : curl http://diun:8055/api/v1/diun/status (si exposée).

🔄 Alternatives

Open Source

app-wud — Notification + auto-update (plus large scope)
Watchtower — Update automatique (peut notifier, mais pas son cœur)
Cupdate — Zero-config, UI web minimaliste
Cup — Mises à jour Docker simplifiées
Docker Update (portainer) — Natif Portainer
Renovate / Dependabot — Updates, mais pour le code (pas conteneurs en runtime)

Propriétaires

Docker Hub Pro — Webhooks de MAJ
Snyk Container — Vuln + updates, payant
JFrog Xray — Enterprise
Prisma Cloud (Palo Alto) — Cloud security
Aqua Security — Container security
Sysdig Secure — Runtime security + MAJ

Tableau comparatif

Critère	Diun	WUD	Watchtower	Cupdate	Cup
Notification seule	✅	✅ (par défaut)	⚠️ basique	✅	✅
Update auto	❌ (via Watchtower)	✅ (option)	✅	❌	✅ (option)
Multi-registry	✅ (tous)	✅	✅	✅	✅
Regex tags	✅	✅	⚠️	❌	❌
Config	YAML	YAML	Env	UI web	UI web
Notifications	+90	+15	Discord/email/SMTP	Discord/Slack	Discord/Telegram
Licence	MIT	MIT	Apache-2.0	MIT	MIT

Verdict : Diun est le plus flexible pour la détection pure : regex de tags, multi-registries, +90 notif providers, base SQLite stable. Pour auto-update, ajouter Watchtower ou utiliser app-wud.

🔐 Sécurité

⚠️ Le socket Docker est lu pour découvrir les conteneurs. Montez-le en :ro (read-only) — Diun n'a pas besoin d'écrire.
Pas de credentials en clair : utilisez des fichiers *.env montés en :ro ou les secrets Docker (docker secret).
HTTPS pour les webhooks : ne pas notifier en HTTP vers des endpoints non chiffrés.
Limiter la fréquence : DIUN_WATCH_SCHEDULE à 6h minimum pour ne pas saturer les registries (Docker Hub a des rate limits).
Auto-update désactivé par défaut : c'est un choix de sécurité — la mise à jour auto peut casser une prod sans surveillance.

📚 Ressources

Pages Liées

cat-docker — Catégorie Docker
app-wud — Concurrent (notif + auto-update)
app-portainer — UI complète
app-traefik — Reverse proxy
observabilite — Stack d'observabilité
securisation-home-lab — Durcir l'infra

7.0 KiB Raw Blame History