08 · Integrazioni cloud
Come inviare le letture RbAmp alle piattaforme cloud — AWS IoT Core, Azure IoT Hub, Google Cloud e pipeline di osservabilità serverless / gestite. Per ciascuna piattaforma: uno sketch ESP32 e ciò che deve configurare lato cloud.
Piattaforme DIY self-hosted (Home Assistant, Node-RED, InfluxDB OSS) — vedere 07 · Integrazioni fai-da-te.
| Cloud | Trasporto | Autenticazione | Latenza | Costo |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | Certificato X.509 | basso | $5/M messaggi |
| Azure IoT Hub | MQTT/TLS o AMQP | Token SAS | basso | $0.40-2/M messaggi |
| Google Cloud IoT (deprecato nel 2023) | MQTT/TLS | JWT | — | n/a |
| InfluxDB Cloud | Line protocol HTTPS | Token API | medio | $250/mo+ |
| Webhook generico / REST | HTTPS POST | chiave API | alta | dipende |
⚠ TLS su ESP32. Qualsiasi trasporto cloud su TLS aggiunge ~30 kB di codice + ~30 kB di heap per l'handshake. AVR / ESP8266 non hanno la RAM per TLS — per quelle piattaforme serve un broker MQTT locale che faccia da proxy verso il cloud (Mosquitto → bridge → AWS IoT).
AWS IoT Core
AWS IoT Core usa mutual-TLS con un certificato X.509 del dispositivo.
Provisioning
- Console AWS → IoT Core → Manage → Things → Create things → Single thing.
-
Generare un certificato + chiavi; scaricare
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Colleghi una policy che consenta
iot:Connect,iot:Publishsuarn:aws:iot:.: :topic/rbamp/+/state -
Si noti l'endpoint AWS IoT:
xxxxxx-ats.iot...amazonaws.com:8883
Sketch 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);
}
Elaborazione lato cloud
-
Creare una IoT Rule:
SELECT *, topic(2) AS device FROM 'rbamp/+/state'→ Kinesis Data Firehose o Lambda per la memorizzazione. -
Per le dashboard — AWS IoT SiteWise (storico industriale) o Timestream (database di serie temporali) → QuickSight.
-
Se Home Assistant gira su un Pi e consuma dati da AWS, configuri un bridge Mosquitto locale (più economico e più veloce di HA → AWS direttamente).
Sul costo
Pubblicando una volta al minuto per dispositivo, AWS IoT produce ~525k messaggi all'anno → ~$2.60/anno/dispositivo nel livello "Connectivity" + "Messaging" (2026, us-east-1). Il costo di Timestream / Lambda è a parte.
Azure IoT Hub
Azure IoT Hub supporta MQTT 3.1.1 su TLS con autenticazione a token SAS (più semplice di X.509 per uso domestico).
Provisioning
-
Portale Azure → IoT Hub → Dispositivi → Nuovo → ID dispositivo
rbamp-main, autenticazione = Chiave simmetrica. -
Salvare la stringa di connessione:
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Generare un token SAS (ad esempio tramite
az iot hub generate-sas-tokeno un SDK Azure qualsiasi).
Sketch ESP32 (token SAS a lunga durata)
#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);
}
Scadenza del token SAS
I token SAS hanno una dichiarazione expiry — la durata tipica va da 1 ora a 1 anno. Per un dispositivo ESP32, generi un token di 1 anno sulla macchina di build e lo scriva nel firmware. Per una rotazione automatica senza presidio, lo aggiorni periodicamente tramite il Device Provisioning Service (DPS) di Azure IoT Hub; ciò esula dallo scopo della libreria.
Elaborazione lato cloud (Azure)
-
Instradi i messaggi verso Event Hubs per un'acquisizione ad alto throughput → Stream Analytics → dashboard di Power BI.
-
Un'alternativa più economica: messaggi → Storage Account (blob) → Synapse Serverless SQL per le query ad hoc.
Google Cloud IoT (DEPRECATO 2023)
Google ha chiuso Cloud IoT Core nel 2023. Percorsi di migrazione:
-
Broker MQTT su Compute Engine (lei stesso distribuisce Mosquitto su una VM) — lo stesso schema di sketch di 07 · Integrazioni fai-da-te, sezione Home Assistant, ma puntato all'IP pubblico della sua VM.
-
HiveMQ Cloud / EMQX Cloud — broker MQTT gestiti, ~$10-20/mese nei piani per hobbisti.
-
Pub/Sub su HTTPS — pubblicare direttamente su un topic Pub/Sub tramite la REST API (autenticazione con una chiave dell'account di servizio inserita nell'ESP32).
Per Pub/Sub su HTTPS vedi la sezione "Webhook generico / REST" qui sotto, sostituendo l'endpoint di pubblicazione di Pub/Sub.
InfluxDB Cloud (TLSv1.3 + line protocol)
InfluxDB Cloud (livello Serverless) accetta il line-protocol su HTTPS — la stessa forma del percorso OSS in 07 · Integrazioni fai-da-te, sezione InfluxDB OSS, ma con cloud2.influxdata.com come host e un token API per l'autenticazione.
#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));
Il livello gratuito InfluxDB Cloud (5 GB / conservazione di 30 giorni) copre ~5000 punti con cadenza di un minuto al giorno — ampio per uso domestico.
Webhook / REST generico
Pubblicazione su qualsiasi endpoint HTTPS con una chiave API — funziona con webhook IFTTT, servizi Flask / FastAPI personalizzati o qualsiasi funzione cloud (AWS Lambda / Azure Functions / GCP Cloud Run) esposta via 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);
}
}
A una frequenza bassa (≤ una volta al minuto) il sovraccarico è accettabile. A frequenze più alte, raggruppi i dati lato ESP32 (accumuli 10 minuti in un buffer circolare, pubblichi come un unico JSON di massa) così da non pagare un handshake TLS per ogni richiesta.
Ibrido: archiviazione locale + sincronizzazione con il cloud
Per le distribuzioni tolleranti alle interruzioni: registri su SPIFFS / una scheda SD una volta al minuto e invii al cloud una volta all'ora. Così si sopravvive alle interruzioni del WiFi senza perdere dati.
#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'accumulatore della libreria dev.energy().wh(0) continua a contare per tutto il tempo in cui dura la finestra offline — nessun dato viene perso finché l'ESP32 resta alimentato.
Bilancio energetico
L'handshake TLS è un'operazione costosa: ~3 s + ~30 kB di heap per connessione. Per i logger in deep sleep (vedi lo scenario del logger a batteria in deep sleep in 06 · Esempi):
-
Riutilizzi la sessione TLS se l'intervallo di sospensione è < 24 h (la maggior parte dei broker gestiti supporta la ripresa della sessione).
-
Raccoglia più misure su una scheda SD locale in un unico POST di massa per risveglio.
-
Usi MQTT su TLS con una sessione persistente (
cleansession=0) così da non ripubblicare la configurazione di discovery a ogni risveglio.
Con un intervallo di risveglio di 10 minuti su una cella Li-ion da 2000 mAh, ci si attendono ~3 mesi di funzionamento con WiFi + TLS, contro ~6 mesi con WiFi + MQTT semplice.
Collegamenti
-
06 · Esempi — gli sketch di base su cui si costruiscono le integrazioni cloud
-
07 · Integrazioni fai-da-te — alternative self-hosted
-
10 · Risoluzione dei problemi — cadute WiFi / debug dell'handshake TLS / problemi di heap
Sorgente e segnalazioni: rb-amp/rbamp-arduino · questa pagina nel repository: docs/08_cloud_integrations.md (v1.6.2)