9 scripts Python puissants pour automatiser votre Raspberry Pi

J’utilise mon Raspberry Pi pour plein de petites tâches, mais certaines deviennent vite pénibles quand il faut les refaire tous les jours. Vérifier un dossier, sauvegarder des fichiers, surveiller une connexion… ce sont typiquement des choses qu’un script Python peut faire à votre place. J’en ai testé plusieurs, et je vais vous montrer ceux qui permettent vraiment de gagner du temps.

Les scripts Python permettent d’automatiser sur Raspberry Pi des tâches pratiques comme les sauvegardes, le monitoring, les alertes et le contrôle d’appareils, en seulement quelques lignes de code. Ils sont plus simples à écrire, à lire et à faire évoluer que les scripts bash, surtout dès qu’on utilise des librairies ou des API web.

Dans cet article, je partage avec vous les scripts Python les plus utiles que j’ai utilisés pour rendre mon Raspberry Pi plus autonome et plus malin. Vous allez trouver des idées, des bouts de code et des astuces à appliquer directement, pas besoin d’être un pro pour ça.

Si, comme moi, vous mélangez parfois la syntaxe entre différents langages de programmation, j’ai exactement ce qu’il vous faut. J’ai créé une fiche mémo Python avec toute la syntaxe essentielle au même endroit, pour que vous puissiez l’avoir sous la main et éviter toute confusion. Téléchargez-la gratuitement ici !

Script de mise à jour automatique du système

Garder son système à jour, c’est essentiel. Les mises à jour contiennent souvent des correctifs de sécurité importants et des corrections de bugs. Petit conseil : c’est aussi une bonne habitude de mettre à jour son système avant d’installer un nouveau logiciel.

Contrairement à la plupart des systèmes d’exploitation modernes, Raspberry Pi OS n’a pas de fonction de mise à jour automatique ou programmée. En général, on met à jour son système manuellement via le gestionnaire de paquets avec cette commande :
sudo apt update && sudo apt full-upgrade -y

On peut automatiser tout ça avec un script Python et la librairie subprocess. Voici un bout de code qui met à jour le Raspberry Pi automatiquement :

import subprocess

# Update and upgrade the system
def run_update():
    subprocess.run(["sudo", "apt", "update"])
    subprocess.run(["sudo", "apt", "upgrade", "-y"])

run_update()

Vous pouvez ensuite rendre ce script Python exécutable avec la commande :
chmod +x /home/pat/path/to/script.py

Et l’ajouter à la fin de votre fichier ~/.bashrc. Comme ça, dès que vous vous connectez à votre Raspberry Pi, une mise à jour du système démarre automatiquement en arrière-plan.

Pour éviter de relancer la mise à jour à chaque connexion, vous pouvez créer un fichier de log qui note l’heure de la dernière mise à jour, puis ajouter une ligne dans votre script pour vérifier qu’un délai minimum s’est écoulé (par exemple 7 jours) avant d’en relancer une :

from pathlib import Path
from datetime import datetime, timedelta

#Définis le chemin d'accès au fichier journal
#et le nombre de jours entre les mises à jour
UPDATE_LOG = Path("/home/pi/.last_update")
UPDATE_THRESHOLD_DAYS = 7

#Vérifie si une mise à jour est nécessaire
def needs_update():
    if not UPDATE_LOG.exists():
        return True
    last_update = datetime.fromisoformat(UPDATE_LOG.read_text())
    return datetime.now() - last_update > timedelta(days=UPDATE_THRESHOLD_DAYS)

#Mettre à jour si nécessaire
if needs_update():
    run_update()

Si vous faites tourner votre Raspberry Pi en mode graphique, vous pouvez ajouter des notifications pour être prévenu quand une mise à jour démarre et quand elle se termine (avec succès ou pas). On peut faire ça avec la librairie plyer.

Vous pouvez installer cette librairie avec la commande :
pip install plyer

Note : Raspberry Pi OS n’a pas de démon de notification préinstallé. N’oubliez pas d’installer dunst depuis le dépôt officiel pour voir les notifications. Vous pouvez installer dunst avec la commande :
sudo apt install dunst

On peut ensuite utiliser ça dans notre script Python pour afficher des notifications à chaque fois qu’une mise à jour démarre et se termine avec succès :

from plyer import notification

def show_notification(title, message):
    notification.notify(
        title=title,
        message=message,
        timeout=5
    )

show_notification("System Update", "Starting update...")

Une fois configuré, vous aurez une notification à l’écran à chaque démarrage et fin de mise à jour, comme ci-dessous :

Script de sauvegarde dans le cloud

Sauvegarder ses fichiers, c’est un truc auquel on pense généralement seulement après coup, quand c’est trop tard. Photos, projets, fichiers de log, perdre tout ça à cause d’une carte SD défaillante, c’est franchement rageant. Alors réglons ce problème.

Vous pouvez écrire un script Python qui sauvegarde automatiquement n’importe quel dossier de votre Raspberry Pi vers Google Drive. Vous pouvez le programmer (tous les jours, toutes les semaines, etc.) avec une tâche cron. On va utiliser rclone, un outil puissant qui connecte votre Pi aux services de stockage cloud les plus connus.

Pour utiliser rclone, il faut d’abord l’installer avec la commande :
sudo apt install rclone

Note : N’oubliez pas de configurer rclone pour le lier à votre Google Drive avec la commande :
rclone config

Une fois installé et configuré, vous pouvez utiliser un code Python simple comme celui-ci pour sauvegarder automatiquement le dossier de votre choix sur votre Google Drive :

import subprocess
from datetime import datetime

# Dossier à sauvegarder
source_folder = "/home/pi/projects"

# Dossier de destination dans Google Drive
backup_name = f"backup_{datetime.now().strftime('%Y-%m-%d')}"
remote_folder = f"gdrive:PiBackups/{backup_name}"

# Lancer la sauvegarde
subprocess.run(["rclone", "copy", source_folder, remote_folder])

Vous pouvez aller plus loin en configurant une crontab pour automatiser et exécuter le script à intervalles réguliers (par exemple toutes les nuits). Comme ça, vos données précieuses sont clonées automatiquement sur votre Google Drive.

Vous pouvez utiliser une méthode de notification similaire à celle qu’on a vue pour le script de mise à jour automatique, pour être prévenu quand une sauvegarde a été créée.

Vous pouvez aussi utiliser la fonction sync de rclone pour mettre à jour vos sauvegardes existantes au lieu d’en créer une nouvelle à chaque fois. Autre avantage avec rclone : vous pouvez le configurer pour utiliser Dropbox, OneDrive ou d’autres services d’hébergement de fichiers similaires. Vous n’êtes pas limité à Google Drive.

Si vous voulez découvrir d’autres méthodes pour sauvegarder votre Raspberry Pi, on en parle ici : Le guide ultime pour sauvegarder et restaurer votre Raspberry Pi, notamment avec rsnapshot pour les sauvegardes incrémentales.

Enregistreur d’utilisation des ressources

Vous vous êtes déjà demandé si votre Raspberry Pi chauffait trop ou utilisait trop de mémoire ? Si votre Pi ralentit d’un coup, avoir un historique de performance peut vous aider à comprendre pourquoi.

Il existe plusieurs outils pour surveiller la santé de votre Raspberry Pi, mais la plupart demandent d’être présent sur place. Vous pouvez développer un script Python avec la librairie psutil pour suivre l’utilisation du CPU, de la mémoire et du disque, et être prévenu si quelque chose dépasse une limite définie.

Vous pouvez installer la librairie psutil avec la commande :
pip install psutil

Vous pouvez ensuite utiliser les fonctions intégrées de psutil pour récupérer l’utilisation du CPU, de la RAM et du disque, comme ci-dessous :

import psutil 

cpu = psutil.cpu_percent()
ram = psutil.virtual_memory().percent
disk = psutil.disk_usage('/').percent

Autre statistique importante à surveiller : la température du CPU de votre Raspberry Pi. On peut aussi la récupérer en lisant la valeur dans le fichier /sys/class/thermal/thermal_zone0/temp. Voici comment faire ça en Python :

# Recuperer la température du CPU
def get_cpu_temp():
    try:
        with open("/sys/class/thermal/thermal_zone0/temp", "r") as f:
            temp_str = f.readline()
            return round(int(temp_str) / 1000, 1)
    except FileNotFoundError:
        return None

Vous pouvez ensuite sauvegarder toutes ces données dans un fichier CSV avec la date et l’heure, pour créer un historique consultable plus tard pour analyser les performances du système.

Vous pouvez aussi améliorer ce script en utilisant Pushbullet pour envoyer des notifications si quelque chose devient excessif (par exemple si la température du CPU est trop élevée) pendant que vous êtes absent.

Note : Assurez-vous d’avoir Pushbullet installé et configuré sur votre PC ou votre téléphone pour recevoir les notifications.

Vous pouvez utiliser un script Python, comme ci-dessous, pour envoyer des notifications Pushbullet à tous vos appareils connectés :

import requests

PUSHBULLET_TOKEN = "your_token_here"

def send_alert(msg):
    requests.post(
        "https://api.pushbullet.com/v2/pushes",
        headers={"Access-Token": PUSHBULLET_TOKEN},
        json={"type": "note", "title": "Raspberry Pi Alert", "body": msg}
    )

if temp and temp > TEMP_LIMIT:
    send_alert(f"CPU temperature is high: {temp}°C")

Maintenant, dès que votre Raspberry Pi chauffe trop, vous serez prévenu automatiquement, même si vous êtes loin de lui :

Les notifications Pushbullet peuvent aussi être reçues sur votre téléphone.

Si votre Raspberry Pi surchauffe régulièrement, jetez un œil à ce guide complet : Température du Raspberry Pi : limites, monitoring, refroidissement, et plus.

Extinction d’écran en cas d’inactivité / économie d’énergie

Vous laissez votre Raspberry Pi tourner avec un écran branché ? Si oui, cet écran reste peut-être allumé même quand personne ne l’utilise. Sur la durée, ça gaspille de l’électricité et ça raccourcit la vie de votre écran.

Raspberry Pi OS a une fonction basique de mise en veille de l’écran, qui le fait passer en noir après 10 à 15 minutes d’inactivité. Mais cette fonction se contente de noircir l’écran, la sortie HDMI n’est pas désactivée.

Avec un script Python simple, vous pouvez surveiller l’activité de la souris et du clavier et éteindre l’écran automatiquement après un certain temps. On peut aussi utiliser vgencmd pour couper l’alimentation de la sortie HDMI, ce qui donne une économie d’énergie bien plus importante que la simple mise en noir de l’écran.

Pour surveiller l’activité de votre clavier et de votre souris, vous aurez besoin de la librairie pynput. Vous pouvez l’installer avec la commande :
pip install pynput

Vous pouvez ensuite utiliser un script Python pour surveiller l’utilisation de votre clavier et de votre souris :

import time
from pynput import mouse, keyboard

def reset_timer(x=None):
    global last_input_time
    last_input_time = time.time()

# Set up listeners for keyboard and mouse
keyboard_listener = keyboard.Listener(on_press=reset_timer)
mouse_listener = mouse.Listener(on_move=reset_timer, on_click=reset_timer, on_scroll=reset_timer)

keyboard_listener.start()
mouse_listener.start()

Ensuite, vous pouvez continuer à surveiller le temps d’inactivité. Si ce temps dépasse un certain seuil, vous pouvez utiliser vgencmd pour désactiver la sortie HDMI.

while True:
    idle_duration = time.time() - last_input_time

    if idle_duration > IDLE_TIME and not screen_off:
        subprocess.run(["/usr/bin/vcgencmd", "display_power", "0"])
        screen_off = True
        print("Screen turned OFF due to inactivity.")
        
    elif idle_duration <= IDLE_TIME and screen_off:
        subprocess.run(["/usr/bin/vcgencmd", "display_power", "1"])
        screen_off = False
        print("Activity detected. Screen turned ON.")

    time.sleep(5)

Vous pouvez automatiser ce script et le faire tourner en arrière-plan avec ~/.bashrc, rc.local, ou un service systemd. Ce script peut représenter une belle économie d’énergie, vu que c’est souvent l’écran qui consomme le plus.

Si les commandes Linux ce n’est pas trop votre truc, n’hésitez pas à jeter un œil à cet article qui vous explique les commandes qu’il faut absolument connaître. Je vous donne aussi une antisèche à télécharger pour les avoir toujours sous la main !

Script d’insertion USB

Transférer des fichiers depuis un Raspberry Pi, ça se fait en général via SSH, SCP, ou la synchro cloud. Mais parfois, la méthode la plus simple reste la bonne vieille clé USB.

Mais si vous faites tourner votre Raspberry Pi en mode headless (sans écran) et que vous voulez récupérer des logs, ce serait pas génial de simplement brancher une clé USB et voir votre Raspberry Pi télécharger automatiquement tous les logs pertinents dessus, puis l’éjecter proprement ?

Ça a l’air sorti d’un film de James Bond, mais on peut faire ça avec un simple script Python.

Vous pouvez trouver le chemin de montage de votre clé USB avec le code Python ci-dessous :

import os

MOUNT_ROOT = "/media/pi"
USB_LABEL = "LOGDUMP"  # Optional: use a specific USB label

def find_usb_mount():
    for mount in os.listdir(MOUNT_ROOT):
        mount_path = os.path.join(MOUNT_ROOT, mount)
        if os.path.ismount(mount_path):
            if USB_LABEL and USB_LABEL.lower() not in mount.lower():
                continue
            return mount_path
    return None

Et ensuite l’utiliser pour copier les données sur votre clé USB avec la librairie shutil :

import os
import shutil
import time

SOURCE_DIR = "/var/log/mylogs"
DESTINATION_NAME = f"logs_{time.strftime('%Y%m%d_%H%M%S')}"

def copy_logs(usb_path):
    dest = os.path.join(usb_path, DESTINATION_NAME)
    os.makedirs(dest, exist_ok=True)
    shutil.copytree(SOURCE_DIR, dest, dirs_exist_ok=True)
    print(f"✅ Logs copied to: {dest}")

Mais la vraie magie opère quand vous ajoutez ce script à vos règles udev. Voici comment faire :

• D’abord, rendez votre script Python exécutable avec la commande :
  sudo chmod +x /path/to/your/script.py
• Créez ensuite un script shell « wrapper » contenant ce script bash :
  python3 /path/to/your/script.py
• Rendez ce script shell exécutable aussi.
• Enfin, créez une règle udev avec la commande :
  sudo nano /etc/udev/rules.d/99-usb-log.rules
• Ajoutez-y les lignes suivantes :
  ACTION=="add", SUBSYSTEM=="block", KERNEL=="sd[a-z][0-9]", RUN+="/path/to/your/shell/script.sh"
• Rechargez udev avec la commande :
  sudo udevadm control --reload-rules && sudo udevadm trigger

Maintenant, dès que vous branchez une clé USB, votre Raspberry Pi copie automatiquement tous vos logs dessus, sans avoir besoin d’écran, de clavier ni de souris.

Vous pouvez encore améliorer ce script en ajoutant une méthode d’authentification pour renforcer la sécurité des données, par exemple un token d’authentification enregistré sur votre clé USB, que le script Python vérifiera avant de copier les logs.

À lire aussi : Top 10 des astuces de sauvegarde pour protéger vos données sur Raspberry Pi

Détecteur de mouvement avec caméra et capture d’écran

Transformer son Raspberry Pi en système de sécurité basique paraît compliqué, mais c’est plus simple qu’on ne le pense. Avec un module caméra pour Raspberry Pi et un peu de magie en vision par ordinateur, vous pouvez y arriver facilement.

OpenCV est une librairie open-source compatible avec des langages comme Python et C++. Elle permet de créer des projets de vision par ordinateur et de machine learning. Avec OpenCV, vous pouvez faire de la reconnaissance faciale, de la reconnaissance de gestes, etc.

Vous pouvez configurer votre caméra Raspberry Pi pour l’utiliser avec Python en suivant ce guide : Comment utiliser la caméra Raspberry Pi avec Python en 2025.

Vous pouvez installer OpenCV sur votre Raspberry Pi avec la commande :
sudo apt install python3-opencv

Vous pouvez ensuite utiliser OpenCV dans un script Python pour créer un algorithme de détection de mouvement, comme ci-dessous :

import cv2

# Capture video stream
cam = cv2.VideoCapture(0)

# Read the first frame and preprocess it
_, frame1 = cam.read()
gray1 = cv2.cvtColor(frame1, cv2.COLOR_BGR2GRAY)
gray1 = cv2.GaussianBlur(gray1, (21, 21), 0)

while True:
    # Read the next frame
    _, frame2 = cam.read()
    gray2 = cv2.cvtColor(frame2, cv2.COLOR_BGR2GRAY)
    gray2 = cv2.GaussianBlur(gray2, (21, 21), 0)

    # Compute difference between frames
    delta = cv2.absdiff(gray1, gray2)
    thresh = cv2.threshold(delta, 25, 255, cv2.THRESH_BINARY)[1]
    thresh = cv2.dilate(thresh, None, iterations=2)

    # Find contours (moving areas)
    contours, _ = cv2.findContours(thresh.copy(), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)

    # Check for motion
    motion_detected = any(cv2.contourArea(c) > 1000 for c in contours)

    if motion_detected:
        print("⚠️ Motion detected!")

    # Update the baseline frame
    gray1 = gray2.copy()

    # Exit on 'q'
    if cv2.waitKey(10) == ord('q'):
        break

cam.release()
cv2.destroyAllWindows()

Ce script de détection de mouvement peut ensuite vous envoyer un email avec l’image jointe. Ça se fait aussi avec un code Python simple :

import smtplib
from email.message import EmailMessage

def send_email(image_path):
    # Set up the email details
    msg = EmailMessage()
    msg['Subject'] = '📸 Motion Detected on Raspberry Pi'
    msg['From'] = ''
    msg['To'] = ''
    msg.set_content('Motion detected! See attached snapshot.')

    # Attach the image
    with open(image_path, 'rb') as f:
        msg.add_attachment(f.read(), maintype='image', subtype='jpeg', filename='snapshot.jpg')

    # Send via Gmail (or your preferred SMTP)
    with smtplib.SMTP_SSL('smtp.gmail.com', 465) as smtp:
        smtp.login('', 'your_app_password')
        smtp.send_message(msg)
        print("📧 Email sent successfully!")

En combinant ces deux scripts, votre Raspberry Pi devient une sorte de vigile pour la maison. Dès qu’il détecte un mouvement sur la caméra, il prend une photo et vous l’envoie par email.

Vous pouvez améliorer ce projet en ajoutant un capteur de mouvement HC-SR501 pour renforcer les capacités de détection de votre système.

Vérificateur de disponibilité des appareils

Si vous avez des appareils connectés, des imprimantes, ou même un autre Raspberry Pi sur votre réseau, ça peut être utile de savoir quand l’un d’eux se déconnecte. C’est particulièrement pratique pour administrer vos outils à distance.

Un script Python peut vérifier régulièrement si vos appareils réseau (routeur, imprimante, contrôleurs domotiques) sont bien joignables. En envoyant un ping à leurs adresses IP à intervalles réguliers, le script peut détecter si l’un d’eux passe hors ligne et vous envoyer une notification.

Vérifier la disponibilité de vos appareils avec ping se fait facilement avec le code ci-dessous :

import os
import time

# List of devices to monitor (name, IP address)
devices = {
    "Router": "192.168.1.1",
    "Printer": "192.168.1.100",
    "NAS": "192.168.1.50"
}

def is_reachable(ip):
    return os.system(f"ping -c 1 -W 2 {ip} > /dev/null 2>&1") == 0

while True:
    for name, ip in devices.items():
        if not is_reachable(ip):
            print(f"⚠️ {name} ({ip}) is offline!")
            # Add optional alert here
        else:
            print(f"✅ {name} is reachable.")
    time.sleep(300)  # Wait 5 minutes

Vous pouvez surveiller tous vos appareils, et si l’un d’eux se déconnecte, vous pouvez être prévenu via Pushbullet ou par email, comme on l’a vu dans les sections précédentes.

Voici un exemple de fonction qui envoie une notification via Pushbullet :

import requests

def send_alert(device_name, ip):
    token = "your_pushbullet_token"
    msg = f"{device_name} ({ip}) is offline!"
    requests.post(
        "https://api.pushbullet.com/v2/pushes",
        headers={"Access-Token": token},
        json={"type": "note", "title": "Device Alert", "body": msg}
    )

Avec ce script, vous pouvez surveiller l’état de tous vos appareils connectés à la maison pendant que vous êtes en vacances.

Mais comment être sûr que votre Raspberry Pi lui-même reste allumé ?

Ça peut aussi se faire avec une notification « heartbeat » (battement de cœur). Vous pouvez modifier ce même script Python pour générer des notifications périodiques de ce type.

import time
import requests

def send_heartbeat():
    token = "your_pushbullet_token"
    message = {
        "type": "note",
        "title": "Raspberry Pi Heartbeat",
        "body": "I'm still online. Time: " + time.strftime("%Y-%m-%d %H:%M:%S")
    }
    requests.post("https://api.pushbullet.com/v2/pushes", headers={
        "Access-Token": token
    }, json=message)

while True:
    send_heartbeat()
    print("✅ Heartbeat sent.")
    time.sleep(3600)  # Every hour

Vous pouvez combiner ces scripts Python pour détecter l’état de tous vos appareils connectés à la maison, et celui du Raspberry Pi lui-même. Comme ça, vous êtes tranquille : tout fonctionne comme prévu, même quand vous êtes absent.

Vous pouvez aussi ajouter un monitoring de la vitesse réseau pour vérifier la connectivité globale de votre réseau domestique avec internet, et être alerté si la vitesse de connexion passe sous un certain seuil.

Pour une administration système plus poussée des serveurs connectés via votre Raspberry Pi, jetez un œil à Nagios.

Contrôleur d’éclairage pour Philips Hue ou appareils Tasmota

Le Raspberry Pi peut servir pour plein de projets de domotique. Il existe une multitude d’outils domotiques disponibles. Mais des scripts Python simples peuvent aussi servir à automatiser les lumières de votre maison connectée.

Un script Python peut contrôler des lampes connectées comme Philips Hue ou des ampoules flashées Tasmota. Ces lumières peuvent s’allumer ou s’éteindre selon l’heure de la journée, ou dès qu’un mouvement est détecté.

Il vous faudra installer la librairie phue pour activer cette fonctionnalité en Python. Vous pouvez le faire avec la commande :
pip install phue

Vous aurez besoin de connaître l’adresse IP de votre Hue Bridge pour vous connecter. Petit conseil : lors de la première connexion, vous devrez appuyer sur le bouton de liaison du bridge pour autoriser votre Pi. Vous pouvez initier la connexion avec ce code Python :

from phue import Bridge

bridge_ip = '192.168.1.100'  # Replace with your bridge IP
b = Bridge(bridge_ip)
b.connect()

Une fois connecté, vous pouvez utiliser cette librairie pour contrôler les lumières :

from datetime import datetime

# Turn on a specific light by name
def turn_on_lights():
    b.set_light('Living Room Lamp', 'on', True)

# Turn off all lights at midnight
if datetime.now().hour == 0:
    b.set_light('Living Room Lamp', 'on', False)

En plus de les allumer ou de les éteindre, vous pouvez aussi contrôler la luminosité, les couleurs et les ambiances avec cette librairie.

Si au lieu des lampes Philips Hue, vous utilisez des prises ou ampoules flashées Tasmota, vous pouvez aussi les contrôler avec des requêtes HTTP. Par exemple, ce code permet d’allumer et d’éteindre un appareil flashé Tasmota :

import requests
from datetime import datetime

# Replace with your Tasmota device IP
device_ip = "192.168.1.150"

def turn_light_on():
    requests.get(f"http://{device_ip}/cm?cmnd=Power%20On")

def turn_light_off():
    requests.get(f"http://{device_ip}/cm?cmnd=Power%20Off")

Pour aller encore plus loin dans l’automatisation, combinez ces contrôles avec une simple vérification de date et heure, ou avec le script de détection de mouvement qu’on a vu plus haut. Vous pouvez aussi automatiser tout ça avec des tâches cron.

Vous pouvez également combiner ces scripts avec MQTT pour activer le contrôle à distance de vos appareils connectés à la maison.

Les outils domotiques tout faits sont géniaux et offrent plein de fonctionnalités. Mais développer votre propre script Python permet une personnalisation bien plus poussée.

Moniteur de disponibilité de site web

Si vous hébergez votre site, votre blog ou un serveur perso, c’est bien de savoir quand ça tombe en panne, surtout si ça arrive pendant que vous avez le dos tourné. Rafraîchir manuellement votre navigateur, ce n’est pas vraiment une solution fiable.

Un script Python peut vérifier régulièrement le statut de votre site et vous prévenir s’il renvoie un code d’erreur ou devient trop lent à répondre. Construire votre propre système de monitoring avec la librairie requests ne prend que quelques lignes de code.

Vous pouvez installer la librairie requests avec la commande :
pip install requests

Une fois cette librairie installée, elle permet de développer un script basique de vérification de disponibilité, comme ci-dessous :

import requests
import time

URL = "https://yourwebsite.com"
CHECK_INTERVAL = 300  # 5 minutes

def check_website():
    try:
        response = requests.get(URL, timeout=5)
        if response.status_code != 200:
            print(f"⚠️ Website returned status code {response.status_code}")
        else:
            print(f"✅ Website is online. ({response.status_code})")
    except requests.exceptions.RequestException as e:
        print(f"🚨 Website check failed: {e}")

while True:
    check_website()
    time.sleep(CHECK_INTERVAL)

Vous pouvez ensuite envoyer des notifications via Pushbullet ou email pour être prévenu si le site tombe, ou s’il renvoie une erreur :

import requests

def send_alert(message):
    token = "your_pushbullet_token"
    requests.post(
        "https://api.pushbullet.com/v2/pushes",
        headers={"Access-Token": token},
        json={"type": "note", "title": "Website Down", "body": message}
    )

Vous pouvez utiliser cette fonction dans votre fonction de vérification comme ceci :

if response.status_code != 200:
    send_alert(f"Website returned {response.status_code}")

Vous pouvez encore améliorer ce script pour être alerté si le temps de chargement de votre site devient trop lent. Un chargement lent peut aussi révéler un problème sous-jacent à régler.

response = requests.get(URL, timeout=10)
load_time = response.elapsed.total_seconds()

if load_time > 1.5:
    send_alert(f"⏱️ Website is slow: {load_time:.2f}s")

Vous pouvez combiner ce script avec votre vérificateur de disponibilité d’appareils et votre enregistreur d’utilisation des ressources pour créer un script tout-en-un qui vous tient au courant de tous vos appareils connectés, de votre site web ou blog, et de la santé de votre Raspberry Pi lui-même.

Ressources supplémentaires pour votre Raspberry Pi

Initiation au Raspberry Pi en vidéo
Si vous débutez et voulez passer rapidement à la vitesse supérieure, j’ai exactement ce qu’il vous faut.
Regardez ma formation vidéo qui vous aidera à démarrer du bon bien, choisir votre matériel, installer les meilleures applications et vous lancer directement dans vos premiers projets avec mon aide.
Regarder les vidéos dès maintenant

Maîtrisez votre Raspberry Pi en 30 jours
Vous avez besoin de plus ? Si vous êtes à la recherche des meilleures astuces pour devenir expert sur Raspberry Pi, ce livre est fait pour vous. Développez vos compétences sous Linux et pratiquez via de nombreux projets en suivant mes guides étape par étape. 10% de remise aujourd’hui !
Télécharger le livre au format PDF ici

Maîtrisez Python sur Raspberry Pi
Pas besoin d’être un génie pour coder quelques lignes pour votre Raspberry Pi.
Je vous apprends juste ce qu’il faut sur Python afin de réaliser n’importe quel projet. La seconde partie du livre est d’ailleurs consacrée à des exemples de projets où je vous guide pas à pas.
Ne perdez pas de temps, apprenez le strict nécessaire et économisez 10% avec ce lien :
Télécharger maintenant

Autres ressources pour profiter de votre Raspberry Pi
J’ai regroupé toutes mes recommandations de logiciels, sites utiles et de matériel sur cette page de ressources. Je vous invite à la consulter régulièrement pour faire les bons choix et rester à jour.
Visiter les pages ressources