Une autre solution est Watchtower qui peut fonctionner en notification ou mettre à jour les containers directement. Mais il nécessite une interaction avec les containers, ce que je veux éviter.

Je suis donc parti sur docker-notify. L’image docker sur le docker hub n’est plus maintenue. Je suis donc parti du github et un build local. Le github n’est plus trop maintenu actuellement, mais l’on voit des utilisateurs actifs autour et un CI/CD est en place pour mettre à jour les dépendances, ce qui permet d’être à jour sans avoir de nouvelles features. D’autres forks sont actif aussi, surtout celui de TonyRL qui passe par une refonte du dockerFile, utilisation de yarn au lieu de npm, une feature pour utiliser ses identifiants dockerhub, mais la compatibilité avec le fichier de configuration de schlabbi semble cassé, le dernier commit de TonyRL compatible étant le 228513a8.

Création des dossiers :

mkdir -p /etc/docker/docker-notify/conf && cd /etc/docker/docker-notify

Création du fichier d’environnement vim .env :

CONFIG_DIR=/etc/docker/docker-notify/conf

Cloner la dernière version du projet git de Schlabbi :

git clone https://github.com/Schlabbi/docker-notify

Docker-compose de Docker-notify

version: '3.7'
services:
  docker-notify:
    build: ./docker-notify
    mem_limit: 300m
    container_name: docker-notify
    restart: unless-stopped
    volumes:
      - $CONFIG_DIR/config.json:/usr/src/app/config.json:ro
      - cache:/usr/src/app/cache

volumes:
  cache:

Explication du docker-compose :

• Je met une limite mémoire sur le container de 300 Mo
• Je nomme le container car je suis en docker « classique » pas de swarm
• Le container démarre automatiquement au démarrage sauf si je l’éteins manuellement
• Le fichier de configuration est monté en bind RO car il n’a pas besoin d’être édité
• Le container à besoin d’avoir un cache. Celui-ci pouvant être perdu, j’utilise un volume temporaire déclaré

Le fichier de configuration json avec notification Telegram

Vous aurez besoin de votre clé API Telegram ainsi que de générer un chatID. Je parle de ces étapes dans l’article sur les notifications Telegram pour les serveurs linux. Suivez donc ces étages pour avoir les identifiants Telegram nécessaire pour faire les notifications en cas de mise à jour d’une image docker particulièrement critique. Pour toutes, ce serait de trop.

Voici le fichier config.json d’exemple à mettre dans /etc/docker/docker-notify/conf :

{
  "checkInterval": 1440,
  "notifyServices":[
      {
          "image": "nextcloud:24",
          "actions": [
              {
                  "type": "mailHook",
                  "instance": "generalMail",
                  "recipient": "belgotux@mondomain.net"
              },
              {
                  "type": "webHook",
                  "instance": "telegram"
              }
          ]
      },
      {
          "image": "nextcloud:latest",
          "actions": [
              {
                  "type": "mailHook",
                  "instance": "generalMail",
                  "recipient": "belgotux@mondomain.net"
              },
			        {
                  "type": "webHook",
                  "instance": "pushbullet"
              }
          ]
      },
      {
          "image": "redis:5-alpine",
          "actions": [
              {
                  "type": "mailHook",
                  "instance": "generalMail",
                  "recipient": "belgotux@mondmain.net"
              }
          ]
      }
  ],
  "smtpServer": {
      "generalMail": {
          "host": "mail.infomaniak.com",
          "port": 465,
          "secure": true,
          "username": "votreuserouvotremail",
          "password": "votrepass",
          "sendername": "Docker-Notify",
          "senderadress": "votremail"
      }
  },
  "webHooks":{
      "telegram": {
          "reqUrl": "https://api.telegram.org/botVOTRE_CLE_API/sendMessage",
          "httpMethod": "GET",
          "httpBody": {
              "text": "$msg",
              "chat_id": "VOTRE_CHAT_ID"
          }
      },
      "pushbullet": {
        "reqUrl": "https://api.pushbullet.com/v2/pushes",
        "httpMethod": "POST",
        "httpHeaders": {
            "Access-Token": "VOTRE_TOKEN",
            "Content-Type": "application/json"
        },
        "httpBody": {
            "type": "note",
            "title": "docker-notify",
            "body": "$msg"
        }
  }
}

Explications :

• checkInterval : le temps de vérification exprimé en minutes, ici toutes les 24h
• notifyServices : la liste de nos images à vérifier ainsi que l’action ou les actions à utiliser. Dans mon cas j’ai les mail et le webHooks telegram
• smtpServer : vous renseignez le serveur mail à utiliser, attention qu’il faut du TLS explicite (port 465) et pas du startTLS (pour 587). Ou alors en claire vers votre relais interne (dans ce cas mettre "secure": false)
• webHooks: permet de faire appel à un mécanisme CI/CD pour recompiler automatiquement votre image perso avec la mise à jour de l’image parent par exemple. Dans mon cas, c’est de cette manière que Telegram est utilisé pour m’avertir de la mise à jour d’une image importante

L’article Notification Telegram – Pushbullet – mail d’une image Docker mise à jour est apparu en premier sur Mon linux.

J’y avais introduit un script simple de notification mail et SMS avec la commande NOTIFYCMD. A l’époque, je n’hébergeais pas encore sur github mes projets. J’avais mis le script en 2018 sur github, à l’occasion de la prise en charge de pushbullet et plus uniquement les mails et SMS.

Récemment j’ai revu le script, car il n’était pas très flexible. J’en ai profité pour y intégrer un PR de pushover de longue date, mais surtout Telegram qui est absolument recommandé pour des échanges chiffrés correctes, même si je n’avais pas d’infos sensibles sur des notifications UPS

Fin d’année passée, ma volonté était de passer toutes mes notifications en Telegram, que ce soit pour octoprint, mes vps, mes serveurs à la maison, Jeedom. J’ai notamment fait un script générique qui peut être utilisé pour envoyer des notifications Telegram à la fin d’une commande, avec un pipe, dans un script, etc en décembre.

La partie boot a été revue afin de ne plus avoir de dépendance avec un script de notification. Ce sont les mêmes fonctions, mais internalisées. J’ai partagé le logrotate également.

Installation manuelle du script de notification depuis github

Une fois la configuration de NUT suivis sur l’article précédent, voici la marche à suivre pour installer le script avec un copier coller. Vous aurez besoin de git :

• Copier le projet git nutNotify
• Copier le fichier nutNotify.conf.txt vers /usr/local/etc/nutNotify.conf afin de l’éditer avec vos besoins. Pour Telegram les deux variables telegramAccessToken et telegramChatID suffisent. Pour obtenir vos identifiants il faut créer un bot Telegram.
• Copier nutNotifyFct.sh nutNotifyBoot.sh nutNotify.sh nutShutdown.sh vers /usr/local/bin
• Copier systemd-notify vers /lib/systemd/system/nut-notify-boot.service
• systemctl reload daemon et enable nut-notify-boot
• Créer le répertoire de log /var/log/nutNotify avec les droits de l’utilisateur nut
• Copier le fichier de logrotate dans /etc/logrotate.d

git clone https://github.com/belgotux/nutNotify.git
cd nutNotify
cp nutNotify.conf.txt /usr/local/etc/nutNotify.conf
vim /usr/local/etc/nutNotify.conf
cp nutNotifyFct.sh nutNotifyBoot.sh nutNotify.sh nutShutdown.sh /usr/local/bin
cp systemd-notify /lib/systemd/system/nut-notify-boot.service
systemctl daemon-reload
systemctl enable nut-notify-boot.service
mkdir /var/log/nutNotify
chown nut:nut /var/log/nutNotify
cp nutNotify.logrotate /etc/logrotate.d

Configuration de NUT et du script de notification push depuis Ansible Galaxy

J’ai également créé un repo github pour le projet Ansible nut client qui a 2 fonctions :

• Configurer le service nut facilement : autant sur le nut server relié à l’UPS, que les clients réseaux nut
• Configurer le script de notification Push pour Telegram, Pushbullet, Pushover, mal ou sms

Vous pouvez définir différents types de notifications en fonction de l’évènement. J’enverrai une notification Telegram pour un problème secteur et lorsque les serveurs s’éteindront en fin de batterie par exemple. Mais je ne voudrais peut-être pas que tous mes serveurs me disent qu’ils sont sur batterie UPS lors d’une coupure, un seul me suffira… D’où l’utilité des variables Ansible : des notifications minimales pour le groupe de serveurs et des notifications pour tous les events pour le serveur relié à l’UPS.

Le role nut-client est disponible sur Ansible Galaxy. Pour le prendre :

ansible-galaxy install belgotux.nut_client

La configuration est bien fournie dans le README en Anglais, mais je mets ici les points essentiels avec un exemple :

• notifynut_method peut être [mail|pushbullet|telegram|pushover|sms] (default mail)
• notifynut_mailto adresse mail de destinataire (default root)
• nut_mode peut être [netclient|netserver] : netserver est à mettre uniquement sur le serveur ayant l’UPS en USB ou utilisé en réseau (default netclient)
• nut_ups_name le nom donné à l’ups
• nut_ups_ip l’IP de l’UPS
• nut_ups_port port du service nut (default 3493)
• nut_user utilisateur nut pour monitorer l’UPS
• nut_password le mot de passe pour monitorer l’UPS

Selon la notification utilisée, les variables sont aussi à compléter. Dans le cas de Telegram :

• notifynut_telegram_accessToken Telegram token
• notifynut_telegram_chatID Telegram chat ID

Utiliser efficacement les variables Ansible

Et c’est suffisant pour un simple serveur. Mais pour ne pas recevoir 5 notifications si vous avez 5 serveurs qui passent sous batteries… Je vous conseille dans le groupe de serveur de mettre ces variables. Vous serez averti en cas de problème de communication avec le serveur NUT et quand le serveur est de nouveau en ligne après une coupure de courant :

notifynut_method: none
notifynut_method_comm: telegram
notifynut_method_serveronline: (telegram mail)

Et dans le hosts_vars du serveur NUT ceci, afin que le service soit en écoute et d’avoir toutes les notifications par telegram uniquement. (sauf serveronline vu qu’on l’a défini dans notre groupe à telegram+mail comme les autres serveurs).

nut_mode: netserver
notifynut_method: telegram

L’article NUT – notifications push Telegram Pushbullet Pushover pour UPS est apparu en premier sur Mon linux.

Ce rôle est disponible dans l’Ansible Galaxy. Pour l’installer rien de plus simple :

ansible-galaxy install belgotux.notification_push

Je vous mets également le lien du projet de notification avec Ansible sur github.

Il ne requiert aucune dépendance, il va chercher la dernière version du script via github pour les 2 scripts actuellement supportés : Pushbullet et Telegram. Dans le cas de ce dernier, une tâche Ansible va directement chercher le chat ID, nécessaire en plus du token.

Au préalable, il faut avoir créé un compte pour Pushbullet en suivant les étages. Et un bot pour Telegram en plus en suivant l’article que j’ai écrit sur les notifications Telegram pour Debian.

Exemple Playbook

Notification pushbullet :

- hosts: servers
  roles:
      - { role: notification-push vars: notification_pushbullet_access_token: 'o.XXXXXXXXXXXXXXXXXXXXX' }

Notification Telegram :

- hosts: servers
  roles:
      - { role: notification-push vars: notification_telegram_access_token: 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX' }

Utiliser un bot API local pour Telegram

Il est tout à fait possible de pousser l’utilisation en auto-hébergement via l’utilisation de son propre service d’API bot Telegram. L’article officiel sur le site de Telegram en décrit les capacités. Le rôle est fait pour pouvoir changer l’adresse par défaut de l’API https://api.telegram.org.

- hosts: servers
  roles:
      - role: notification-push
        vars:
          notification_telegram_access_token: 'XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX'
          notification_telegram_provider_api: 'https://your_custom_api'

L’article Role Ansible notification push Linux Debian est apparu en premier sur Mon linux.