08 · Integraciones en la nube
Cómo enviar las lecturas de RbAmp a plataformas en la nube: AWS IoT Core, Azure IoT Hub, Google Cloud y canales de observabilidad gestionados o sin servidor. Para cada plataforma: un sketch para ESP32 y lo que debe configurar en el lado de la nube.
Plataformas DIY autoalojadas (Home Assistant, Node-RED, InfluxDB OSS): véase 07 · Integraciones DIY.
| Nube | Transporte | Autenticación | Latencia | Coste |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | Certificado X.509 | bajo | $5/M mensajes |
| Azure IoT Hub | MQTT/TLS o AMQP | Token SAS | bajo | $0.40-2/M mensajes |
| Google Cloud IoT (obsoleto desde 2023) | MQTT/TLS | JWT | — | n/a |
| InfluxDB Cloud | Protocolo de línea HTTPS | Token de API | medio | $250/mo+ |
| Webhook genérico / REST | POST HTTPS | Clave de API | alta | depende |
⚠ TLS en ESP32. Cualquier transporte en la nube sobre TLS añade ~30 kB de código + ~30 kB de heap para el handshake. AVR / ESP8266 no tienen RAM para TLS: para esas plataformas necesita un broker MQTT local que haga de proxy hacia la nube (Mosquitto → puente → AWS IoT).
AWS IoT Core
AWS IoT Core usa TLS mutuo con un certificado de dispositivo X.509.
Aprovisionamiento
- AWS Console → IoT Core → Manage → Things → Create things → Single thing.
-
Genere un certificado y claves; descargue
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Asocie una política que permita
iot:Connect,iot:Publishsobrearn:aws:iot:.: :topic/rbamp/+/state -
Tenga en cuenta el endpoint de AWS IoT:
xxxxxx-ats.iot...amazonaws.com:8883
Sketch para 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);
}
Procesamiento en la nube
-
Cree una IoT Rule:
SELECT *, topic(2) AS device FROM 'rbamp/+/state'→ Kinesis Data Firehose o Lambda para almacenamiento. -
Para paneles: AWS IoT SiteWise (historiador industrial) o Timestream (base de datos de series temporales) → QuickSight.
-
Si Home Assistant se ejecuta en una Pi y consume datos de AWS, configure un puente local de Mosquitto (más barato y rápido que HA → AWS directamente).
Sobre el coste
Con publicación una vez por minuto por dispositivo, AWS IoT da unos 525k mensajes al año → unos $2.60/año/dispositivo en el nivel «Connectivity» + «Messaging» (2026, us-east-1). El coste de Timestream / Lambda es aparte.
Azure IoT Hub
Azure IoT Hub admite MQTT 3.1.1 sobre TLS con autenticación por token SAS (más sencillo que X.509 para uso doméstico).
Aprovisionamiento
-
Azure Portal → IoT Hub → Devices → New → ID de dispositivo
rbamp-main, autenticación = Symmetric key. -
Guarde la cadena de conexión:
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Genere un token SAS (por ejemplo, con
az iot hub generate-sas-tokeno cualquier SDK de Azure).
Boceto ESP32 (token SAS de larga duración)
#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);
}
Caducidad del token SAS
Los tokens SAS llevan una cláusula expiry: la vida útil típica va de 1 hora a 1 año. Para un despliegue con ESP32, genere un token de 1 año en la máquina de compilación y grábelo en el firmware. Para una rotación automática desatendida, refresque el token periódicamente mediante el Device Provisioning Service (DPS) de Azure IoT Hub; eso queda fuera del alcance de la biblioteca.
Procesamiento en la nube (Azure)
-
Enrute los mensajes a Event Hubs para una ingesta de alto rendimiento → Stream Analytics → paneles de Power BI.
-
Una alternativa más barata: mensajes → Storage Account (blob) → Synapse Serverless SQL para consultas ad hoc.
Google Cloud IoT (OBSOLETO desde 2023)
Google cerró Cloud IoT Core en 2023. Vías de migración:
-
Broker MQTT en Compute Engine (usted despliega Mosquitto en una VM) — el mismo patrón de sketch que en 07 · Integraciones DIY, sección Home Assistant, pero apuntando a la IP pública de su VM.
-
HiveMQ Cloud / EMQX Cloud: brokers MQTT gestionados, ~$10-20/mes en niveles para aficionados.
-
Pub/Sub sobre HTTPS: publique directamente en un tema de Pub/Sub mediante la API REST (autenticación con una clave de cuenta de servicio grabada en el ESP32).
Para Pub/Sub sobre HTTPS, véase la sección «Webhook genérico / REST» de abajo, sustituyendo el endpoint de publicación de Pub/Sub.
InfluxDB Cloud (TLSv1.3 + protocolo de línea)
InfluxDB Cloud (nivel Serverless) acepta protocolo de línea sobre HTTPS: la misma forma que la ruta OSS de 07 · Integraciones DIY, sección de InfluxDB OSS, pero con cloud2.influxdata.com como host y un token de API para la autenticación.
#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));
El nivel gratuito de InfluxDB Cloud (5 GB / retención de 30 días) cubre unos 5000 puntos a una cadencia de un minuto al día: suficiente para uso doméstico.
Webhook / REST genérico
Publicación en cualquier endpoint HTTPS con una clave de API: funciona con webhooks de IFTTT, servicios personalizados en Flask / FastAPI, o cualquier función en la nube (AWS Lambda / Azure Functions / GCP Cloud Run) expuesta por 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 frecuencia baja (≤ una vez por minuto) la sobrecarga es aceptable. A frecuencias mayores, agrupe los datos en el lado del ESP32 (acumule 10 minutos en un búfer circular y publique un único JSON masivo), para no pagar un handshake TLS por petición.
Híbrido: almacenamiento local + sincronización con la nube
Para despliegues tolerantes a la desconexión: registre en SPIFFS / una tarjeta SD una vez por minuto y envíe a la nube una vez por hora. Así se sobrevive a las caídas de WiFi sin perder datos.
#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
}
El acumulador de la biblioteca dev.energy().wh(0) sigue contando durante todo el tiempo que dure la ventana sin conexión: no se pierden datos mientras el ESP32 permanezca alimentado.
Presupuesto de energía
El handshake TLS es una operación costosa: ~3 s + ~30 kB de heap por conexión. Para los registradores con deep sleep (véase el escenario del registrador con deep sleep alimentado por batería en 06 · Ejemplos):
-
Reutilice la sesión TLS si el intervalo de suspensión es < 24 h (la mayoría de los brokers gestionados admiten la reanudación de sesión).
-
Agrupe varias mediciones en una tarjeta SD local en un único POST masivo por despertar.
-
Use MQTT sobre TLS con sesión persistente (
cleansession=0) para no volver a publicar la configuración de descubrimiento en cada despertar.
Con un intervalo de despertar de 10 minutos en una batería Li-ion de 2000 mAh, cabe esperar ~3 meses de funcionamiento con WiFi + TLS, frente a ~6 meses con WiFi + MQTT sin cifrar.
Enlaces
-
06 · Ejemplos — los sketches base sobre los que se construyen las integraciones en la nube
-
07 · Integraciones DIY — alternativas autoalojadas
-
10 · Solución de problemas: caídas de WiFi / depuración del handshake TLS / problemas de memoria heap
Fuente y incidencias: rb-amp/rbamp-arduino · esta página en el repositorio: docs/08_cloud_integrations.md (v1.6.2)