AWS IoT
La plateforme complète qui connecte vos objets au cloud, permettant une communication bidirectionnelle sécurisée et une analyse intelligente des données IoT.
Qu'est-ce qu'AWS IoT ?
Imaginez pouvoir communiquer avec tous les objets qui vous entourent : votre réfrigérateur, votre système d'arrosage, votre thermostat, ou même les plantes de votre jardin.
AWS IoT est comme un traducteur universel qui permet à ces objets de se connecter à internet, d'envoyer des informations au cloud, et de recevoir des instructions. C'est la plateforme qui rend possible la maison intelligente et l'industrie connectée.
Pourquoi est-ce important ?
Information en temps réel
Savoir instantanément ce qui se passe : niveau d'humidité des plantes, température ambiante, consommation d'énergie...
Contrôle à distance
Piloter vos appareils de n'importe où : allumer des lumières, ajuster le chauffage, ou activer l'arrosage depuis votre smartphone.
En résumé, AWS IoT transforme des objets ordinaires en appareils intelligents, communiquant avec le cloud pour vous offrir plus de confort, d'économies d'énergie et de nouvelles possibilités d'automatisation.
Fonctionnement technique
AWS IoT est un ensemble de services cloud qui permettent de connecter, gérer et analyser les appareils IoT à grande échelle. Il offre une infrastructure sécurisée pour la communication bidirectionnelle entre les appareils connectés et AWS.
Les composants clés
AWS IoT Core
Le service principal qui permet aux appareils de se connecter au cloud de manière sécurisée, en utilisant des protocoles comme MQTT, HTTP et WebSockets. Il gère l'authentification, l'autorisation et le routage des messages vers d'autres services AWS comme 
AWS Lambda ou 
DynamoDB.
Voici un exemple de capteur d'humidité Arduino/ESP32 qui envoie des données à AWS IoT :
// Exemple de code Arduino pour capteur d'humidité avec connexion à AWS IoT
#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <DHT.h>
// Configuration Wi-Fi
const char* ssid = "votre_ssid_wifi";
const char* password = "votre_mot_de_passe_wifi";
// Configuration AWS IoT
const char* aws_iot_endpoint = "xxxxxxx-ats.iot.us-east-1.amazonaws.com";
const int aws_iot_port = 8883;
const char* client_id = "plant_monitor_device";
const char* publish_topic = "plant/moisture/data";
// Configuration capteur DHT
#define DHTPIN 4 // Le pin où est connecté le capteur DHT
#define DHTTYPE DHT22 // DHT 22 (AM2302)
DHT dht(DHTPIN, DHTTYPE);
// Configuration capteur d'humidité du sol
const int soilMoisturePin = 36; // Pin analogique pour le capteur d'humidité
const int dryValue = 3600; // Valeur lue quand le sol est sec
const int wetValue = 1200; // Valeur lue quand le sol est mouillé
// Variables globales
WiFiClientSecure wifi_client;
PubSubClient mqtt_client(wifi_client);
unsigned long lastPublishTime = 0;
const unsigned long publishInterval = 60000; // Publier une fois par minute
void setup() {
Serial.begin(115200);
dht.begin();
// Connexion au Wi-Fi
connectToWiFi();
// Configuration du client MQTT
setupMQTT();
}
void loop() {
// Maintenir la connexion MQTT
if (!mqtt_client.connected()) {
reconnectMQTT();
}
mqtt_client.loop();
// Publier des données à intervalle régulier
unsigned long currentTime = millis();
if (currentTime - lastPublishTime >= publishInterval) {
publishSensorData();
lastPublishTime = currentTime;
}
}
void connectToWiFi() {
Serial.print("Connexion au Wi-Fi");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("Wi-Fi connecté!");
Serial.print("Adresse IP: ");
Serial.println(WiFi.localIP());
}
void setupMQTT() {
// Configuration des certificats TLS (code omis pour simplifier l'exemple)
mqtt_client.setServer(aws_iot_endpoint, aws_iot_port);
}
void reconnectMQTT() {
while (!mqtt_client.connected()) {
Serial.print("Tentative de connexion à AWS IoT...");
if (mqtt_client.connect(client_id)) {
Serial.println("Connecté à AWS IoT!");
} else {
Serial.print("Échec, rc=");
Serial.print(mqtt_client.state());
Serial.println(" Nouvelle tentative dans 5 secondes");
delay(5000);
}
}
}
void publishSensorData() {
// Lire l'humidité et la température
float humidity = dht.readHumidity();
float temperature = dht.readTemperature();
// Lire l'humidité du sol
int soilMoistureRaw = analogRead(soilMoisturePin);
int soilMoisturePercent = map(soilMoistureRaw, dryValue, wetValue, 0, 100);
soilMoisturePercent = constrain(soilMoisturePercent, 0, 100);
// Vérifier si les lectures sont valides
if (isnan(humidity) || isnan(temperature)) {
Serial.println("Échec de lecture depuis le capteur DHT!");
return;
}
// Créer un objet JSON pour les données
StaticJsonDocument<200> doc;
doc["device_id"] = client_id;
doc["temperature"] = temperature;
doc["humidity"] = humidity;
doc["soil_moisture"] = soilMoisturePercent;
doc["timestamp"] = millis();
// Convertir le document JSON en chaîne
char jsonBuffer[512];
serializeJson(doc, jsonBuffer);
// Publier sur AWS IoT
Serial.println("Publication des données du capteur:");
Serial.println(jsonBuffer);
if (mqtt_client.publish(publish_topic, jsonBuffer)) {
Serial.println("Publication réussie!");
} else {
Serial.println("Échec de publication");
}
}AWS IoT Device Shadow
Représentation virtuelle d'un appareil qui stocke son état actuel et désiré, permettant aux applications de communiquer avec les appareils même lorsqu'ils sont hors ligne. Les shadows synchronisent automatiquement l'état lorsque l'appareil se reconnecte.
La fonction Shadow est particulièrement utile pour les appareils qui peuvent être intermittents, comme des dispositifs sur batterie ou ceux avec une connectivité instable.
AWS IoT Rules Engine
Moteur d'analyse et de transformation des messages qui permet de définir des actions à déclencher lorsque des données spécifiques sont reçues. Les règles sont écrites en SQL et peuvent déclencher des actions comme l'envoi de notifications 
SNS, l'invocation de fonctions Lambda, ou le stockage de données dans DynamoDB.
// AWS IoT Rule pour enregistrer les données dans DynamoDB
{
"sql": "SELECT device_id, temperature, humidity, soil_moisture, timestamp FROM 'plant/moisture/data'",
"actions": [
{
"dynamoDB": {
"tableName": "plant_moisture_data",
"roleArn": "arn:aws:iam::123456789012:role/PlantMonitorDynamoDBRole",
"hashKeyField": "device_id",
"hashKeyValue": "${device_id}",
"rangeKeyField": "timestamp",
"rangeKeyValue": "${timestamp}",
"payloadField": "data"
}
},
{
"sns": {
"targetArn": "arn:aws:sns:us-east-1:123456789012:plant_alert",
"roleArn": "arn:aws:iam::123456789012:role/PlantMonitorSNSRole",
"messageFormat": "JSON"
}
}
]
}Contrôle des appareils
AWS IoT permet également de contrôler les appareils à distance, en envoyant des commandes depuis le cloud. Par exemple, voici comment contrôler des LED RGB avec une bande FastLED :
// Exemple de code Arduino pour contrôler des LEDs via AWS IoT
#include <WiFi.h>
#include <PubSubClient.h>
#include <ArduinoJson.h>
#include <FastLED.h>
// Configuration Wi-Fi
const char* ssid = "votre_ssid_wifi";
const char* password = "votre_mot_de_passe_wifi";
// Configuration AWS IoT
const char* aws_iot_endpoint = "xxxxxxx-ats.iot.us-east-1.amazonaws.com";
const int aws_iot_port = 8883;
const char* client_id = "led_control_device";
const char* subscribe_topic = "device/leds/control";
// Configuration FastLED
#define LED_PIN 5
#define NUM_LEDS 30
#define LED_TYPE WS2812B
#define COLOR_ORDER GRB
CRGB leds[NUM_LEDS];
// Variables globales
WiFiClientSecure wifi_client;
PubSubClient mqtt_client(wifi_client);
void setup() {
Serial.begin(115200);
// Initialisation des LEDs
FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS).setCorrection(TypicalLEDStrip);
FastLED.setBrightness(50); // Luminosité à 50/255
// LED par défaut (toutes éteintes)
fill_solid(leds, NUM_LEDS, CRGB::Black);
FastLED.show();
// Connexion au Wi-Fi
connectToWiFi();
// Configuration du client MQTT
setupMQTT();
}
void loop() {
// Maintenir la connexion MQTT
if (!mqtt_client.connected()) {
reconnectMQTT();
}
mqtt_client.loop();
// Le reste du traitement est géré dans la fonction de callback
}
void connectToWiFi() {
Serial.print("Connexion au Wi-Fi");
WiFi.begin(ssid, password);
while (WiFi.status() != WL_CONNECTED) {
delay(500);
Serial.print(".");
}
Serial.println();
Serial.println("Wi-Fi connecté!");
Serial.print("Adresse IP: ");
Serial.println(WiFi.localIP());
}
void setupMQTT() {
// Configuration des certificats TLS (code omis pour simplifier l'exemple)
mqtt_client.setServer(aws_iot_endpoint, aws_iot_port);
mqtt_client.setCallback(messageReceived);
}
void reconnectMQTT() {
while (!mqtt_client.connected()) {
Serial.print("Tentative de connexion à AWS IoT...");
if (mqtt_client.connect(client_id)) {
Serial.println("Connecté à AWS IoT!");
// S'abonner au topic de contrôle
mqtt_client.subscribe(subscribe_topic);
Serial.println("Abonné au topic de contrôle");
} else {
Serial.print("Échec, rc=");
Serial.print(mqtt_client.state());
Serial.println(" Nouvelle tentative dans 5 secondes");
delay(5000);
}
}
}
void messageReceived(char* topic, byte* payload, unsigned int length) {
Serial.print("Message reçu [");
Serial.print(topic);
Serial.print("]: ");
// Convertir le payload en chaîne
char message[length + 1];
for (int i = 0; i < length; i++) {
message[i] = (char)payload[i];
}
message[length] = '\0';
Serial.println(message);
// Analyser le message JSON
StaticJsonDocument<200> doc;
DeserializationError error = deserializeJson(doc, message);
if (error) {
Serial.print("Erreur d'analyse JSON: ");
Serial.println(error.c_str());
return;
}
// Extraire les données
const char* action = doc["action"];
if (strcmp(action, "set_color") == 0) {
int r = doc["red"];
int g = doc["green"];
int b = doc["blue"];
// Définir la couleur de toutes les LEDs
fill_solid(leds, NUM_LEDS, CRGB(r, g, b));
FastLED.show();
Serial.printf("Couleur définie à RGB(%d, %d, %d)\n", r, g, b);
}
else if (strcmp(action, "rainbow") == 0) {
// Effet arc-en-ciel
fill_rainbow(leds, NUM_LEDS, 0, 7);
FastLED.show();
Serial.println("Mode arc-en-ciel activé");
}
else if (strcmp(action, "off") == 0) {
// Éteindre toutes les LEDs
fill_solid(leds, NUM_LEDS, CRGB::Black);
FastLED.show();
Serial.println("LEDs éteintes");
}
}Interaction depuis Node.js
Côté backend, nous pouvons utiliser le SDK AWS pour Node.js afin d'envoyer des commandes aux appareils IoT :
// Exemple de code Node.js pour envoyer des commandes à un appareil via AWS IoT
const AWS = require('aws-sdk');
const { v4: uuidv4 } = require('uuid');
// Configuration des informations d'identification AWS
AWS.config.update({
region: 'us-east-1',
credentials: new AWS.Credentials({
accessKeyId: process.env.AWS_ACCESS_KEY_ID,
secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY
})
});
// Créer une instance du client AWS IoT
const iotData = new AWS.IotData({
endpoint: 'xxxxxxx-ats.iot.us-east-1.amazonaws.com'
});
// Fonction pour contrôler les LEDs
async function controlLeds(action, color = null) {
// Préparer le message
const message = {
timestamp: Date.now(),
requestId: uuidv4(),
action: action
};
// Ajouter des informations de couleur si nécessaire
if (action === 'set_color' && color) {
message.red = color.red;
message.green = color.green;
message.blue = color.blue;
}
// Paramètres pour publier sur AWS IoT
const params = {
topic: 'device/leds/control',
payload: JSON.stringify(message),
qos: 0
};
try {
// Publier le message
const result = await iotData.publish(params).promise();
console.log('Message envoyé avec succès:', message);
return result;
} catch (error) {
console.error('Erreur lors de l'envoi du message:', error);
throw error;
}
}
// Exemples d'utilisation
async function runExamples() {
try {
// Allumer les LEDs en rouge
await controlLeds('set_color', { red: 255, green: 0, blue: 0 });
console.log('LEDs allumées en rouge');
// Attendre 5 secondes
await new Promise(resolve => setTimeout(resolve, 5000));
// Activer le mode arc-en-ciel
await controlLeds('rainbow');
console.log('Mode arc-en-ciel activé');
// Attendre 5 secondes
await new Promise(resolve => setTimeout(resolve, 5000));
// Éteindre les LEDs
await controlLeds('off');
console.log('LEDs éteintes');
} catch (error) {
console.error('Erreur lors de l'exécution des exemples:', error);
}
}
// Exécuter les exemples
runExamples();AWS IoT Button
Un exemple pratique est l'AWS IoT Button, un bouton programmable qui peut déclencher diverses actions dans le cloud. Voici un exemple de fonction Lambda traitant les événements d'un bouton IoT pour contrôler des LEDs :
// Code AWS Lambda pour traiter les événements AWS IoT Button
exports.handler = async (event, context) => {
console.log('Événement IoT Button reçu:', JSON.stringify(event, null, 2));
// Extraire les informations du bouton
const buttonSerialNumber = event.serialNumber;
const clickType = event.clickType; // 'SINGLE', 'DOUBLE', ou 'LONG'
const batteryVoltage = event.batteryVoltage;
let action;
// Déterminer l'action en fonction du type de clic
switch (clickType) {
case 'SINGLE':
action = {
command: 'set_color',
color: { red: 0, green: 0, blue: 255 } // Bleu
};
break;
case 'DOUBLE':
action = {
command: 'rainbow'
};
break;
case 'LONG':
action = {
command: 'off'
};
break;
default:
return {
statusCode: 400,
body: 'Type de clic non reconnu'
};
}
try {
// Envoyer la commande à l'appareil IoT
// (En production, vous appelleriez une fonction pour publier sur AWS IoT)
console.log(`Envoi de la commande ${action.command} pour le bouton ${buttonSerialNumber}`);
return {
statusCode: 200,
body: JSON.stringify({
message: 'Commande traitée avec succès',
buttonSerialNumber,
clickType,
action
})
};
} catch (error) {
console.error('Erreur lors du traitement de la commande:', error);
return {
statusCode: 500,
body: 'Erreur lors du traitement de la commande'
};
}
};Services complémentaires
- AWS IoT Analytics - Service entièrement géré pour l'analyse des données IoT à grande échelle
- AWS IoT Events - Service de détection et de réponse aux événements des appareils IoT
- AWS IoT SiteWise - Service pour collecter, organiser et analyser les données industrielles
- AWS IoT Greengrass - Extension du cloud qui permet l'exécution locale de calculs, messagerie et synchronisation de données
- AWS IoT Device Defender - Service pour auditer les configurations, surveiller les appareils et détecter les comportements anormaux
Protocoles de communication
- MQTT - Protocole léger basé sur la publication/souscription, idéal pour les appareils à ressources limitées
- HTTP - Protocole standard pour les appareils disposant de plus de ressources
- WebSockets - Pour les communications bidirectionnelles en temps réel
- LoRaWAN - Protocole pour les réseaux longue portée et basse consommation, supporté par AWS IoT Core
Sécurité
La sécurité est fondamentale dans l'IoT. AWS IoT fournit plusieurs mécanismes :
- Authentification mutuelle TLS - Chaque appareil s'authentifie avec un certificat X.509
- Stratégies IAM - Définition précise des autorisations pour chaque appareil
- Device Defender - Surveillance continue des comportements anormaux
- Chiffrement des données - En transit et au repos
Cas d'usage
Domotique et maison intelligente
Contrôle d'éclairage, thermostats intelligents, systèmes de sécurité, et gestion de l'énergie domestique. Intégration avec des assistants vocaux comme Alexa.
Agriculture intelligente
Surveillance de l'humidité du sol, systèmes d'irrigation automatisés, suivi des conditions météorologiques et optimisation des cultures. Parfait pour les potagers connectés.
Surveillance environnementale
Capteurs de qualité de l'air, monitoring de la pollution, suivi des niveaux d'eau et détection précoce des risques environnementaux.
Industrie 4.0
Maintenance prédictive, surveillance des équipements, optimisation des chaînes de production et gestion des actifs industriels.
Applications populaires avec ESP32 et Arduino
Les microcontrôleurs ESP32 et Arduino sont parfaits pour créer des projets IoT personnalisés avec AWS IoT :
Ce que j'ai réalisé avec AWS IoT
Des projets connectés et intelligents
J'ai utilisé AWS IoT dans divers projets personnels et professionnels, en créant des solutions connectées innovantes et robustes.
Système de monitoring pour plantes
Développement d'un système de suivi de l'humidité du sol et d'arrosage automatique pour les plantes d'intérieur, utilisant des capteurs Arduino connectés à AWS IoT Core et DynamoDB pour stocker l'historique des données.
Cadre photo intelligent connecté
Création d'un cadre photo ESP32 connecté à AWS IoT, capable d'afficher des photos envoyées depuis une application mobile, avec des animations LED contrôlées par AWS Lambda et 
AWS S3.
