Dans le paysage numérique actuel, la fiabilité et la disponibilité des services en ligne sont primordiales pour les entreprises et les administrations. Uptime Kuma se présente comme une alternative robuste et open-source aux solutions de monitoring traditionnelles.
Table of Contents
Qu’est-ce qu’Uptime Kuma ?
Uptime Kuma est un outil de surveillance auto-hébergé qui permet aux utilisateurs de suivre la disponibilité et la performance de divers services web et serveurs. Conçu pour être une alternative open-source à des services comme Uptime Robot, il offre une interface utilisateur intuitive et une suite complète de fonctionnalités de monitoring.
Caractéristiques Principales
- Surveillance Multitype : Uptime Kuma ne se limite pas à vérifier la disponibilité des sites web par des requêtes HTTP/S. Il supporte également le ping, le monitoring de ports, et plus encore, permettant ainsi de couvrir un large éventail de services et d’applications.
- Alertes et Notifications : L’une des fonctionnalités les plus utiles d’Uptime Kuma est sa capacité à envoyer des alertes en temps réel via divers canaux comme les emails, Telegram, Slack, et d’autres systèmes de notification.
- Interface Utilisateur Graphique : L’interface est claire et bien organisée, offrant un tableau de bord où les utilisateurs peuvent visualiser rapidement l’état de tous les services surveillés, avec des graphiques pour le temps de réponse et l’historique des statuts.
Avantages d’Uptime Kuma
- Confidentialité et Contrôle : Étant une solution auto-hébergée, Uptime Kuma permet aux organisations de garder toutes leurs données en interne, ce qui est crucial pour la conformité aux réglementations sur la confidentialité des données.
- Coût-Efficacité : Sans frais d’abonnement, Uptime Kuma peut être une solution économique, surtout pour les startups et les petites entreprises qui cherchent à optimiser leurs coûts opérationnels.
- Personnalisable et Extensible : Le caractère open-source d’Uptime Kuma permet aux développeurs de personnaliser et d’étendre ses fonctionnalités selon leurs besoins spécifiques.
Mise en Œuvre
La mise en place d’Uptime Kuma est relativement simple. Voici les étapes de base pour démarrer :
- Installation : Uptime Kuma peut être installé sur n’importe quel serveur supportant Docker ou Node.js. Le processus d’installation implique le téléchargement du code depuis GitHub et son déploiement via Docker, ce qui est bien documenté sur la page GitHub du projet.
- Configuration : Après l’installation, les utilisateurs peuvent ajouter des moniteurs via l’interface web d’Uptime Kuma, en spécifiant les URL ou les adresses IP des services à surveiller.
- Surveillance et Alertes : Configurez les alertes pour recevoir des notifications en cas de problème détecté avec un service. Uptime Kuma supporte plusieurs méthodes de notification, ce qui rend facile l’intégration avec les systèmes existants.
Scripts python d’automatisation
Tout d’abord, vous devez installer le paquet uptime_kuma_api en utilisant pip :
pip install uptime-kuma-apiAjouter automatiquement des moniteurs
Ce script Python utilise une liste d’URLs stockées dans un fichier et les ajoute comme moniteurs à Uptime Kuma. Chaque URL est configurée pour être vérifiée toutes les 15 minutes, et les notifications d’expiration des certificats sont activées.
from uptime_kuma_api import UptimeKumaApi, MonitorType
# Configuration initiale
api_url = 'http://your-uptime-kuma-url:3001'
api = UptimeKumaApi(api_url)
api.login('your_username', 'your_password')
# Lecture des URLs à partir d'un fichier et ajout comme moniteurs
with open('urls.txt', 'r') as file:
urls = file.readlines()
for url in urls:
url = url.strip()
result = api.add_monitor(
type=MonitorType.HTTP,
name=url,
url=url,
interval=900, # Intervalles de vérification toutes les 15 minutes
expiryNotification=True # Activation de la notification d'expiration du certificat
)
print(result)
api.disconnect()Pour générer automatiquement le fichier en entrée, par exemple l’ensemble des URLs ingress de votre cluster k8s, vous pouvez utiliser cette commande :
kubectl get ingress --all-namespaces -o=jsonpath='{range .items[*]}{range .spec.rules[*]}{.host}{"\n"}{end}{end}' | sed 's/^/https:\/\//' > urls.txtCela va générer ce type de fichier :
https://vault.pascal-mietlicki.fr
https://blog.pascal-mietlicki.fr
https://pileouface.pascal-mietlicki.fr
https://cointoss.pascal-mietlicki.fr
https://dice.pascal-mietlicki.fr
https://draw.pascal-mietlicki.fr
https://gpt.pascal-mietlicki.fr
https://lovestarter.pascal-mietlicki.fr
https://plantuml.pascal-mietlicki.fr
https://uptime.pascal-mietlicki.fr
https://pascal-mietlicki.fr
https://www.pascal-mietlicki.frPurger tous les moniteurs
Ce script permet de supprimer tous les moniteurs configurés dans Uptime Kuma. Il récupère la liste des moniteurs existants et les supprime un par un.
from uptime_kuma_api import UptimeKumaApi
api_url = 'http://your-uptime-kuma-url:3001'
api = UptimeKumaApi(api_url)
api.login('your_username', 'your_password')
# Récupération et suppression de tous les moniteurs
monitors = api.get_monitors()
for monitor in monitors:
api.delete_monitor(monitor['id'])
print(f"Deleted monitor: {monitor['name']}")
api.disconnect()Supprimer les moniteurs inactifs
Ce script identifie et supprime les moniteurs qui ne sont pas actifs. Il utilise le champ ‘active’ pour déterminer l’état du moniteur.
from uptime_kuma_api import UptimeKumaApi
api_url = 'http://your-uptime-kuma-url:3001'
api = UptimeKumaApi(api_url)
api.login('your_username', 'your_password')
monitors = api.get_monitors()
for monitor in monitors:
if not monitor['active']: # Vérifie si le moniteur n'est pas actif
api.delete_monitor(monitor['id'])
print(f"Inactive monitor deleted: {monitor['name']}")
api.disconnect()Ajout automatisé d’une status page
from uptime_kuma_api import UptimeKumaApi, MonitorType
# Configuration initiale
api_url = 'http://your-uptime-kuma-instance:port'
api = UptimeKumaApi(api_url)
api.login('your-username', 'your-password')
# Fonction pour demander à l'utilisateur s'il souhaite modifier une page existante
def prompt_user(message):
response = input(message + " (yes/no): ")
return response.lower() in ['yes', 'y']
# Fonction pour générer un slug valide à partir du titre
def generate_slug(title):
slug = re.sub(r'[^a-z0-9]+', '-', title.lower()).strip('-')
return slug
# Fonction pour sélectionner une page de statut existante
def select_status_page(status_pages):
print("Pages de statut existantes :")
for idx, page in enumerate(status_pages):
print(f"{idx + 1}. {page['title']} (Slug: {page['slug']})")
choice = int(input("Sélectionnez le numéro de la page que vous souhaitez modifier ou entrez 0 pour créer une nouvelle page : "))
if choice == 0:
return None
else:
return status_pages[choice - 1]
# Récupérer les pages de statut existantes
status_pages = api.get_status_pages()
# Demander à l'utilisateur s'il souhaite modifier une page existante ou en créer une nouvelle
selected_page = select_status_page(status_pages)
if selected_page:
title = selected_page['title']
slug = selected_page['slug']
if prompt_user(f"Voulez-vous mettre à jour tous les moniteurs de la page '{title}' pour que sendUrl soit True ?"):
status_page_id = selected_page['id']
modify_existing = True
else:
print("Aucune modification apportée.")
exit()
else:
# Demander le titre de la page de statut à l'utilisateur
title = input("Veuillez entrer le titre de la nouvelle page de statut : ")
slug = generate_slug(title)
api.add_status_page(slug, title)
status_page_id = api.get_status_pages()[-1]['id']
modify_existing = True
if modify_existing:
# Récupération de la liste des moniteurs
monitors = api.get_monitors()
# Préparer la liste des moniteurs à ajouter à la page de statut
monitor_list = []
for monitor in monitors:
monitor_id = monitor['id']
monitor_name = monitor['name']
monitor_url = monitor.get('url', '')
print(f"Moniteur URL :'{monitor_url}'")
# Vérification si le moniteur est de type HTTP
if monitor['type'] == MonitorType.HTTP:
# Mise à jour du moniteur pour s'assurer que le lien est cliquable
api.edit_monitor(monitor_id, url=monitor_url, sendUrl=True)
# Ajouter le moniteur à la liste
monitor_list.append({"id": monitor_id})
# Log du traitement du moniteur
print(f"Moniteur '{monitor_name}' (ID: {monitor_id}) traité et ajouté à la page de statut.")
# Vérifier si la page de statut a des moniteurs
status_page = api.get_status_page(slug)
existing_monitors = status_page['publicGroupList'][0]['monitorList'] if status_page['publicGroupList'] else []
# Ajouter les nouveaux moniteurs à la liste existante
for monitor in monitor_list:
if monitor not in existing_monitors:
existing_monitors.append(monitor)
# Sauvegarder la page de statut avec les moniteurs
api.save_status_page(slug, publicGroupList=[
{
'name': 'Services',
'weight': 1,
'monitorList': existing_monitors
}
])
print("Tous les moniteurs ont été ajoutés à la page de statut par défaut avec des liens cliquables.")Rendre les liens cliquables de la status page
Pour une raison obscure (sans doute non implémenté), la librairie python ne traite pas correctement l’option « sendUrl ». Cette option permet de rendre les liens de la Status Page cliquables.
Ce que vous pouvez faire c’est mettre à jour directement la base de données SQLITE.
sqlite3 kuma.db
sqlite> UPDATE monitor_group SET send_url = 1 WHERE send_url = 0;Conclusion
Uptime Kuma est un excellent choix pour ceux qui recherchent une solution de monitoring fiable, personnalisable et respectueuse de la vie privée. Que vous soyez une petite entreprise ou une grande organisation, il offre les outils nécessaires pour maintenir une surveillance efficace de vos infrastructures IT sans les coûts associés aux plateformes commerciales.
Pour en savoir plus et débuter avec Uptime Kuma, visitez le site officiel et la documentation.
