Post

đź”” Ntfy service de notification

Posté Mis à jour
Preview Image
Par Yann
22 min lire
đź”” Ntfy service de notification

Ntfy, qui se prononce “notify”, est un service de notification ultra léger, permettant d’envoyer des messages vers un smartphone ou un ordinateur via de simples scripts, sans besoin de compte et totalement gratuitement !

*

Le CLI de ntfy vous permet de publier des messages, de vous abonner à des sujets et d’héberger vous-même votre propre serveur ntfy. C’est très simple. Il suffit d’installer le binaire, le paquet ou l’image Docker, de le configurer et de l’exécuter.

Les étapes suivantes ne sont nécessaires que si vous voulez héberger votre propre serveur ntfy ou si vous voulez utiliser le CLI ntfy. Si vous voulez juste envoyer des messages en utilisant ntfy.sh, vous n’avez pas besoin d’installer quoi que ce soit. Vous pouvez simplement utiliser curl.

Le serveur ntfy se présente sous la forme d’un binaire lié statiquement et est livré sous forme de paquetage tarball, deb/rpm et sous forme d’image Docker. Nous supportons amd64, armv7 et arm64.
Veuillez consulter la page des versions pour les binaires et les paquets deb/rpm.

ntfy

Installer ntfy

Debian

Installation via le dépôt Debian/Ubuntu (empreinte digitale) 55BA 774A 6F5E E674 31E4 B6B7 CFDB 962D 4F1E C4AF::

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

# 1. Ajouter la clé GPG
sudo mkdir -p /etc/apt/keyrings
sudo curl -L -o /etc/apt/keyrings/ntfy.gpg https://archive.ntfy.sh/apt/keyring.gpg

# 2. Ajouter le dépôt
sudo apt install apt-transport-https
echo "deb [arch=amd64 signed-by=/etc/apt/keyrings/ntfy.gpg] https://archive.ntfy.sh/apt stable main" | sudo tee /etc/apt/sources.list.d/ntfy.list

# 3. Mettre Ă  jour et installer
sudo apt update
sudo apt install ntfy

# 4. Activer et démarrer le service
sudo systemctl enable ntfy
sudo systemctl start ntfy

# 5. VĂ©rifier le statut
sudo systemctl status ntfy

Arch Linux

Installer le paquet

1

yay -S --noconfirm ntfysh-bin

Création groupe et utilisateur à l’installation

1
2

Creating group 'ntfy' with GID 951.
Creating user 'ntfy' (ntfy user) with UID 951 and GID 951.

Instance ntfy publique

Application android ntfy

Installer l’application android ntfy
Pour s’abonner à un sujet, il suffit de lancer l’application et de cliquer sur le bouton +

Nous écrivons ensuite le nom du sujet auquel nous voulons nous abonner (le nom est complètement arbitraire), et, pour utiliser notre instance Ntfy auto-hébergée, nous cochons « Utiliser un serveur différent » et entrons l’IP de notre serveur ; enfin, nous cliquons sur « ABONNER »

Pour envoyer une notification au sujet, il suffit d’envoyer une requête POST ou PUT au serveur, en utilisant le langage de programmation de notre choix ou notre outil de ligne de commande préféré (commande ntfy pub ou une requête POST via curl).

1
2

curl -d "Ceci est une notification ntfy" https://noti.rnmkcy.eu/notif_infos
ntfy pub notif_infos "Ceci est une notification ntfy"

La notification push devrait apparaître sur notre appareil client android

Affichage des messages au format JSON

1

{"topic":"monsujet","message":"Ceci est une notification ntfy","time":1622656800}

Exemples d’utilisation
Recevoir une alerte Ă  chaque connexion SSH en utilisant ntfy

Instance ntfy privée (ACTIVE)

Les dossiers et les droits

1
2
3
4
5
6

sudo touch /var/log/ntfy.log
sudo chmod 775 /var/log/ntfy.log
sudo chown root:ntfy /var/log/ntfy.log
sudo chmod 775 -R /var/lib/ntfy/ 
sudo chown root:ntfy -R /var/lib/ntfy/
sudo systemctl restart ntfy

Configurer server.yml

La façon la plus simple de configurer une instance privée est de définir auth-default-access: deny-all dans le fichier /etc/ntfy/server.yml :

1
2

auth-file: /var/lib/ntfy/user.db
auth-default-access: "deny-all"

Le fichier de configuration /etc/ntfy/server.yml

1
2
3
4

listen-http: "127.0.0.1:8083"
auth-file: /var/lib/ntfy/user.db
auth-default-access: "deny-all"
behind-proxy: true

Explications

  • Listen-http - Le port sur lequel le serveur Web HTTP Ă©coute (par dĂ©faut = 80). Vous pouvez Ă©galement ajouter une adresse IP Ă  laquelle vous connecter (listen-http : "127.0.0.1:8083")
  • auth-file - Emplacement du user.dbfichier d’authentification.
  • auth-default-access - DĂ©finir ceci sur “deny-all” forcera tous les sujets Ă  ĂŞtre privĂ©s par dĂ©faut.
  • behind-proxy - Si ntfy est dĂ©ployĂ© derrière un proxy comme Caddy, nginx, etc., alors cela doit ĂŞtre dĂ©fini sur true.

Redémarrer le serveur ntfy

1

sudo systemctl restart ntfy

Création utilisateurs

Passer en mode su : sudo -s

Puisque nous avons déjà défini l’ attribut auth-file et auth-default-access, nous pouvons passer à l’ajout de notre premier utilisateur administrateur “notif”.

1

ntfy user add --role=admin notif

L’appel de cette commande avec un nom d’utilisateur vous invitera automatiquement à créer un mot de passe pour le nouvel utilisateur.

Créer un utilisateur non admin

1

ntfy user add yann

Une fois l’utilisateur créé, nous pouvons l’abonner à notre premier sujet de notification.

1

ntfy access yann yan_infos rw

RĂ©ponse

1
2
3
4

granted read-write access to topic yan_infos

user yann (role: user, tier: none)
- read-write access to topic yan_infos

Explications

  • rw spĂ©cifie le niveau d’accès de l’utilisateur notif pour le sujet notif_infos. Puisque cet utilisateur sera utilisĂ© pour envoyer des notifications, nous devons lui donner la possibilitĂ© d’écrire sur le sujet.
  • wo “write-only” (Ă©criture seule)
  • rw “read-write” (lecture-Ă©criture)
  • ro “read-only” (lecture seule)

Vous pouvez modifier les autorisations d’accès à tout moment, en réexécutant la commande ci-dessus avec un niveau d’accès différent.

Créez maintenant un deuxième utilisateur notifmob avec les autorisations sur le sujet en lecture seul.
Ce deuxième utilisateur sera utilisé pour notre application mobile.

1
2

ntfy user add notifmob
ntfy access notifmob yan_infos ro

RĂ©ponse

1
2
3
4

granted read-only access to topic yan_infos

user notifmob (role: user, tier: none)
- read-only access to topic yan_infos

Liste des commandes pour la gestion des utilisateurs

1
2
3
4
5
6
7

sudo ntfy user list                     # Shows list of users (alias: 'ntfy access')
sudo ntfy user add phil                 # Add regular user phil  
sudo ntfy user add --role=admin phil    # Add admin user phil
sudo ntfy user del phil                 # Delete user phil
sudo ntfy user change-pass phil         # Change password for user phil
sudo ntfy user change-role phil admin   # Make user phil an admin
sudo ntfy user change-tier phil pro     # Change phil's tier to "pro"

Vous pouvez publier et vous abonner en utilisant l’authentification de base avec le nom d’utilisateur/mot de passe donné. Veillez à utiliser HTTPS pour éviter les écoutes et l’exposition de votre mot de passe.

Authentification

A - Utilisateur et mot de passe

Username + password
Lorsque l’agent utilisateur souhaite envoyer des informations d’authentification au serveur, il peut utiliser le champ d’en-tête Authorization

Le champ d’en-tête Authorization est construit comme suit :

  • Le nom d’utilisateur et le mot de passe sont combinĂ©s avec un seul deux-points ( :). Cela signifie que le nom d’utilisateur lui-mĂŞme ne peut pas contenir de deux points.
  • La chaĂ®ne rĂ©sultante est encodĂ©e en une sĂ©quence d’octets. Le jeu de caractères Ă  utiliser pour cet encodage est par dĂ©faut non spĂ©cifiĂ©, tant qu’il est compatible avec US-ASCII, mais le serveur peut suggĂ©rer l’utilisation d’UTF-8 en envoyant le paramètre charset.
  • La chaĂ®ne rĂ©sultante est encodĂ©e Ă  l’aide d’une variante de Base64 (+/ et avec remplissage).
  • La mĂ©thode d’autorisation et un caractère d’espacement (par exemple “Basic “) sont ensuite ajoutĂ©s Ă  la chaĂ®ne encodĂ©e.

Par exemple, si le navigateur utilise Aladdin comme nom d’utilisateur et open sesame comme mot de passe, la valeur du champ est le codage Base64 de Aladdin:open sesame, ou QWxhZGRpbjpvcGVuIHNlc2FtZQ==. Le champ d’en-tête Authorization se présente alors comme suit :

1

Authorization: Basic QWxhZGRpbjpvcGVuIHNlc2FtZQ==

Pour générer l’en-tête d’autorisation, utilisez la norme base64 pour encoder les <nom d'utilisateur>:<mot de passe> séparés par deux points et ajoutez-y le mot Basic, c’est-à-dire Authorization : Basic base64(<username>:<password>).
Voici un pseudo-code qui, je l’espère, l’explique mieux :

1
2
3

username = "testuser"
password = "fakepassword"
authHeader = "Basic " + base64(username + " :" + password) // -> Basic dGVzdHVzZXI6ZmFrZXBhc3N3b3Jk

La commande suivante génère la valeur appropriée pour vous sur les systèmes *nix :

1

echo "Basic $(echo -n 'testuser:fakepassword' | base64)"

INFO: EntĂŞte autorisation au format utilisateur:Mot_de_passe base 64
echo -n 'leno:mot de passe' | base64
Renvoie –> eWFubjptb3QgZGUgcGFzc2U=

curl

1
2
3
4

curl --ipv4 \
    -u leno:mypass \
    -d "accès avec authentification" \
    https://noti.rnmkcy.eu/yan_infos

POST http

1
2
3

curl --ipv4 \
 -i -s -X POST -H "Authorization: Basic bGVubzpRpbjpvsZW5vNDk=" \
 -d "POST/HTTP accès avec authentification" "https://noti.rnmkcy.eu/yan_infos"

JavaScript

1
2
3
4
5
6
7

fetch('https://ntfy.example.com/mysecrets', {
    method: 'POST', // PUT works too
    body: 'Look ma, with auth',
    headers: {
        'Authorization': 'Basic cGhpbDpteXBhc3M='
    }
})

Go

1
2
3
4

req, _ := http.NewRequest("POST", "https://ntfy.example.com/mysecrets",
    strings.NewReader("Look ma, with auth"))
req.Header.Set("Authorization", "Basic cGhpbDpteXBhc3M=")
http.DefaultClient.Do(req)

Python

1
2
3
4
5

requests.post("https://ntfy.example.com/mysecrets",
    data="Look ma, with auth",
    headers={
        "Authorization": "Basic cGhpbDpteXBhc3M="
    })

PHP

1
2
3
4
5
6
7
8
9

file_get_contents('https://ntfy.example.com/mysecrets', false, stream_context_create([
    'http' => [
        'method' => 'POST', // PUT also works
        'header' => 
            'Content-Type: text/plain\r\n' .
            'Authorization: Basic cGhpbDpteXBhc3M=',
        'content' => 'Look ma, with auth'
    ]
]));

ntfy CLI

1
2
3
4

ntfy publish \
    -u phil:mypass \
    ntfy.example.com/mysecrets \
    "Look ma, with auth"

B - Jetons (Tokens)

Le jeton peut être utilisé à la place du nom d’utilisateur et du mot de passe lors de l’envoi de messages. (Access tokens)

En plus de l’authentification par nom d’utilisateur/mot de passe, ntfy fournit également une authentification par jetons d’accès. Les jetons d’accès sont utiles pour éviter d’avoir à configurer votre mot de passe dans plusieurs applications de publication/abonnement. Par exemple, vous pouvez utiliser un jeton dédié pour publier à partir de votre hôte de sauvegarde, et un autre à partir de votre système domotique.

Vous pouvez créer des jetons d’accès en utilisant la commande ntfy token, ou dans l’application web dans la section “Compte” (lorsque vous êtes connecté). Voir les jetons d’accès pour plus de détails.

Une fois le jeton d’accès créé, vous pouvez l’utiliser pour vous authentifier auprès du serveur ntfy, par exemple lorsque vous publiez ou vous abonnez à des sujets.

La commande ntfy token permet de gérer les jetons d’accès des utilisateurs. Les jetons peuvent avoir des étiquettes, et ils peuvent expirer automatiquement (ou ne jamais expirer). Chaque utilisateur peut avoir jusqu’à 20 jetons (codés en dur).

Exemples de commandes (tapez ntfy token –help ou ntfy token COMMAND –help pour plus de détails)

1
2
3
4
5

ntfy token list # Affiche la liste des jetons pour tous les utilisateurs
ntfy token list phil # Affiche la liste des jetons de l'utilisateur phil
ntfy token add phil # Crée un jeton pour l'utilisateur phil qui n'expire jamais
ntfy token add --expires=2d phil # Crée un jeton pour l'utilisateur phil qui expire dans 2 jours
ntfy token remove phil tk_th2sxr...  # Supprimer le jeton

Création d’un jeton d’accès (token) pour un utilisateur

1
2
3
4

# token qui n'expire pas
ntfy token add userone
# token qui expire dans 30 jours
ntfy token add --expires=30d userone

Liste des tokens

1

ntfy token list

1
2

utilisateur notif
- tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2 (sauvegardes), expire le 15 mars 23 14:33 EDT, accédé depuis 0.0.0.0 le 13 février 23 13:33 EST

Une fois le jeton d’accès créé, vous pouvez l’utiliser pour vous authentifier auprès du serveur ntfy, par exemple lorsque vous publiez ou vous abonnez à des sujets.

Voici un exemple utilisant Bearer auth, avec le jeton tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2 :

curl

1
2
3
4

curl --ipv4 \
  -H "Authorization: Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2" \
  -d "Look ma, with auth" \
  https://ntfy.example.com/mysecrets

POST http

1
2
3
4
5

POST /mysecrets HTTP/1.1
Host: ntfy.example.com
Authorization: Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2

Look ma, with auth

** JavaScript**

1
2
3
4
5
6
7

fetch('https://ntfy.example.com/mysecrets', {
    method: 'POST', // PUT works too
    body: 'Look ma, with auth',
    headers: {
        'Authorization': 'Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2'
    }
})

Go

1
2
3
4

req, _ := http.NewRequest("POST", "https://ntfy.example.com/mysecrets",
strings.NewReader("Look ma, with auth"))
req.Header.Set("Authorization", "Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2")
http.DefaultClient.Do(req)

Python

1
2
3
4
5

requests.post("https://ntfy.example.com/mysecrets",
data="Look ma, with auth",
headers={
    "Authorization": "Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2"
})

PHP

1
2
3
4
5
6
7
8
9

file_get_contents('https://ntfy.example.com/mysecrets', false, stream_context_create([
    'http' => [
        'method' => 'POST', // PUT also works
        'header' =>
            'Content-Type: text/plain\r\n' .
            'Authorization: Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2',
        'content' => 'Look ma, with auth'
    ]
]));

ntfy CLI

1
2
3
4

ntfy publish \
  --token tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2 \
  ntfy.example.com/mysecrets \
  "Look ma, with auth"

ntfy Android (PRIVE)

Installer android ntfy

Installer l’application ntfy disponible sur F-Droid

Après ouverture de l’application

Il faut saisir utilisateur et mot de passe car notification privée

Configuration application mobile Android

Téléchargez d’abord l’application depuis f-droid , et après son installation, lancez-la.

Au premier lancement, vous serez accueilli par un écran vide sans aucun sujet. Pour configurer l’application pour votre instance auto-hébergée, ouvrez le menu des paramètres (menu à 3 points > paramètres)

et accédez à « Gérer les utilisateurs » sous Général.

Appuyez sur « Ajouter un nouvel utilisateur » et dans le Service URLchamp, entrez l’URL que vous avez utilisée pour votre instance ntfy ci-dessus . Les champs Nom d’utilisateur et Mot de passe seront le deuxième utilisateur que vous avez créé précédemment
Une fois les champs remplis, appuyez sur « AJOUTER UN UTILISATEUR ».

Votre section utilisateur devrait alors ressembler à l’image suivante

Appuyez sur la flèche de retour (ou faites glisser votre doigt vers l’arrière), entrez le paramètre Serveur par défaut et saisissez à nouveau votre URL ntfy.

Maintenant, appuyez ou faites glisser votre doigt pour revenir à l’écran d’accueil. Pour désactiver la notification de livraison instantanée, qui s’affiche dans votre tiroir de notification, faites glisser votre doigt vers le sélecteur d’application et appuyez longuement sur l’icône de l’application ntfy
Appuyez ensuite sur « Informations sur l’application ».

Sur la page des paramètres de l’application, appuyez sur Notifications et désactivez la notification « Service d’abonnement » sous « Autre » ???.

Abonnement sujet

ATTENTION :Pour s'abonner Ă  un sujet, il faut que le sujet existe.
Sur l’écran d’accueil de l’application, appuyez sur le bouton vert « + » et saisissez le nom du sujet que vous avez créé précédemment lors de l’ étape d’accès utilisateur . Appuyez ensuite sur « S’ABONNER ».

Si cela est fait correctement, votre nouveau sujet devrait apparaître sur l’écran d’accueil de votre application.

Les paramètres de l’abonnement peuvent être ajustés en appuyant dessus puis en appuyant sur le menu à 3 points. Appuyez ensuite sur « Paramètres d’abonnement » dans le menu. Ici, vous pouvez modifier les préférences de notification ainsi que l’icône et le nom d’affichage de l’abonnement.

ntfy - Ligne de commande

SĂ©curiser

Pour éviter que n’importe qui puisse envoyer ou recevoir des messages, vous pouvez utiliser un mot de passe.

1
2

ntfy publish -u admin:myp@ssw0rd ntfy.example.com/monsujet "This is a message"
curl -u admin:myp@ssw0rd -d "This is a message" https://ntfy.example.com/monsujet

Cela implique un hébergement du serveur ntfy

Envoi

1

ntfy publish -u utilisateur:mot_de_passe  ntfysrv.eu/test "Nouveau test depuis PC1 en ligne de commande" |jq

Affichage message expédié

1
2
3
4
5
6
7
8

{
  "id": "WqRBXcEmOoqv",
  "time": 1708692353,
  "expires": 1708735553,
  "event": "message",
  "topic": "test",
  "message": "Nouveau test depuis PC1 en ligne de commande"
}

RĂ©ception

Se mettre en attente d’un message

1
2
3
4

# Mot de passe sur serveur privé
ntfy sub -u utilisateur:mot_de_passe  ntfysrv.eu/test |jq
# Clé token tk_xxxxxxxxxxx
ntfy sub -s all --token tk_xxxxxxxxxxx https://ntfysrv.eu/test |jq

Affichage à la réception d’un message

1
2
3
4
5
6
7
8
9

{
  "id": "BY9zD5GQqCI9",
  "time": 1708693062,
  "expires": 1708736262,
  "event": "message",
  "topic": "test",
  "title": "Firefox PC1",
  "message": "Nouvel essai depuis le navigateur"
}

Utilitaire jq pour un affichage au format json

RĂ©ception avec notify-send

Pour afficher vos notifications directement sur votre environnement de bureau, vous pouvez utiliser la commande ntfy sub avec notify-send.

1
2
3
4

# Mot de passe sur serveur privé
ntfy sub -u utilisateur:mot_de_passe  ntfysrv.eu/test 'notify-send -t 0 "ntfy" "$m"'
# Clé token tk_xxxxxxxxxxx
ntfy sub --token tk_xxxxxxxxxxx https://ntfysrv.eu/test 'notify-send -t 0 "ntfy" "$m"'

Voir tous les anciens messages

Si vous souhaitez voir l’historique des messages, vous pouvez utiliser le paramètre -s all

1

ntfy sub -s all monsujet

Notification token + curl

L’utilisateur notif a les droits en lecture/écriture et possède une clé token qui englobe utilisateur/mot de passe

Ligne de commande

1

curl -H "Title: Test envoi notification" -u :token_utilisateur_notif https://noti.rnmkcy.eu/notif_infos -d "ceci est un message de test"

Différentes publications Publishing

1
2
3
4
5
6
7
8
9
10
11
12

curl --ipv4 \
 -H "Title: Alerte!" \
 -H "Authorization: Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2" \
 -H "X-Tags: warning,mailsrv13,daily-backup" \
 -d "Envoi en cas d'erreur!" \
 https://noti.rnmkcy.eu/notif_infos

curl --ipv4 \
  -H "Authorization: Bearer tk_AgQdq7mVBoFD37zQVN29RhuMzNIz2" \
  -d "Look ma, with auth" \
  https://ntfy.example.com/mysecrets

Alerte sur connexion SSH

Alerte en cas de connexion SSH

Le fichier /etc/pam.d/sshd

1
2

# Ă  la fin du fichier
session optional pam_exec.so /usr/bin/ntfy-ssh-login.sh

Le fichier /usr/bin/ntfy-ssh-login.sh

1
2
3
4
5
6
7
8
9
10

#!/bin/bash
if [ "${PAM_TYPE}" = "open_session" ]; then
  curl --ipv4 \
    -H "Title: Alerte connexion SSH!" \
    -H "Authorization: Bearer tk_cpifjh59xo3zu2bgi2jyfkif4wsbf" \
    -H prio:high \
    -H tags:warning \
    -d "SSH ${HOSTNAME} user: ${PAM_USER} from ${PAM_RHOST}" \
    https://noti.rnmkcy.eu/notif_infos
fi

Le rendre exécutable : chmod +x /usr/bin/ntfy-ssh-login.sh

Message en cas de connexion

ntfy - proxy

Si vous exécutez ntfy derrière un proxy, vous devez activer le drapeau behind-proxy. Cela demandera à la logique de limitation de taux d’utiliser l’en-tête X-Forwarded-For comme identifiant principal d’un visiteur, plutôt que l’adresse IP distante. Si l’indicateur “behind-proxy” n’est pas activé, tous les visiteurs seront comptés comme un seul, car du point de vue du serveur ntfy, ils partagent tous l’adresse IP du proxy.

/etc/ntfy/server.yml

Modifier le fichier /etc/ntfy/server.yml

1
2
3

listen-http: "127.0.0.1:8083"

behind-proxy: true

Redémarrer le service

1

sudo systemctl restart ntfy

Proxy nginx, Serveur CWWK Debian 13 rnmkcy.eu

ntfy.rnmkcy.eu

Créer le fichier proxy /etc/nginx/conf.d/ntfy.rnmkcy.eu.conf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

server {
    # ipv4 listening port/protocol
    listen       443 ssl;
    http2 on;
    server_name  ntfy.rnmkcy.eu;

    include /etc/nginx/conf.d/ssl-modern.inc;

  location / { 
    proxy_pass              http://127.0.0.1:8083;
    proxy_http_version 1.1;

    proxy_set_header Host $host;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;

    proxy_connect_timeout 3m;
    proxy_send_timeout 3m;
    proxy_read_timeout 3m;

    client_max_body_size 0; # Stream request body to backend
  } 

}

VĂ©rifier et recharger nginx

1

sudo nginx -t && sudo systemctl reload nginx

Accessibilité lien https://ntfy.rnmkcy.eu

Première connexion depuis un navigateur firefox https://ntfy .rnmkcy.eu



Notifications par courrier

Pour permettre la transmission de messages par e-mail, vous pouvez configurer un serveur SMTP pour les messages sortants. Une fois configuré, vous pouvez définir l’en-tête X-Email pour envoyer des messages par e-mail (par exemple curl -d “hi here” -H “X-Email: phil@example.com” ntfy.sh/mytopic).

Ă€ ce jour, seuls les serveurs SMTP avec authentification en texte brut (ou sans aucune authentification) et STARTTLS sont pris en charge.
Veuillez également vous référer aux paramètres de limitation de débit ci-dessous (visitor-email-limit-burst & visitor-email-limit-burst).

  • smtp-sender-addr est le hostname:port du serveur SMTP
  • smtp-sender-from est l’adresse e-mail de l’expĂ©diteur
  • smtp-sender-user/smtp-sender-pass sont le nom d’utilisateur et le mot de passe de l’utilisateur SMTP (laissez vide pour aucune authentification)
  • smtp-sender-verify est un indicateur qui force la vĂ©rification du destinataire de l’e-mail lorsqu’il est activĂ©. Si dĂ©fini sur true, seuls les destinataires d’e-mails vĂ©rifiĂ©s peuvent ĂŞtre utilisĂ©s dans l’en-tĂŞte X-Email.

Ajouter ce qui suit au fichier de configuration /etc/ntfy/server.yml pour le courrier sortant

1
2
3
4
5

base-url: "https://ntfy.rnmkcy.eu"
smtp-sender-addr: "yannig.net:587"
smtp-sender-user: "yann"
smtp-sender-pass: "Mot_de_passe_yann"
smtp-sender-from: "yann@yannig.net"

Redémarrer le service ntfy

1

sudo service ntfy restart

Tester

1
2
3
4
5
6
7
8

curl --ipv4 \
    -H "Email: phil@example.com" \
    -H "Tags: warning,skull,backup-host,ssh-login" \
    -H "Priority: high" \
    -d "Unknown login from 5.31.23.83 to backups.example.com" \
    ntfy.sh/alerts
curl -H "Email: phil@example.com" -d "You've Got Mail" 
curl -d "You've Got Mail" "ntfy.sh/alerts?email=phil@example.com"

1
2
3
4
5
6
7
8
9

curl --ipv4 \
    -H "X-Email: ntfy@cinay.eu" \
    -H "Title: Information!" \
    -H "Authorization: Bearer tk_xxxxxxxxxxxxxxxxxxxxxx" \
    -H "Priority: high" \
    -H tags:information_source \
    -d "`date`
    `hostnamectl`" \
    https://ntfy.rnmkcy.eu/yan_infos

Message reçu

fichier /etc/ntfy/server.yml au 04/05/2026

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# ntfy server config file
#
# To listen on all interfaces, you may omit the IP address, e.g. ":443".
# To disable HTTP, set "listen-http" to "-".
#
listen-http: "127.0.0.1:8083"

# log-level defines the default log level, can be one of trace, debug, info (default), warn or error.
log-level: warn
log-format: json
log-file: /var/log/ntfy.log

auth-file: /var/lib/ntfy/user.db
auth-default-access: "deny-all"
behind-proxy: true


base-url: "https://ntfy.rnmkcy.eu"

smtp-sender-addr: "yannig.net:587"
smtp-sender-user: "yann"
smtp-sender-pass: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
smtp-sender-from: "yann@destina.net"

Activer “attachment”

Pour activer les attachments sur une instance ntfy auto-hébergée, il faut configurer un backend de stockage pour les pièces jointes, ainsi qu’une base-url publique correcte. La documentation ntfy indique que cette fonctionnalité dépend d’un stockage d’attachments activé côté serveur, local ou S3-compatible.

Configuration Ă  ajouter

Dans le fichier de config de ntfy, activez un stockage d’attachments et définissez l’URL publique du service. La doc précise que les attachments peuvent être stockés localement ou via S3, et qu’une base-url est nécessaire pour générer les liens correctement.

1
2
3
4

base-url: "https://ntfy.rnmkcy.eu"
attachment-cache-dir: "/var/cache/ntfy/attachments"
attachment-cache-size-limit: 5G
attachment-expiry-duration: 72h

Selon votre installation, les noms exacts des options peuvent varier légèrement, mais l’idée reste la même : activer un backend de stockage et déclarer l’URL publique.

Points importants

  • Si vous ĂŞtes derrière un reverse proxy, base-url doit correspondre Ă  l’URL externe utilisĂ©e par les clients.
  • Il faut que le serveur ait les droits d’écriture sur le rĂ©pertoire de cache ou sur le backend S3.
  • Sans ce stockage, ntfy refusera les demandes d’attachments, ce qui explique votre erreur attachments not allowed.

Test après redémarrage

Une fois la config modifiée, redémarrez ntfy puis testez avec un envoi qui inclut un fichier ou une URL d’attachment. La documentation montre que les attachments se publient via l’en-tête X-Attach ou l’équivalent Attach.

Maintenance

curl

Il faut forcer ipv4 dans la commande curl: curl --ipv4 (How to force curl to use IPv4 or IPv6)

Tests ntfy.rnmkcy.eu

Remplacer TOKEN

1

printf 'Test message' | curl --ipv4 -v -X PUT -H "Title:test" -H "Content-Type:text/plain" -H "Authorization: Bearer TOKEN" --data-binary @- "https://ntfy.rnmkcy.eu/yan_infos"

RĂ©sultat

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

* Host ntfy.rnmkcy.eu:443 was resolved.
* IPv6: 2a01:e0a:95a:e2f1::1
* IPv4: 82.64.18.243
*   Trying [2a01:e0a:95a:e2f1::1]:443...
* ALPN: curl offers h2,http/1.1
* TLSv1.3 (OUT), TLS handshake, Client hello (1):
*  CAfile: /etc/ssl/certs/ca-certificates.crt
*  CApath: /etc/ssl/certs
* TLSv1.3 (IN), TLS handshake, Server hello (2):
* TLSv1.3 (IN), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (IN), TLS handshake, Encrypted Extensions (8):
* TLSv1.3 (IN), TLS handshake, Certificate (11):
* TLSv1.3 (IN), TLS handshake, CERT verify (15):
* TLSv1.3 (IN), TLS handshake, Finished (20):
* TLSv1.3 (OUT), TLS change cipher, Change cipher spec (1):
* TLSv1.3 (OUT), TLS handshake, Finished (20):
* SSL connection using TLSv1.3 / TLS_AES_256_GCM_SHA384 / X25519MLKEM768 / id-ecPublicKey
* ALPN: server accepted h2
* Server certificate:
*  subject: CN=rnmkcy.eu
*  start date: May  2 01:13:28 2026 GMT
*  expire date: Jul 31 01:13:27 2026 GMT
*  subjectAltName: host "ntfy.rnmkcy.eu" matched cert's "*.rnmkcy.eu"
*  issuer: C=US; O=Let's Encrypt; CN=E8
*  SSL certificate verify ok.
*   Certificate level 0: Public key type EC/secp384r1 (384/192 Bits/secBits), signed using ecdsa-with-SHA384
*   Certificate level 1: Public key type EC/secp384r1 (384/192 Bits/secBits), signed using sha256WithRSAEncryption
*   Certificate level 2: Public key type RSA (4096/152 Bits/secBits), signed using sha256WithRSAEncryption
* Connected to ntfy.rnmkcy.eu (2a01:e0a:95a:e2f1::1) port 443
* using HTTP/2
* [HTTP/2] [1] OPENED stream for https://ntfy.rnmkcy.eu/yan_infos
* [HTTP/2] [1] [:method: PUT]
* [HTTP/2] [1] [:scheme: https]
* [HTTP/2] [1] [:authority: ntfy.rnmkcy.eu]
* [HTTP/2] [1] [:path: /yan_infos]
* [HTTP/2] [1] [user-agent: curl/8.14.1]
* [HTTP/2] [1] [accept: */*]
* [HTTP/2] [1] [title: test]
* [HTTP/2] [1] [content-type: text/plain]
* [HTTP/2] [1] [authorization: Bearer TOKEN]
* [HTTP/2] [1] [content-length: 12]
> PUT /yan_infos HTTP/2
> Host: ntfy.rnmkcy.eu
> User-Agent: curl/8.14.1
> Accept: */*
> Title:test
> Content-Type:text/plain
> Authorization: Bearer TOKEN
> Content-Length: 12
> 
* upload completely sent off: 12 bytes
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
* TLSv1.3 (IN), TLS handshake, Newsession Ticket (4):
< HTTP/2 200 
< server: nginx
< date: Sat, 09 May 2026 09:38:27 GMT
< content-type: application/json
< content-length: 139
< access-control-allow-origin: *
< 
{"id":"pxP4M6bl4H1U","time":1778319507,"expires":1778362707,"event":"message","topic":"yan_infos","title":"test","message":"Test message"}
* Connection #0 to host ntfy.rnmkcy.eu left intact
Blog, Applications
application
Cet article est sous licence CC BY 4.0 par l'auteur.