rbAmp
FR
Boutique
Docs
Mis à jour · Modifier sur GitHub [Edit on GitHub]

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
Sécurité

⚠ 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

  1. Console AWS → IoT Core → Manage → Things → Create things → Single thing [Manage → Things → Create things → Single thing].
  2. Générez un certificat et des clés ; téléchargez device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Attachez une politique autorisant iot:Connect, iot:Publish sur arn:aws:iot:::topic/rbamp/+/state.

  4. Notez le point de terminaison AWS IoT : xxxxxx-ats.iot..amazonaws.com:8883.

Croquis ESP32

C++
#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

  1. Portail Azure → IoT Hub → Appareils → Nouveau → ID d'appareil rbamp-main, authentification = Clé symétrique.

  2. Enregistrez la chaîne de connexion : HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Générez un jeton SAS (par exemple via az iot hub generate-sas-token ou n'importe quel SDK Azure).

Croquis ESP32 (jeton SAS longue durée)

C++
#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.

C++
#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.

C++
#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.

C++
#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.



Sources et problèmes : rb-amp/rbamp-arduino · cette page dans le dépôt : docs/08_cloud_integrations.md (v1.6.2)