Surveillez vos services avec Uptime Kuma

Uptime Kuma est un outil de supervision auto-hébergé, compatible avec de multiples plateformes telles que Windows Server, Linux ou NAS.

Cet article détaille l'installation sous Linux (réalisée ici sous Debian 12) via les 2 solutions officielles possibles : Docker ou l'installation manuelle.

Pourquoi choisir Uptime Kuma ?

Il s'agit de l'outil de supervision le plus simple d'utilisation, tout en restant très complet. Avec Uptime Kuma, il est possible de :

• Surveiller des services via différents protocoles et méthodes (HTTP(S), TCP, Ping...)

• Surveiller des serveurs de jeux Steam et des conteneurs Docker

• Être notifié en cas de dysfonctionnement des services (via Discord, Telegram, Email et bien plus)

• Être alerté sur l'expiration d'un certificat TLS

• Personnaliser l'intervalle de vérification d'un service

• Et bien plus

Cet article présente l'installation d'Uptime Kuma (via les 2 méthodes) et accompagnera la mise en place de la surveillance d'un premier service.

⚠️ Uptime Kuma n'utilise pas d'agent et ne s'appuie pas sur le protocole SNMP. Par conséquent, cela ne permet pas de surveiller la charge du processeur, l'espace de stockage ou la consommation de mémoire vive.

I. Installation via Docker

Tout d'abord, créer un répertoire de travail :

mkdir Uptime-Kuma

Ensuite, entrer dans le dossier :

cd Uptime-Kuma

Puis, créer le fichier docker compose :

nano docker-compose.yaml

Une fois dans l'éditeur nano, copier le contenu ci-dessous :

services:
  uptime-kuma:
    image: louislam/uptime-kuma:2
    container_name: uptime-kuma
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - ./uptime-kuma-data:/app/data
      - /var/run/docker.sock:/var/run/docker.sock

⚠️ Note de sécurité : Mapper le socket Docker permet de surveiller les conteneurs nativement, mais donne des droits élevés au conteneur. En production critique, nous privilégierions l'utilisation d'une API sécurisée ou d'un proxy docker-socket.

Quitter nano en cliquant sur Ctrl+X, puis Y, puis sur la touche Entrée.

Lancer le conteneur avec :

docker compose up -d

C'EST TOUT ! L'INTERFACE EST ACCESSIBLE EN ENTRANT <L'IP_DU_SERVEUR:3001> DANS LE NAVIGATEUR INTERNET.

Pour ajouter un nom de domaine avec Uptime Kuma Docker :

Dans cet exemple, Caddy est utilisé car il est ultra-léger et gère les certificats SSL automatiquement.

Tout d'abord, se rendre chez l'hébergeur de nom de domaine et créer un enregistrement de type A :

• Nom : status (ou autre choix)

• Cible : l'adresse IP publique du routeur

⚠️ Ne pas oublier d'ouvrir les ports 80 et 443 sur le routeur vers le serveur.

Ensuite, créer un répertoire pour Caddy :

mkdir Caddy

Entrer dans le dossier et créer le fichier docker-compose.yaml :

cd Caddy
nano docker-compose.yaml

Copier le bloc suivant :

services:
  caddy:
    image: caddy:2
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - caddy_net

volumes:
  caddy_data:
  caddy_config:

networks:
  caddy_net:
    driver: bridge

Éditer le Docker Compose d'Uptime Kuma (créé précédemment) :

nano ~/Uptime-Kuma/docker-compose.yaml

Ajouter les lignes suivantes à la toute fin de votre fichier (sous la partie services) :

    networks:
      - caddy_net

networks:
  caddy_net:
    external: true

Quitter nano avec Ctrl+X, puis Y, puis appuyer sur entrée.

Maintenant, il est nécessaire de configurer Caddy. Ouvrir le fichier de configuration :

cd ~/Caddy
nano Caddyfile

Et ajouter le bloc suivant :

status.votre-domaine.fr {
    reverse_proxy uptime-kuma:3001
}

Quitter nano avec Ctrl+X puis Y puis appuyer sur entrée.

⚠️ Redémarrer les conteneurs (Caddy et Uptime Kuma) :

docker compose -f ~/Caddy/docker-compose.yaml up -d
docker compose -f ~/Uptime-Kuma/docker-compose.yaml up -d

II. Installation Manuelle

Bien que Docker soit le standard actuel, comprendre l'installation 'Bare Metal' est crucial pour maîtriser les dépendances systèmes et comprendre ce qui se passe “sous le capot”.

Tout d'abord, il faut mettre les paquets à jour :

sudo apt update && sudo apt upgrade -y

Installer Node.js avec la commande curl (via NVM pour obtenir la bonne version) :

curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.39.7/install.sh | bash
source ~/.bashrc
nvm install --lts

Installer git :

sudo apt install git -y

Cloner le dépôt GitHub d'Uptime Kuma :

git clone https://github.com/louislam/uptime-kuma.git

Se rendre dans le dossier où le clone du dépôt a été effectué, par exemple :

cd uptime-kuma

Une fois dans le dossier, installer les dépendances et PM2 (cela permet de garder Uptime Kuma actif en arrière-plan même après fermeture de la session SSH c’est ce qu’on appelle un gestionnaire de proccessus) :

npm run setup
npm install pm2 -g

Installer pm2-logrotate, pour obtenir les logs de débogage :

pm2 install pm2-logrotate

Démarrer Uptime Kuma et configurer le lancement automatique au redémarrage du serveur :

pm2 start server/server.js --name uptime-kuma
pm2 startup
# (Copier-coller la commande fournie par le terminal ici)
pm2 save

Pour accéder à Uptime Kuma via un nom de domaine, l'installation d'Apache ou Nginx est requise. La procédure officielle utilise Nginx :

sudo apt install nginx

Vérifier la version de Nginx :

nginx -v

Démarrer le service et vérifier qu'il est actif :

sudo systemctl start nginx
systemctl status nginx

La mention active (running) doit apparaître en vert.

Ensuite, créer un fichier de configuration pour Uptime Kuma :

sudo nano /etc/nginx/conf.d/uptime-kuma.conf

Coller le fichier de configuration suivant (remplacer votre.domaine.com par le domaine concerné) :

server {
  listen 80;
  server_name votre.domaine.com;

  location / {
    proxy_pass http://localhost:3001;
    proxy_http_version 1.1;
    proxy_set_header Upgrade $http_upgrade;
    proxy_set_header Connection "upgrade";
    proxy_set_header Host $host;
  }
}

Pour finir, redémarrer le service Nginx :

sudo systemctl restart nginx

L'accès à Uptime Kuma est désormais possible via le nom de domaine.

III. Mise en place de la supervision du premier service

Se rendre sur l'interface d'Uptime Kuma (en entrant <L'IP_DU_SERVEUR:3001> ou via le nom de domaine précédemment configuré).

À la première connexion, le tableau de bord est vide.

Tableau de bord d'accueil d'Uptime Kuma

Étapes de création d'une sonde :

1. Créer une nouvelle sonde : Cliquer sur le bouton vert "Ajouter une nouvelle sonde" situé en haut à gauche de l'interface.

2. Configuration générale : Une page de configuration s'ouvre.

Interface de configuration d'une nouvelle sonde

3. Remplir les champs principaux :

   • Type de sonde : Sélectionner le protocole à surveiller parmi la liste déroulante.

     • Définition : C'est la méthode que Kuma utilisera pour "pinguer" le service. Choisir "HTTP(S)" pour surveiller un site web classique.

   • Nom d'affichage : Saisir le nom qui apparaîtra sur le tableau de bord (exemple : "Mon Blog Perso").

   • URL : Renseigner le lien exact du site web ou du service à surveiller (exemple : https://aymenhammache.fr).

Les autres paramètres (intervalles de vérification, nombre de tentatives avant alerte) disposent de leurs propres explications contextuelles et peuvent être laissés par défaut pour un premier test.

Configuration des notifications :

Pour être alerté en cas de panne, il est nécessaire de configurer une notification.

1. Cliquer sur le bouton "Configurer une notification" (situé dans la colonne de droite).

2. Une fenêtre modale s'ouvre :

Configuration de l'alerte Discord

3. Paramétrer l'alerte :

   • Type de notification : Choisir le service désiré parmi les nombreuses messageries disponibles.

     • Exemple : Sélectionner "Discord" pour recevoir les alertes directement dans un salon textuel.

   • Configuration : Renseigner les informations requises selon le service choisi (l'URL du Webhook pour Discord, le Token pour Telegram, etc.).

   • Nom du robot (optionnel) : Personnaliser le nom de l'expéditeur de l'alerte.

   • Options avancées : Laisser la case "Proxy" vide et l'authentification sur "Aucune", sauf besoin spécifique de votre infrastructure réseau.

Une fois la configuration terminée, cliquer sur "Sauvegarder" en bas de page. La surveillance démarre immédiatement.

Le tableau de bord affiche désormais l'état du service en temps réel

Conclusion

L'installation d'Uptime Kuma est désormais terminée. Que ce soit via Docker ou en installation manuelle, le serveur dispose maintenant d'une solution de supervision robuste et esthétique.

La surveillance des services critiques est une étape indispensable dans la gestion d'un Homelab ou d'une infrastructure professionnelle. Au-delà des simples sondes, Uptime Kuma offre également la possibilité de créer des "Pages de Statut" publiques (Status Pages), permettant de communiquer l'état des services aux utilisateurs en temps réel.

Il ne reste plus qu'à explorer les nombreuses options de personnalisation et à affiner les alertes pour garantir une réactivité optimale en cas d'incident.