08 · Intégrations cloud
Comment envoyer les mesures rbamp vers des plateformes cloud — AWS IoT Core, Azure IoT Hub, Google Cloud, et les chaînes de supervision serverless / gérées. Pour chaque plateforme : comment mettre en place le projet ESP-IDF 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.
Flotte → sujets MQTT par module
Dans le déploiement canonique (compteur principal + N sous-charges sur un même bus), le maître publie les mesures sur un sujet distinct pour chaque module. Un motif pratique consiste à parcourir la flotte en utilisant soit l'adresse du module, soit son LABEL défini par l'utilisateur :
char topic[64];
for (size_t i = 0; i < rbamp_fleet_count(fleet); ++i) {
rbamp_handle_t dev = rbamp_fleet_get(fleet, i);
char label[9]; rbamp_read_label(dev, label);
snprintf(topic, sizeof topic, "rbamp/%s/snapshot",
label[0] ? label : "unlabeled");
/* publish snaps[i] as JSON to topic */
}
Sujets supplémentaires : rbamp/ (alimenté par rbamp_has_error), rbamp/fleet/total_power, rbamp/fleet/total_energy_wh, rbamp/fleet/balance (secteur − Σ(sous-charges) dans le scénario canonique 80 %). Un exemple complet avec charges utiles conservées et découverte automatique Home Assistant figure au chapitre 06 · Exemples, scénario 1.
| 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 environ 30 kB de code + environ 30 kB de tas par négociation. Sur de très petites cibles à mémoire limitée (l'ESP32-C2 en particulier, surtout avec le Bluetooth activé), le tas TLS peut poser problème — voir 10 · Dépannage, section « TLS handshake fail » (échec de la négociation TLS).
Certificats TLS — motif à base de fichiers via SPIFFS
Contrairement à la bibliothèque Arduino, où les certificats sont généralement intégrés au firmware sous forme de chaînes PROGMEM, ESP-IDF privilégie une approche par fichiers : les fichiers de certificats sont placés dans une partition SPIFFS dédiée, et une URI de la forme file:///certs/aws_root_ca.pem est transmise à la configuration.
Table de partitions
Ajoutez une entrée pour la partition de certificats dans le partitions.csv de votre projet :
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x6000,
phy_init, data, phy, 0xf000, 0x1000,
factory, app, factory, 0x10000, 0x100000,
certs, data, spiffs, , 0x20000,
Dans sdkconfig.defaults :
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
Image SPIFFS avec certificats
Placez les fichiers de certificat dans un répertoire spiffs_image/ à côté de main/ et activez la génération d'image dans main/CMakeLists.txt :
idf_component_register(
SRCS "main.c"
INCLUDE_DIRS "."
REQUIRES rbamp mqtt esp_http_client nvs_flash esp_wifi esp_event esp_netif
)
# SPIFFS image with certificates — built at build-time and flashed into
# the "certs" partition by one of the `idf.py spiffs-certs-flash` commands.
spiffs_create_partition_image(certs
${CMAKE_SOURCE_DIR}/spiffs_image
FLASH_IN_PROJECT
)
Après idf.py build flash, les fichiers de spiffs_image/* se trouvent dans la partition certs et sont accessibles via VFS sous /certs/.
Montage à l'exécution
esp_vfs_spiffs_conf_t spiffs_cfg = {
.base_path = "/certs",
.partition_label = "certs",
.max_files = 4,
.format_if_mount_failed = false,
};
ESP_ERROR_CHECK(esp_vfs_spiffs_register(&spiffs_cfg));
Ensuite, l'URI "file:///certs/ca.pem" peut être passé à esp_mqtt_client_config_t.broker.verification.certificate_uri et aux champs similaires.
AWS IoT Core
AWS IoT Core utilise le TLS mutuel avec un certificat X.509 de l'appareil.
Provisionnement
- Console AWS → IoT Core → Manage → Things → Create things → Single thing [Manage → Things → Create things → Single thing].
-
Générez le certificat et les 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
Fichiers de certificats dans SPIFFS
À placer dans spiffs_image/ :
spiffs_image/
ca.pem # AmazonRootCA1.pem
client.crt # device.cert.pem
client.key # device.private.key
Projet ESP-IDF
#include "freertos/FreeRTOS.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_spiffs.h"
#include "esp_wifi.h"
#include "mqtt_client.h"
#include "nvs_flash.h"
#include "rbamp.h"
#define AWS_URI "mqtts://xxxxxx-ats.iot.eu-west-1.amazonaws.com:8883"
#define AWS_CLIENT_ID "rbamp-main"
static const char *TAG = "aws_iot";
static esp_mqtt_client_handle_t mqtt;
void app_main(void) {
/* ...nvs + netif + wifi STA until IP_EVENT_STA_GOT_IP is received... */
/* ...mount SPIFFS at /certs (see the TLS certificates section above)... */
/* ...I²C bus + rbamp_new + rbamp_begin + set_sensor_class + set_ct_model... */
rbamp_handle_t dev = NULL;
const esp_mqtt_client_config_t cfg = {
.broker.address.uri = AWS_URI,
.broker.verification.certificate_uri = "file:///certs/ca.pem",
.credentials.client_id = AWS_CLIENT_ID,
.credentials.authentication.certificate_uri = "file:///certs/client.crt",
.credentials.authentication.key_uri = "file:///certs/client.key",
.session.keepalive = 60,
};
mqtt = esp_mqtt_client_init(&cfg);
ESP_ERROR_CHECK(esp_mqtt_client_start(mqtt));
while (1) {
vTaskDelay(pdMS_TO_TICKS(60000));
rbamp_period_snapshot_t snap;
if (rbamp_read_period_snapshot(dev, &snap, 50, false) != ESP_OK ||
!snap.valid) continue;
float u, freq;
rbamp_read_voltage(dev, 0, &u);
rbamp_read_frequency(dev, &freq);
char payload[256];
snprintf(payload, sizeof(payload),
"{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f,\"freq\":%.1f}",
(double)u, (double)snap.avg_p[0],
rbamp_energy_wh(dev, 0), (double)freq);
esp_mqtt_client_publish(mqtt, "rbamp/main/state",
payload, 0, /*qos*/0, /*retain*/0);
}
}
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, utilisez 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).
Sur le coût
Publication une fois par minute et par appareil, AWS IoT atteint ~525k messages par an → ~2.60 $/an/appareil sur le palier « Connectivity » + « Messaging » (2026, us-east-1). Le coût 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 les usages domestiques).
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).
Certificat + configuration
Placez l'autorité de certification racine Azure (Baltimore CyberTrust Root ou DigiCert Global Root G2) dans spiffs_image/ca.pem.
#define AZ_URI "mqtts://foo.azure-devices.net:8883"
#define AZ_USER "foo.azure-devices.net/rbamp-main/?api-version=2021-04-12"
#define AZ_SAS "SharedAccessSignature sr=foo.azure-devices.net%2Fdevices%2Frbamp-main&sig=…&se=…"
#define AZ_DEVICE_ID "rbamp-main"
const esp_mqtt_client_config_t cfg = {
.broker.address.uri = AZ_URI,
.broker.verification.certificate_uri = "file:///certs/ca.pem",
.credentials.client_id = AZ_DEVICE_ID,
.credentials.username = AZ_USER, /* SAS auth — no mTLS */
.credentials.authentication.password = AZ_SAS,
.session.keepalive = 60,
};
/* Publish to the Azure D2C topic: */
char topic[128];
snprintf(topic, sizeof(topic), "devices/%s/messages/events/", AZ_DEVICE_ID);
esp_mqtt_client_publish(mqtt, topic, payload, 0, /*qos*/0, /*retain*/0);
Expiration du jeton SAS
Les jetons SAS portent une revendication expiry — les durées de vie typiques vont de 1 heure à 1 an. Pour un déploiement ESP32, générez un jeton valable 1 an sur la machine de build et intégrez-le au firmware. Pour une rotation automatique sans surveillance, renouvelez-le périodiquement via le Device Provisioning Service (DPS) d'Azure IoT Hub ; cela dépasse le périmètre du composant.
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 motif que dans 07 · Intégrations maison, 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 — publiez directement sur un sujet Pub/Sub via l'API REST (authentification par clé JSON de compte de service, intégrée à 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 via HTTPS — la même forme que le chemin OSS décrit dans 07 · Intégrations maison, section InfluxDB OSS, mais avec cloud2.influxdata.com comme hôte et un jeton API pour l'authentification.
Placez l'AC de cloud2.influxdata.com (DigiCert Global Root G2 ou similaire) dans spiffs_image/influx_ca.pem.
#include "esp_http_client.h"
#include "esp_log.h"
#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"
static const char *TAG = "influx_cloud";
static esp_err_t read_ca(char *buf, size_t buflen, size_t *out_len) {
FILE *f = fopen("/certs/influx_ca.pem", "rb");
if (!f) return ESP_FAIL;
*out_len = fread(buf, 1, buflen - 1, f);
buf[*out_len] = '\0';
fclose(f);
return ESP_OK;
}
static void push_influx_cloud(float u, float p, double e_wh) {
static char ca_buf[2048];
static size_t ca_len = 0;
if (ca_len == 0) {
if (read_ca(ca_buf, sizeof(ca_buf), &ca_len) != ESP_OK) {
ESP_LOGE(TAG, "CA read failed");
return;
}
}
char body[256];
snprintf(body, sizeof(body),
"rbamp,device=main voltage=%.1f,power=%.1f,energy=%.3f",
(double)u, (double)p, e_wh);
esp_http_client_config_t cfg = {
.url = INFLUX_URL,
.method = HTTP_METHOD_POST,
.cert_pem = ca_buf,
.timeout_ms = 10000, /* TLS handshake may take up to 3 s */
};
esp_http_client_handle_t client = esp_http_client_init(&cfg);
esp_http_client_set_header(client, "Authorization", "Token " INFLUX_TOKEN);
esp_http_client_set_header(client, "Content-Type", "text/plain");
esp_http_client_set_post_field(client, body, strlen(body));
esp_err_t err = esp_http_client_perform(client);
int status = esp_http_client_get_status_code(client);
esp_http_client_cleanup(client);
if (err != ESP_OK || status != 204) {
ESP_LOGW(TAG, "influx HTTP %d (err %s)", status, esp_err_to_name(err));
}
}
/* In the 60-second loop, after rbamp_read_period_snapshot(): */
float u;
rbamp_read_voltage(dev, 0, &u);
push_influx_cloud(u, snap.avg_p[0], rbamp_energy_wh(dev, 0));
Le palier gratuit InfluxDB Cloud (5 Go / rétention de 30 jours) couvre environ 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 "esp_http_client.h"
#include "esp_log.h"
#include "esp_timer.h"
#define WEBHOOK_URL "https://your-api.example.com/ingest"
#define API_KEY "Bearer your-token-here"
static const char *TAG = "webhook";
/* CA for your HTTPS endpoint (read from /certs/webhook_ca.pem,
* via snprintf+fopen as in push_influx_cloud). */
extern const char *get_server_ca(void); /* implementation as in the InfluxDB section */
static void push_webhook(float u, float p, double e_wh) {
char body[256];
snprintf(body, sizeof(body),
"{\"ts\":%lld,\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
(long long)(esp_timer_get_time() / 1000000),
(double)u, (double)p, e_wh);
esp_http_client_config_t cfg = {
.url = WEBHOOK_URL,
.method = HTTP_METHOD_POST,
.cert_pem = get_server_ca(),
.timeout_ms = 10000,
};
esp_http_client_handle_t client = esp_http_client_init(&cfg);
esp_http_client_set_header(client, "Authorization", API_KEY);
esp_http_client_set_header(client, "Content-Type", "application/json");
esp_http_client_set_post_field(client, body, strlen(body));
esp_err_t err = esp_http_client_perform(client);
int status = esp_http_client_get_status_code(client);
esp_http_client_cleanup(client);
if (err != ESP_OK || status < 200 || status >= 300) {
ESP_LOGW(TAG, "webhook HTTP %d (err %s)", status, esp_err_to_name(err));
}
}
⚠ .skip_cert_common_name_check = false doit rester à false en production. Pendant le prototypage, vous pouvez utiliser .use_global_ca_store = true (le binaire n'embarque alors aucune AC spécifique, ce qui réduit la sécurité TLS) — mais ne JAMAIS livrer cela en production sans une AC explicite.
À une cadence faible (≤ 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, puis publiez-les en un seul JSON groupé) pour ne pas payer une négociation TLS par requête.
Hybride : stockage local + synchronisation vers le cloud
Pour les déploiements tolérant les coupures : journaliser dans SPIFFS une fois par minute et pousser vers le cloud une fois par heure. Cela survit aux coupures WiFi sans perte de données.
#include
#include "esp_log.h"
#include "esp_timer.h"
#include "rbamp.h"
#define LOG_PATH "/storage/log.csv"
static const char *TAG = "hybrid";
static void log_to_spiffs(const rbamp_period_snapshot_t *snap,
float u, double e_wh) {
FILE *f = fopen(LOG_PATH, "a");
if (!f) {
ESP_LOGE(TAG, "fopen failed");
return;
}
fprintf(f, "%lld,%.1f,%.1f,%.3f\n",
(long long)(esp_timer_get_time() / 1000),
(double)u, (double)snap->avg_p[0], e_wh);
fclose(f);
}
static void sync_to_cloud_if_due(void) {
static int64_t last_sync_us = 0;
const int64_t now_us = esp_timer_get_time();
if ((now_us - last_sync_us) < 3600LL * 1000000LL) return; /* once per hour */
last_sync_us = now_us;
FILE *f = fopen(LOG_PATH, "r");
if (!f) return;
char line[256];
while (fgets(line, sizeof(line), f)) {
push_webhook_line(line); /* line → JSON → POST */
}
fclose(f);
/* Optionally: rename(LOG_PATH, "/storage/log_pushed.csv") + truncate */
}
L'accumulateur du composant, rbamp_energy_wh(dev, 0), continue de compter pendant toute la fenêtre hors ligne — aucune donnée n'est perdue tant que l'ESP32 est alimenté. La partition SPIFFS storage est présentée dans 06 · Exemples, scénario 8 (spiffs_logger).
Bilan énergétique
Une négociation TLS est une opération coûteuse : ~3 s + ~30 kB de tas par connexion. Pour les enregistreurs en deep-sleep (voir 06 · Exemples, scénario 9) :
-
Réutilisez la session TLS si l'intervalle de sommeil est < 24 h — le
mbedtlsd'ESP-IDF prend en charge la reprise de session via l'APImbedtls_ssl_get/set_session(). Cela ramène la négociation à ~500 ms. -
Regrouper plusieurs mesures dans un SPIFFS local en une seule publication POST en bloc par réveil — le motif de la section « Hybride » ci-dessus.
-
MQTT sur TLS avec session persistante (
session.disable_clean_session = truedansesp_mqtt_client_config_t) — le broker conserve vos abonnements entre deux réveils, donc inutile de republier la configuration de découverte.
Avec un intervalle de réveil de 10 minutes sur une cellule Li-ion de 2000 mAh, attendez-vous à environ 3 mois de fonctionnement en WiFi + TLS, contre environ 6 mois en WiFi + MQTT simple (selon le budget du scénario 9).
Voir aussi
-
06 · Exemples — les projets de base sur lesquels reposent les intégrations cloud (surtout le scénario 8 « spiffs_logger » pour l'approche hybride)
-
07 · Intégrations maison — alternatives auto-hébergées (Home Assistant / Node-RED / OpenHAB / InfluxDB OSS)
-
10 · Dépannage — coupures Wi-Fi / débogage de la négociation TLS / problèmes de tas
Sources et tickets : rb-amp/rbamp-esp-idf · cette page dans le dépôt : docs/08_cloud_integrations.md (v1.7.3)