Installation complète d’Uptime Kuma sur VPS Lite Infomaniak

Monitoring HTTPS, alertes Telegram, import massif des sites et sauvegarde Swiss Backup.

Objectif

Mettre en place une plateforme de monitoring centralisée permettant :

• surveillance de la disponibilité des sites,
• détection des erreurs PHP,
• détection des pages blanches,
• surveillance des certificats SSL,
• alertes Telegram,
• accès HTTPS sécurisé,
• sauvegarde automatique hors site,
• import massif de dizaines de sites,
• maintenance simple et durable.

Architecture finale

URL finale : https://monitor.votredomaine.ch

Configuration VPS recommandée

Partie 1 — Création et accès au VPS

Étape 1 — Création du VPS

Dans la console Infomaniak, créer :

• un VPS Lite,
• avec Ubuntu 24.04 LTS.

Lors de la création, générer une nouvelle clé SSH.

Nom conseillé : vps-admin

Télécharger la clé privée, par exemple vers :

~/cles-ssh/vps-admin.pem

Étape 2 — Préparer la clé SSH sur Mac

chmod 600 "~/cles-ssh/vps-admin.pem"

Étape 3 — Connexion SSH

ssh -i "~/cles-ssh/vps-admin.pem" ubuntu@203.0.113.10

Au premier accès, répondre yes à la question de confiance de la clé hôte.

Étape 4 — Mise à jour du système

sudo apt update && sudo apt upgrade -y

Partie 2 — Installation de Docker et d’Uptime Kuma

Étape 5 — Installation de Docker

curl -fsSL https://get.docker.com | sh

Vérifier l’installation :

docker --version

Étape 6 — Vérification de Docker Compose

docker compose version

Si absent :

sudo apt install docker-compose-plugin -y

Étape 7 — Autoriser Docker sans sudo

sudo usermod -aG docker $USER
exit

Reconnecter ensuite la session SSH pour que le changement de groupe prenne effet.

Étape 8 — Création du dossier Uptime Kuma

mkdir -p ~/uptime-kuma
cd ~/uptime-kuma

Étape 9 — Création du fichier compose.yaml

nano compose.yaml

Contenu à coller :

services:
  uptime-kuma:
    image: louislam/uptime-kuma:1
    container_name: uptime-kuma
    restart: unless-stopped
    ports:
      - "3001:3001"
    volumes:
      - ./data:/app/data

Sauvegarde nano : CTRL + O, ENTER, CTRL + X.

Étape 10 — Lancement d’Uptime Kuma

docker compose up -d
docker ps

Résultat attendu : uptime-kuma Up (healthy)

Partie 3 — Firewall et premier accès

Étape 11 — Ouverture des ports Infomaniak

Règles de firewall du VPS :

Étape 12 — Premier accès à Uptime Kuma

Dans un navigateur :

http://203.0.113.10:3001

Créer un utilisateur admin avec un mot de passe fort.

Partie 4 — Notifications Telegram

Étape 13 — Création du bot Telegram

Dans Telegram, ouvrir BotFather et envoyer :

/newbot

• Nom du bot : Mon Monitoring
• Username : mon_monitoring_bot

BotFather fournit un Bot Token à conserver.

Étape 14 — Récupération du chat_id Telegram

Ouvrir une conversation avec le bot et envoyer un message (ex. hello).

Ouvrir ensuite dans un navigateur :

https://api.telegram.org/botTOKEN/getUpdates

Repérer dans la réponse JSON :

"chat":{"id":123456789

Le chat_id est ici 123456789.

Étape 15 — Configuration Telegram dans Kuma

Dans Uptime Kuma : Settings → Notifications → Add Notification → Telegram

Renseigner le Bot Token et le Chat ID, puis cliquer sur Test. Le message doit arriver immédiatement sur Telegram.

Partie 5 — Nom de domaine et HTTPS

Étape 16 — Création du DNS du sous-domaine

Dans la zone DNS du domaine :

Vérifier la propagation :

dig monitor.votredomaine.ch

Étape 17 — Installation de Nginx

sudo apt install nginx -y

Étape 18 — Création du reverse proxy Nginx

sudo nano /etc/nginx/sites-available/uptime-kuma

Contenu à coller :

server {
    server_name monitor.votredomaine.ch;

    location / {
        proxy_pass http://127.0.0.1:3001;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header Upgrade $http_upgrade;
        proxy_set_header Connection "upgrade";
    }
}

Sauvegarde nano : CTRL + O, ENTER, CTRL + X.

Étape 19 — Activation du site Nginx

sudo ln -s /etc/nginx/sites-available/uptime-kuma /etc/nginx/sites-enabled/
sudo rm /etc/nginx/sites-enabled/default

Étape 20 — Vérification et redémarrage de Nginx

sudo nginx -t
sudo systemctl restart nginx

Étape 21 — Test HTTP

Tester dans un navigateur :

http://monitor.votredomaine.ch

Étape 22 — Installation HTTPS avec Let’s Encrypt

sudo apt install certbot python3-certbot-nginx -y
sudo certbot --nginx -d monitor.votredomaine.ch

Répondre aux invites : email de contact, acceptation des conditions, redirection HTTPS → Yes.

Résultat attendu : Congratulations!

URL finale : https://monitor.votredomaine.ch

Étape 23 — Fermeture du port 3001

Une fois le HTTPS opérationnel, supprimer la règle firewall ouvrant le port 3001 en public. Conserver uniquement :

Partie 6 — Réglages recommandés des sondes

Étape 24 — Paramètres des monitors

Pour des sites WordPress vitrines classiques :

Pourquoi le mode « HTTP(s) – Mot-clé »

Le mode simple HTTP(s) ne détecte pas :

• les erreurs fatales PHP,
• les pages blanches,
• les erreurs de plugin,
• les erreurs de thème.

En effet, WordPress peut renvoyer un code HTTP 200 OK même en cas d’erreur applicative visible. Le mode HTTP(s) – Mot-clé est donc requis pour ce cas d’usage : il vérifie qu’un texte précis est bien présent dans la page.

Choix du mot-clé

Le mot-clé doit être :

• toujours présent sur la page,
• stable dans le temps,
• simple (pas de HTML, pas de balises, pas de texte variable).

Exemple : votredomaine.ch

Partie 7 — Maintenance et mises à jour d’Uptime Kuma

Étape 25 — Mise à jour future d’Uptime Kuma

cd ~/uptime-kuma
docker compose pull
docker compose up -d
docker image prune -f
docker ps

Résultat attendu : healthy

Emplacement des données importantes

~/uptime-kuma/data

Ce dossier contient les utilisateurs, l’historique, les monitors, les notifications et la configuration de Kuma. C’est l’élément prioritaire à sauvegarder (voir Partie 9).

Partie 8 — Import massif des sites (API Python)

Étape 26 — Installation de l’environnement Python

Ubuntu 24.04 bloque l’installation pip au niveau système : un environnement virtuel est nécessaire.

sudo apt install python3-venv -y
cd ~/uptime-kuma
python3 -m venv venv
source venv/bin/activate

Le prompt doit afficher (venv).

Étape 27 — Installation de l’API Uptime Kuma

pip install uptime-kuma-api

Étape 28 — Fichiers d’import massif

Préparer deux fichiers :

• uptime-kuma-sites-inforweb.json (liste des sites à surveiller)
• import-uptime-kuma-sites.py (script d’import)

Étape 29 — Envoi des fichiers vers le VPS

Depuis le Mac :

scp -i "~/cles-ssh/vps-admin.pem" ~/Downloads/import-uptime-kuma-sites.py ubuntu@203.0.113.10:~/uptime-kuma/
scp -i "~/cles-ssh/vps-admin.pem" ~/Downloads/uptime-kuma-sites-inforweb.json ubuntu@203.0.113.10:~/uptime-kuma/

Étape 30 — Vérification des fichiers

cd ~/uptime-kuma
ls

Résultat attendu :

compose.yaml
data
import-uptime-kuma-sites.py
uptime-kuma-sites-inforweb.json
venv

Étape 31 — Import automatique des monitors

source venv/bin/activate
python import-uptime-kuma-sites.py uptime-kuma-sites-inforweb.json

Le script crée automatiquement les monitors et ignore les doublons.

Étape 32 — Attacher Telegram à tous les monitors

nano attach-telegram.py

Contenu :

from uptime_kuma_api import UptimeKumaApi

URL = "https://monitor.votredomaine.ch"

username = input("Utilisateur Uptime Kuma : ")
password = input("Mot de passe Uptime Kuma : ")

with UptimeKumaApi(URL) as api:
    api.login(username, password)

    notifications = api.get_notifications()
    telegram_id = None
    for n in notifications:
        if "Telegram" in n["name"]:
            telegram_id = n["id"]

    monitors = api.get_monitors()
    for monitor in monitors:
        monitor_id = monitor["id"]
        existing = monitor.get("notificationIDList", [])
        if telegram_id not in existing:
            existing.append(telegram_id)
            api.edit_monitor(
                id_=monitor_id,
                notificationIDList=existing
            )
            print(f"Telegram ajouté : {monitor['name']}")

print("Terminé.")

Sauvegarde nano : CTRL + O, ENTER, CTRL + X.

Lancer le script :

python attach-telegram.py

Partie 9 — Sauvegarde automatique (Restic + Swiss Backup)

Étape 33 — Installation de Restic

sudo apt install restic -y

Étape 34 — Configuration de Swiss Backup

nano ~/.restic-env

Contenu :

export AWS_ACCESS_KEY_ID="ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="SECRET_KEY"
export AWS_DEFAULT_REGION="us-east-1"
export RESTIC_REPOSITORY="s3:https://s3.swiss-backup04.infomaniak.com/uptime-kuma-vps"
export RESTIC_PASSWORD="MOT-DE-PASSE-TRES-LONG"

Sécuriser le fichier (accès propriétaire uniquement) :

chmod 600 ~/.restic-env
source ~/.restic-env

Ce fichier contient des identifiants sensibles. Ne jamais le versionner ni le partager. Utiliser un mot de passe Restic long et unique — c’est la seule clé permettant de déchiffrer les sauvegardes.

Étape 35 — Initialisation du dépôt Restic

restic init

Résultat attendu : created restic repository

Étape 36 — Script de sauvegarde automatique

nano ~/backup-kuma.sh

Contenu :

#!/bin/bash
source /home/ubuntu/.restic-env

sudo -E restic backup \
  /home/ubuntu/uptime-kuma \
  /etc/nginx \
  /etc/letsencrypt

sudo -E restic forget \
  --keep-daily 7 \
  --keep-weekly 4 \
  --keep-monthly 6 \
  --prune

Rendre le script exécutable :

chmod +x ~/backup-kuma.sh

Étape 37 — Premier backup manuel

~/backup-kuma.sh
sudo -E restic snapshots

Étape 38 — Automatisation quotidienne (cron)

crontab -e

Choisir l’éditeur (option 1 pour nano) et ajouter la ligne :

0 3 * * * /home/ubuntu/backup-kuma.sh >> /home/ubuntu/backup-kuma.log 2>&1

Sauvegarde nano : CTRL + O, ENTER, CTRL + X.

Vérifier la planification :

crontab -l

Vérification des logs de backup

cat /home/ubuntu/backup-kuma.log
tail -f /home/ubuntu/backup-kuma.log

Partie 10 — Utilisation de la fonction Maintenance

La fonction Maintenance d’Uptime Kuma permet de :

• suspendre temporairement les alertes,
• éviter les faux positifs pendant une intervention,
• planifier des fenêtres de maintenance à l’avance.

Elle est particulièrement utile lors de :

• mises à jour WordPress,
• migrations de sites,
• maintenance du serveur,
• redémarrages du VPS.

À activer systématiquement avant toute intervention planifiée sur un site surveillé.

Récapitulatif de l’architecture finale

• Accès : https://monitor.votredomaine.ch (HTTPS uniquement, port 3001 fermé)
• Monitoring : sondes HTTP(s) – Mot-clé, intervalle 1h, mot-clé stable par site
• Alertes : Telegram, attachées à tous les monitors
• Sauvegarde : Restic vers Swiss Backup, quotidienne à 3h du matin, rétention 7j/4sem/6mois
• Mise à jour : docker compose pull && docker compose up -d, à faire manuellement et ponctuellement
• Import de sites : via API Python, réutilisable pour tout ajout massif futur

Références

• Uptime Kuma — Documentation
• Uptime Kuma — GitHub
• Restic — Documentation
• Swiss Backup — Infomaniak