Peut-on allumer un Raspberry Pi à distance ? (Wake-On-Lan)

Je ne compte plus le nombre de fois où j’ai voulu allumer mon Raspberry Pi depuis une autre pièce, ou à l’autre bout de la ville. Que ce soit pour faire fonctionner un Pi headless et lancer des sauvegardes à distance ou pour éteindre un serveur multimédia pour économiser de l’énergie. Je voulais un moyen simple de réveiller les appareils depuis n’importe où, j’ai donc testé quelques solutions et vous partage tout ce que j’ai appris dans ce guide.

La technologie Wake-on-LAN (WOL) permet à un ordinateur d’être allumé à distance en envoyant un paquet réseau spécial appelé « magic packet ». Bien que le Raspberry Pi ne dispose pas de la capacité WOL, quelques solutions de contournement existent pour recréer cette fonctionnalité.

Dans ce guide, je vais vous montrer comment allumer un Raspberry Pi à distance en utilisant une prise connectée ou un ESP32, puis utiliser ce Pi pour allumer votre ordinateur principal ou votre serveur en WOL. Je vous dirai également comment le contrôler de manière sûre et fiable via Internet.

Si vous débutez avec Raspberry Pi ou Linux, j’ai quelque chose qui peut vous aider !
Téléchargez ma fiche mémo des commandes Linux gratuitement – c’est un guide de référence rapide avec toutes les commandes essentielles dont vous aurez besoin utiliser votre Raspberry Pi. Cliquez ici pour l’obtenir gratuitement !

Pourquoi utiliser Wake-On-LAN

Wake-on-LAN (WOL) est une fonctionnalité qui vous permet de réveiller à distance votre ordinateur depuis un état de faible consommation en lui envoyant un magic packet par ethernet. Vous pouvez réaliser cela sur des serveurs informatiques ordinaires en modifiant les paramètres du BIOS et du système d’exploitation pour activer le WOL.

La fonction Wake-on-LAN vous permet d’allumer votre ordinateur à distance. Cette fonctionnalité est utile à toute personne ayant une installation à domicile qui souhaite accéder à son système à distance ainsi qu’aux professionnels de l’informatique qui ont besoin de réaliser des mises à jour ou faire de l’administration système en dehors des heures de travail habituelles.

WOL est une excellente fonctionnalité qui peut vous aider à réduire la consommation énergétique de votre installation. Malheureusement, le Raspberry Pi ne supporte pas le WOL. La seule façon d’allumer un Raspberry Pi est de brancher le câble d’alimentation USB ou d’utiliser les GPIO.

Cependant, avec un peu de créativité, vous pouvez créer une configuration Raspberry Pi qui peut être allumée à distance. Vous pouvez ensuite utiliser cet appareil comme hub qui envoie des paquets magiques aux PC ou serveurs pour les allumer.

Comment allumer un Raspberry Pi à distance ?

Bien que le Raspberry Pi n’ait pas de capacités WOL, il existe quelques moyens créatifs pour allumer votre Raspberry Pi à distance. Dans ce guide, nous mentionnerons deux de ces options.

Utiliser un interrupteur connnecté ou une prise connectée

La façon la plus simple d’allumer votre Raspberry Pi à distance est d’utiliser un interrupteur connecté. Des interrupteurs connectés comme celui-ci sur Amazon vous permettent de contrôler la prise de courant via votre appareil mobile en local par Wi-Fi ou à distance via Internet.

Cet interrupteur connecté vous permet d’alimenter votre Raspberry Pi en utilisant le câble du chargeur. Étant donné que le Raspberry Pi démarre automatiquement à l’allumage, vous pouvez le mettre en marche et l’éteindre à distance.

L’avantage apparent de cette configuration est la facilité d’installation, et je recommande cette option à tous les débutants.

Un inconvénient est que le Raspberry Pi s’éteint brusquement chaque fois que vous éteignez la prise connectée. Bien qu’il soit parfois acceptable d’éteindre brutalement le Raspberry Pi (en anglais), cela peut entraîner une corruption des données si certains processus sont en cours d’exécution.

Utiliser une Carte ESP32 (Fabriquer son propre interrupteur / prise connectée)

Si vous êtes un peu plus à l’aise avec la technologie et que vous souhaitez fabriquer votre propre interrupteur connecté qui éteint en toute sécurité votre Raspberry Pi, vous pouvez également le faire. Pour cela, nous pouvons utiliser un ESP32 avec des capacités Wi-Fi pour allumer le Raspberry Pi.

Ce dont vous aurez besoin

Pour ce projet, vous aurez besoin des éléments suivants :

• ESP32 WROOM (Amazon Link).
• Module de relais 5V (Amazon Link).
• Veroboard ou HAT de prototypage pour Raspberry Pi (Amazon Link) (Adafruit Link).
• Quelques compétences en soudure.
• Compréhension de la programmation ESP32.

Schéma de câblage

Pour activer la fonctionnalité d’allumage/extinction à distance, vous devez insérer un ESP32 et un module de relais 5V entre notre adaptateur secteur et le Raspberry Pi. Pour cela, suivez ce schéma de câblage :

Comme vous pouvez le voir, nous avons connecté l’ESP32 et le module de relais 5V directement au fil rouge de l’adaptateur secteur. Cependant, nous avons connecté le Raspberry Pi via la connexion normalement ouverte (NO) du relais.

Le contrôle du module relais est connecté à la broche D19 de l’ESP32, et donc, le relais sera contrôlé par l’ESP32.

De plus, nous avons connecté D17 de l’ESP32 directement au GPIO17 du Raspberry Pi. Cela permet à notre ESP32 de communiquer avec le Raspberry Pi pour permettre un arrêt sécurisé au lieu d’un retrait brusque de l’alimentation (l’un des avantages clés de cette méthode par rapport au Smart Switch).

Pour créer un circuit avec votre Raspberry Pi, envisagez d’utiliser la carte de prototypage Adafruit pour améliorer l’apparence et l’organisation de votre produit final.

Firmware ESP32

Le firmware nécessaire pour ce projet comporte deux composantes principales. D’abord, le système doit recevoir des commandes de votre appareil mobile vers l’ESP32. Ensuite, en fonction des commandes reçues, l’ESP32 changera le statut des broches D17 et D19 en conséquence.

Nous pouvons configurer notre ESP32 comme un abonné MQTT pour recevoir des commandes via Internet. Pour vous familiariser avec MQTT, lisez ce tutoriel sur la mise en place d’un Broker MQTT sur votre Raspberry Pi (en anglais). Vous pouvez également lire cet excellent guide sur comment configurer un ESP32 en tant qu’abonné MQTT.

Une fois que vous vous êtes familiarisé avec l’utilisation de MQTT pour recevoir des commandes à distance, vous pouvez utiliser ce programme pour permettre à votre ESP32 d’allumer et d’éteindre en toute sécurité votre Raspberry Pi :

// Inclure les bibliothèques nécessaires
#include 
#include 
// ---------- Identifiants Wi-Fi ----------
const char* ssid = "YOUR_WIFI_SSID";          // Votre SSID WiFi
const char* password = "YOUR_WIFI_PASSWORD";  // Votre mot de passe WiFi
// ---------- Détails du Broker MQTT ----------
const char* mqtt_server = "test.mosquitto.org"; // Broker MQTT public à des fins de test
const int mqtt_port = 1883;                     // Port par défaut MQTT
const char* mqtt_topic = "raspberrypi/control"; // Sujet MQTT auquel s'abonner pour le contrôle du Raspberry Pi
cpp
// MQTT Client and WiFi Client instances
WiFiClient espClient;
PubSubClient client(espClient);
// ---------- ESP32 GPIO pins ----------
const int relayPin = 19;            // Broche GPIO contrôlant le relais (alimentation au Raspberry Pi)
const int shutdownPin = 17;         // Broche GPIO signalant au Raspberry Pi d'initier un arrêt en toute sécurité
// ---------- Temps d'arrêt configurable (millisecondes) ----------
unsigned long shutdownWaitTime = 15000; // Temps d'attente par défaut de 15 secondes (peut être ajusté à distance)
// ---------- La fonction setup s'exécute une fois au démarrage ----------
void setup() {
  // Démarrer la communication série pour le débogage
  Serial.begin(115200);
  // Initialiser la broche du relais en tant que OUTPUT
  pinMode(relayPin, OUTPUT);
  digitalWrite(relayPin, LOW);  // Relais OFF initialement
  // Initialiser la broche d'arrêt en tant que OUTPUT
  pinMode(shutdownPin, OUTPUT);
  digitalWrite(shutdownPin, LOW);  // Initialement LOW
  // Connexion au réseau Wi-Fi
  Serial.print("Connexion au WiFi");
  WiFi.begin(ssid, password);
  // Attendre jusqu'à la connexion au Wi-Fi
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnexion WiFi réussie!");
  
  // Configurer le serveur MQTT et la fonction de rappel
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
  // Établir une connexion initiale au courtier MQTT
  reconnect();
}
// ---------- Fonction de rappel MQTT ----------
// Cette fonction s'exécute chaque fois qu'un nouveau message arrive sur les sujets abonnés
void callback(char* topic, byte* message, unsigned int length) {
  String command = "";
cpp
// Convert incoming byte message to a String
for (int i = 0; i < length; i++) {
  command += (char)message[i];
}
Serial.print("Commande MQTT reçue : ");
Serial.println(command);
// Traiter la commande reçue
if (command == "ON") {
  digitalWrite(relayPin, HIGH);  // Activer l'alimentation du Raspberry Pi
  Serial.println("Raspberry Pi allumé");
}
else if (command.startsWith("OFF")) {
  Serial.println("Procédure d'arrêt sécurisé en cours");
  // Vérifier si le temps d'attente pour l'arrêt est inclus (format : OFF:temps_en_secondes)
  int separatorIndex = command.indexOf(':');
  if (separatorIndex != -1) {
    String waitTimeStr = command.substring(separatorIndex + 1);
    unsigned long waitTimeSec = waitTimeStr.toInt();
    shutdownWaitTime = waitTimeSec * 1000;
    Serial.print("Temps d'attente pour l'arrêt configuré : ");
    Serial.print(waitTimeSec);
    Serial.println(" secondes");
  }
  // Signaler au Raspberry Pi l'arrêt sécurisé
  digitalWrite(shutdownPin, HIGH);
  delay(500);  // Durée du signal de 500ms
  digitalWrite(shutdownPin, LOW);
  // Attendre que le Raspberry Pi s'éteigne en toute sécurité
  Serial.print("Attente de ");
  Serial.print(shutdownWaitTime / 1000);
  Serial.println(" secondes pour l'arrêt sécurisé...");
  delay(shutdownWaitTime);
  digitalWrite(relayPin, LOW);  // Désactiver l'alimentation du Raspberry Pi
  Serial.println("Raspberry Pi éteint");
}
// ---------- Fonction reconnecter pour MQTT ----------
// Tente de se reconnecter au broker MQTT en cas de déconnexion
void reconnect() {
  while (!client.connected()) {
    Serial.print("Connexion au broker MQTT en cours...");
cpp
// Attempt to connect to the MQTT broker
if (client.connect("ESP32_Client")) {
  Serial.println("connected");
  client.subscribe(mqtt_topic);  // Subscribe to the control topic
  Serial.println("Subscribed to MQTT topic successfully");
}
else {
  Serial.print("Failed, rc=");
  Serial.print(client.state());
  Serial.println(", retrying in 5 seconds");
  delay(5000);  // Wait 5 seconds before retrying
}
}
// ---------- Main loop function ----------
// Continuously checks MQTT connection and processes incoming messages
void loop() {
if (!client.connected()) {
  reconnect();  // Reconnect if disconnected
}
client.loop();  // Process MQTT events
}

Une fois que vous avez assemblé le circuit complet et téléchargé le firmware avec la configuration correcte sur votre ESP32, vous pouvez allumer et éteindre votre Raspberry Pi à distance.

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 !

Comment utiliser un Raspberry Pi comme serveur Wake-On-LAN ?

Bien que le Raspberry Pi ne puisse pas être réveillé en utilisant le Wake-On-LAN (WOL), il peut être utilisé pour réveiller votre serveur une fois qu’il a été mis sous tension en utilisant les méthodes précédentes. Cette configuration en chaîne vous permet de réveiller l’ensemble de votre système de serveur à distance.

Configuration de votre serveur

Avant de configurer votre Raspberry Pi pour envoyer le paquet magique, nous devons configurer le serveur pour qu’il soit prêt à s’allumer lorsqu’il en reçoit un.

La première chose à faire est de l’activer dans le BIOS de votre ordinateur. Vous devez activer les paramètres « Wake On LAN/WLAN » et désactiver les paramètres « Deep Sleep ». Les étapes exactes dépendent du fabricant de votre PC/Serveur.

Le plus souvent, vous devez appuyer sur une touche comme Del ou F2 pour accéder aux paramètres du BIOS, puis vous pouvez changer les paramètres à partir de là.

Ensuite, nous devons configurer les pilotes réseau pour activer le WOL. Les étapes exactes dépendent du système d’exploitation sur lequel votre serveur fonctionne.

Windows Server

Si votre serveur fonctionne sous une version de Windows, vous pouvez suivre ces étapes :

• Ouvrez Device Manager et naviguez jusqu’à votre adaptateur réseau.
  
• Faites un clic droit et sélectionnez Properties, allez à Power Management, et activez « Allow this device to wake the computer«  et « Only allow a magic packet to wake the computer ».
• Allez à l’onglet « Advanced« , choisissez « Energy-Efficient Ethernet« , et désactivez-le.
  
• Cliquez sur « OK » et fermez le Gestionnaire de périphériques.
• Allez à « Control Panel » -> « Hardware and Sound » -> « Power Options » -> « Choose what the power button do » et cliquez sur « Change settings that are currently unavailable« .
  
• Désactivez « Turn on fast startup » et cliquez sur « Save changes« .
  
• Maintenant, pour trouver l’adresse MAC de votre port Ethernet, ouvrez une invite de commande et saisissez cette commande :
  ipconfig /all
  

Avec ces configurations, à chaque fois qu’un paquet magique est reçu sur le port LAN de cet ordinateur, il allume automatiquement votre serveur.

Serveur Ubuntu

Si votre serveur fonctionne plutôt sur Ubuntu ou tout autre OS Linux, vous pouvez suivre ces étapes :

• Ouvrez un terminal et entrez cette commande pour voir tous les adaptateurs réseau disponibles et leur adresse MAC :
  ip a
  
• Notez le nom de la connexion et son adresse MAC.
• Vérifiez que WOL est pris en charge en utilisant cette commande :
  sudo ethtool <Adapter Name> | grep "Wake-on"
  
• Si la lettre ‘g’ est présente dans « Supports Wake-on », alors WOL est pris en charge.
• Activez WOL en utilisant cette commande :
  
• Ensuite, créez un service en utilisant cette commande :
  sudo nano /lib/systemd/system/wakeonlan.service
  
• Nous pouvons ensuite activer ce service en utilisant cette commande :
  sudo systemctl enable wakeonlan.service
  

Et voilà ; nous avons configuré notre serveur Ubuntu pour activer le WOL.

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 !

Installation de l’outil WOL sur Raspberry Pi

Après avoir configuré notre serveur pour qu’il se réveille lorsqu’il reçoit le paquet magique, nous devons maintenant configurer notre Raspberry Pi pour qu’il puisse envoyer le paquet magique. Pour ce faire, suivez ces étapes :

• Assurez-vous que votre Raspberry Pi est à jour en utilisant la commande suivante :
  sudo apt update && sudo apt full-upgrade
  
• Installez etherwake depuis le dépôt officiel en utilisant apt :
  sudo apt install etherwake
  
• Maintenant nous pouvons envoyer le paquet magique en utilisant la commande suivante (remplacez AA:BB:CC:DD:EE:FF par l’adresse MAC réelle de votre PC serveur) :
  sudo etherwake -i eth0 AA:BB:CC:DD:EE:FF

C’est tout ; nous avons installé l’outil WOL sur notre Raspberry Pi. Avant de continuer avec le tutoriel, je vous conseille de tester cette commande avec votre Raspberry Pi et votre serveur et de vérifier localement que chaque fois que vous envoyez cette commande, votre PC serveur se réveille.

Cette configuration vous permet d’allumer à distance votre Raspberry Pi avec votre ESP32 et MQTT. Ensuite, vous pouvez utiliser SSH + Tailscale ou RPIConnect pour vous connecter à distance à votre Raspberry Pi et réveiller votre PC serveur en exécutant la commande etherwake dans un terminal.

Tout combiner et automatiser

La configuration décrite ci-dessus est efficace, nous permettant de réveiller à distance notre Raspberry Pi et de l’utiliser pour réveiller notre PC serveur. Cependant, nous pouvons améliorer cela en intégrant tout le système dans un produit complet.

Nous pouvons écrire un script Python pour notre Raspberry Pi afin qu’il se connecte à notre courtier MQTT et reçoive des commandes de notre mobile/ordinateur portable lorsque nous sommes absents. En utilisant cela, nous pouvons créer un tableau de bord centralisé basé sur MQTT sur notre appareil mobile avec un interrupteur pour le Raspberry Pi et un autre pour chaque serveur PC.

Pour cela, j’ai écrit un programme Python simple que vous pouvez utiliser :

import paho.mqtt.client as mqtt
from wakeonlan import send_magic_packet
import re

# ---------- Configuration ----------
MQTT_BROKER = "test.mosquitto.org"  # Same as ESP32
MQTT_PORT = 1883
MQTT_TOPIC = "raspberrypi/control"

# ---------- Regular expression to validate MAC address ----------
MAC_REGEX = re.compile(r'^WAKE:([0-9A-Fa-f]{2}:){5}[0-9A-Fa-f]{2}$')

# ---------- MQTT Callback Functions ----------
def on_connect(client, userdata, flags, rc):
    if rc == 0:
        print("Connecté au courtier MQTT!")
        client.subscribe(MQTT_TOPIC)
        print(f"Abonné au sujet: {MQTT_TOPIC}")
    else:
        print(f"Échec de connexion, code de retour {rc}")

def on_message(client, userdata, msg):
    payload = msg.payload.decode().strip()
    print(f"Message MQTT reçu: {payload}")

    if MAC_REGEX.match(payload):
        mac = payload.split(":", 1)[1]
        print(f"Commande WAKE valide reçue. Envoi de paquet magique à MAC: {mac}")
        send_magic_packet(mac)
    else:
        print("Format de commande WAKE invalide. Utiliser : WAKE:AA:BB:CC:DD:EE:FF")

# ---------- Setup MQTT Client ----------
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION1,"RaspberryPi_WOL")
client.on_connect = on_connect
client.on_message = on_message

client.connect(MQTT_BROKER, MQTT_PORT, 60)

# ---------- Blocking loop ----------
try:
    print("Démarrage de la boucle MQTT...")
    client.loop_forever()
except KeyboardInterrupt:
    print("Sortie...")
    client.disconnect()

Avec ce programme qui tourne sur votre Raspberry Pi, vous pouvez envoyer une charge utile MQTT via le même courtier MQTT. Pour allumer un serveur, vous pouvez envoyer la charge utile : WAKE:AA:BB:CC:DD:EE:FF où AA:BB:CC:DD:EE:FF est l’adresse MAC du PC serveur que vous essayez de réveiller.

Remarque : Pensez à sécuriser cette configuration. Après avoir tout testé, je recommande de passer à un broker MQTT privé ou sécurisé au lieu de compter sur un broker public, comme celui mentionné dans ce tutoriel.
Vous pouvez suivre ce tutoriel pour configurer votre propre broker MQTT (en anglais).

Aller un peu plus loin

Voici quelques idées pour encore améliorer et perfectionner le projet :

• Ajouter une fonctionnalité d’arrêt pour éteindre à distance vos serveurs Linux ou Windows en utilisant SSH ou RPC.
• Déclencher des alertes e-mail ou Telegram lorsqu’un serveur est allumé/éteint ou cesse de répondre.
• Suivre le temps de disponibilité et la disponibilité des appareils en pingant périodiquement chaque serveur et en affichant le statut.

En complétant ce tutoriel, vous avez configuré votre contrôle à distance pour allumer votre Raspberry Pi et vos serveurs domestiques pendant votre absence, vous permettant de les gérer sans les garder allumés.

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