08 · Intégrations cloud
Comment envoyer les lectures RbAmp vers les plateformes cloud — AWS IoT Core, Azure IoT Hub, Google Cloud, et les pipelines d'observabilité serverless / gérés. Pour chaque plateforme : un croquis ESP32 et ce qu'il faut configurer côté cloud.
Plateformes DIY auto-hébergées (Home Assistant, Node-RED, InfluxDB OSS) — voir 07 · Intégrations DIY.
| Cloud | Transport | Authentification | Latence | Coût |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | Certificat X.509 | faible | $5/M messages |
| Azure IoT Hub | MQTT/TLS ou AMQP | Jeton SAS | faible | $0.40-2/M messages |
| Google Cloud IoT (déprécié en 2023) | MQTT/TLS | JWT | — | n/a |
| InfluxDB Cloud | Protocole de ligne HTTPS | Jeton API | moyen | $250/mo+ |
| Webhook générique / REST | POST HTTPS | Clé API | élevé | dépend |
⚠ TLS sur ESP32. Tout transport cloud sur TLS ajoute ~30 ko de code + ~30 ko de tas pour la négociation. AVR / ESP8266 n'ont pas la RAM nécessaire pour TLS — pour ces plateformes, il faut un broker MQTT local qui relaie vers le cloud (Mosquitto → pont → AWS IoT).
AWS IoT Core
AWS IoT Core utilise le TLS mutuel avec un certificat d'appareil X.509.
Provisionnement
- Console AWS → IoT Core → Manage → Things → Create things → Single thing [Manage → Things → Create things → Single thing].
-
Générez un certificat et des clés ; téléchargez
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Attachez une politique autorisant
iot:Connect,iot:Publishsurarn:aws:iot:.: :topic/rbamp/+/state -
Notez le point de terminaison AWS IoT :
xxxxxx-ats.iot...amazonaws.com:8883
Croquis ESP32
#include
#include
#include
#include
#include
static const char AWS_ENDPOINT[] = "xxxxxx-ats.iot.eu-west-1.amazonaws.com";
static const char AWS_CLIENT_ID[] = "rbamp-main";
// Contents of AmazonRootCA1.pem, device.cert.pem, device.private.key
// in PROGMEM strings (saves RAM, places them in flash).
static const char AWS_ROOT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
MIIDQTCC...
-----END CERTIFICATE-----
)EOF";
static const char DEV_CERT[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
MIIDWjCC...
-----END CERTIFICATE-----
)EOF";
static const char DEV_KEY[] PROGMEM = R"EOF(
-----BEGIN RSA PRIVATE KEY-----
MIIEowIB...
-----END RSA PRIVATE KEY-----
)EOF";
static RbAmp dev(Wire, 0x50);
static WiFiClientSecure tls;
static PubSubClient mqtt(tls);
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
tls.setCACert(AWS_ROOT_CA);
tls.setCertificate(DEV_CERT);
tls.setPrivateKey(DEV_KEY);
mqtt.setServer(AWS_ENDPOINT, 8883);
mqtt.setKeepAlive(60);
mqtt.connect(AWS_CLIENT_ID);
Wire.begin();
Wire.setClock(50000);
while (!dev.begin()) delay(500);
}
void loop() {
if (!mqtt.connected()) mqtt.connect(AWS_CLIENT_ID);
mqtt.loop();
static uint32_t last = 0;
if (last == 0) last = millis();
if (millis() - last < 60000) { delay(50); return; }
last = millis();
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) return;
char payload[256];
snprintf(payload, sizeof(payload),
"{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f,\"freq\":%.1f}",
dev.readVoltage(), snap.avg_p[0],
dev.energy().wh(0), dev.readFrequency());
mqtt.publish("rbamp/main/state", payload, false);
}
Traitement côté cloud
-
Créez une IoT Rule [IoT Rule] :
SELECT *, topic(2) AS device FROM 'rbamp/+/state'→ Kinesis Data Firehose ou Lambda pour le stockage. -
Pour les tableaux de bord — AWS IoT SiteWise (historien industriel) ou Timestream (base de séries temporelles) → QuickSight.
-
Si Home Assistant tourne sur un Pi et consomme les données d'AWS, mettez en place un pont Mosquitto local (moins cher et plus rapide que HA → AWS directement).
Coût
Une publication par minute et par appareil représente ~525 k messages par an → ~2.60 $/an/appareil sur le niveau « Connectivity » + « Messaging » (2026, us-east-1). Le coût de Timestream / Lambda est séparé.
Azure IoT Hub
Azure IoT Hub prend en charge MQTT 3.1.1 sur TLS avec authentification par jeton SAS (plus simple que X.509 pour un usage domestique).
Provisionnement
-
Portail Azure → IoT Hub → Appareils → Nouveau → ID d'appareil
rbamp-main, authentification = Clé symétrique. -
Enregistrez la chaîne de connexion :
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Générez un jeton SAS (par exemple via
az iot hub generate-sas-tokenou n'importe quel SDK Azure).
Croquis ESP32 (jeton SAS longue durée)
#include
#include
#include
#include
static const char AZ_HOST[] = "foo.azure-devices.net";
static const char AZ_USER[] = "foo.azure-devices.net/rbamp-main/?api-version=2021-04-12";
static const char AZ_SAS[] = "SharedAccessSignature sr=foo.azure-devices.net%2Fdevices%2Frbamp-main&sig=…&se=…";
static const char AZ_DEVICE_ID[] = "rbamp-main";
// Root CA for Azure IoT Hub (Baltimore CyberTrust Root or DigiCert Global Root)
static const char AZ_ROOT_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
)EOF";
static RbAmp dev(Wire, 0x50);
static WiFiClientSecure tls;
static PubSubClient mqtt(tls);
void setup() {
// ...WiFi up...
tls.setCACert(AZ_ROOT_CA);
mqtt.setServer(AZ_HOST, 8883);
mqtt.setKeepAlive(60);
mqtt.connect(AZ_DEVICE_ID, AZ_USER, AZ_SAS);
Wire.begin(); Wire.setClock(50000);
while (!dev.begin()) delay(500);
}
void loop() {
if (!mqtt.connected()) mqtt.connect(AZ_DEVICE_ID, AZ_USER, AZ_SAS);
mqtt.loop();
static uint32_t last = 0;
if (millis() - last < 60000) { delay(50); return; }
last = millis();
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) return;
char payload[256];
snprintf(payload, sizeof(payload),
"{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
dev.readVoltage(), snap.avg_p[0], dev.energy().wh(0));
// Azure D2C topic format:
char topic[128];
snprintf(topic, sizeof(topic), "devices/%s/messages/events/", AZ_DEVICE_ID);
mqtt.publish(topic, payload, false);
}
Expiration du jeton SAS
Les jetons SAS portent une revendication expiry — la durée de vie typique va de 1 heure à 1 an. Pour un déploiement ESP32, générez un jeton d'1 an sur la machine de build et intégrez-le au firmware. Pour une rotation automatique sans intervention, renouvelez-le périodiquement via le Device Provisioning Service (DPS) d'Azure IoT Hub ; cela sort du cadre de la bibliothèque.
Traitement côté cloud (Azure)
-
Acheminez les messages vers Event Hubs pour une ingestion à haut débit → Stream Analytics → tableaux de bord Power BI.
-
Une alternative moins chère : messages → Storage Account (blob) → Synapse Serverless SQL pour les requêtes ad hoc.
Google Cloud IoT (DÉPRÉCIÉ en 2023)
Google a arrêté Cloud IoT Core en 2023. Voies de migration :
-
Broker MQTT sur Compute Engine (vous déployez Mosquitto vous-même sur une VM) — le même schéma de croquis que dans 07 · Intégrations DIY, section Home Assistant, mais pointant vers l'IP publique de votre VM.
-
HiveMQ Cloud / EMQX Cloud — brokers MQTT gérés, ~10-20 $/mois sur les offres d'amateurs.
-
Pub/Sub sur HTTPS — publier directement sur un topic Pub/Sub via l'API REST (authentification par une clé de compte de service gravée dans l'ESP32).
Pour Pub/Sub sur HTTPS, voir la section « Webhook générique / REST » ci-dessous, en remplaçant par le point de terminaison de publication Pub/Sub.
InfluxDB Cloud (TLSv1.3 + protocole de ligne)
InfluxDB Cloud (palier Serverless) accepte le line-protocol en HTTPS — la même forme que la voie OSS décrite dans 07 · Intégrations DIY, section InfluxDB OSS, mais avec cloud2.influxdata.com comme hôte et un jeton API pour l'authentification.
#include
#include
#define INFLUX_URL "https://us-east-1-1.aws.cloud2.influxdata.com/api/v2/write?org=MyOrg&bucket=energy&precision=s"
#define INFLUX_TOKEN "your-rw-token"
// CA for cloud2.influxdata.com (DigiCert Global Root G2 or similar)
static const char INFLUX_CA[] PROGMEM = R"EOF(
-----BEGIN CERTIFICATE-----
...
-----END CERTIFICATE-----
)EOF";
void push_influx_cloud(float u, float p, double e_wh) {
WiFiClientSecure client;
client.setCACert(INFLUX_CA);
HTTPClient http;
http.begin(client, INFLUX_URL);
http.addHeader("Authorization", "Token " INFLUX_TOKEN);
http.addHeader("Content-Type", "text/plain");
char body[256];
snprintf(body, sizeof(body),
"rbamp,device=main voltage=%.1f,power=%.1f,energy=%.3f",
u, p, e_wh);
int code = http.POST(body);
http.end();
if (code != 204) Serial.printf("influx HTTP %d\n", code);
}
// In your 60-second loop, after readPeriodSnapshot():
push_influx_cloud(dev.readVoltage(), snap.avg_p[0], dev.energy().wh(0));
Le niveau gratuit d'InfluxDB Cloud (5 Go / rétention de 30 jours) couvre ~5000 points à une cadence d'une minute par jour — largement suffisant pour un usage domestique.
Webhook / REST générique
Publication vers n'importe quel point de terminaison HTTPS avec une clé API — fonctionne avec les webhooks IFTTT, les services Flask / FastAPI personnalisés ou toute fonction cloud (AWS Lambda / Azure Functions / GCP Cloud Run) exposée en HTTPS.
#include
#include
#define WEBHOOK_URL "https://your-api.example.com/ingest"
#define API_KEY "Bearer your-token-here"
// Attach the server CA for TLS, or use setInsecure()
// for prototyping only. NEVER ship setInsecure()
// to production — it disables certificate validation.
static const char SERVER_CA[] PROGMEM = "...";
void push_webhook(float u, float p, double e_wh) {
WiFiClientSecure client;
client.setCACert(SERVER_CA);
HTTPClient http;
http.begin(client, WEBHOOK_URL);
http.addHeader("Authorization", API_KEY);
http.addHeader("Content-Type", "application/json");
char body[256];
snprintf(body, sizeof(body),
"{\"ts\":%lu,\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
(unsigned long)(millis() / 1000), u, p, e_wh);
int code = http.POST(body);
http.end();
if (code < 200 || code >= 300) {
Serial.printf("webhook HTTP %d\n", code);
}
}
À faible cadence (≤ une fois par minute), la surcharge est acceptable. À des cadences plus élevées, regroupez les données côté ESP32 (accumulez 10 minutes dans un tampon circulaire, publiez en un seul JSON en bloc) afin de ne pas payer une négociation TLS à chaque requête.
Hybride : stockage local + synchronisation vers le cloud
Pour les déploiements tolérants à la coupure : journalisez sur SPIFFS / une carte SD une fois par minute, et envoyez au cloud une fois par heure. Cela survit aux coupures WiFi sans perte de données.
#include
void log_to_sd(RbAmpPeriodSnapshot& snap) {
File f = SD.open("/log.csv", FILE_APPEND);
if (!f) return;
f.printf("%lu,%.1f,%.1f,%.3f\n",
(unsigned long)(millis() / 1000),
dev.readVoltage(),
snap.avg_p[0],
dev.energy().wh(0));
f.close();
}
void sync_to_cloud_if_due() {
static uint32_t last_sync = 0;
if (millis() - last_sync < 3600000UL) return; // once an hour
last_sync = millis();
File f = SD.open("/log.csv", FILE_READ);
if (!f) return;
while (f.available()) {
String line = f.readStringUntil('\n');
push_webhook_line(line.c_str());
}
f.close();
// Optional: archive to /log_pushed.csv + truncate /log.csv
}
L'accumulateur de la bibliothèque dev.energy().wh(0) continue de compter pendant toute la durée de la fenêtre hors ligne — aucune donnée n'est perdue tant que l'ESP32 reste alimenté.
Bilan énergétique
La négociation TLS est une opération coûteuse : ~3 s + ~30 ko de tas par connexion. Pour les enregistreurs en veille profonde (voir le scénario d'enregistreur sur batterie en veille profonde dans 06 · Exemples) :
-
Réutilisez la session TLS si l'intervalle de veille est < 24 h (la plupart des brokers gérés prennent en charge la reprise de session).
-
Regroupez plusieurs mesures sur une carte SD locale en un seul envoi POST en bloc à chaque réveil.
-
Utilisez MQTT sur TLS avec une session persistante (
cleansession=0) pour ne pas republier la configuration de découverte à chaque réveil.
Avec un réveil toutes les 10 minutes sur une cellule Li-ion de 2000 mAh, comptez environ 3 mois de fonctionnement en Wi-Fi + TLS, contre environ 6 mois en Wi-Fi + MQTT simple.
Liens
-
06 · Exemples — les croquis de base sur lesquels reposent les intégrations cloud
-
07 · Intégrations DIY — alternatives auto-hébergées
-
10 · Dépannage — coupures Wi-Fi / débogage de la négociation TLS / problèmes de tas
Sources et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/08_cloud_integrations.md (v1.6.2)