08 · Integrações na cloud
Como enviar leituras do RbAmp para plataformas cloud — AWS IoT Core, Azure IoT Hub, Google Cloud e pipelines de observabilidade serverless / geridos. Para cada plataforma: um sketch para ESP32 e o que é preciso configurar no lado da cloud.
Plataformas DIY auto-alojadas (Home Assistant, Node-RED, InfluxDB OSS) — ver 07 · Integrações DIY.
| Cloud | Transporte | Autenticação | Latência | Custo |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | Certificado X.509 | baixo | $5/M mensagens |
| Azure IoT Hub | MQTT/TLS ou AMQP | Token SAS | baixo | $0.40–2/M mensagens |
| Google Cloud IoT (descontinuado em 2023) | MQTT/TLS | JWT | — | n/a |
| InfluxDB Cloud | HTTPS line-protocol | Token de API | médio | $250/mo+ |
| Webhook genérico / REST | POST HTTPS | Chave de API | alta | depende |
⚠ TLS no ESP32. Qualquer transporte cloud sobre TLS acrescenta ~30 kB de código + ~30 kB de heap para o handshake. AVR / ESP8266 não têm RAM para TLS — para essas plataformas é preciso um broker MQTT local que faça de proxy para a cloud (Mosquitto → ponte → AWS IoT).
AWS IoT Core
O AWS IoT Core usa TLS mútuo com um certificado de dispositivo X.509.
Provisionamento
- Consola AWS → IoT Core → Gerir [Manage] → Coisas [Things] → Criar coisas [Create things] → Coisa única [Single thing].
-
Gere um certificado + chaves; descarregue
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Associe uma política que permita
iot:Connect,iot:Publishsobrearn:aws:iot:.: :topic/rbamp/+/state -
Note o endpoint do 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);
}
Processamento do lado da cloud
-
Crie uma IoT Rule:
SELECT *, topic(2) AS device FROM 'rbamp/+/state'→ Kinesis Data Firehose ou Lambda para armazenamento. -
Para painéis — AWS IoT SiteWise (historiador industrial) ou Timestream (base de dados de séries temporais) → QuickSight.
-
Se o Home Assistant correr num Pi e consumir dados da AWS, configure uma ponte Mosquitto local (mais barata e mais rápida do que HA → AWS diretamente).
Sobre o custo
Publicar uma vez por minuto por dispositivo gera ~525k mensagens por ano → ~2.60 USD/ano/dispositivo no escalão "Connectivity" + "Messaging" (2026, us-east-1). O custo do Timestream / Lambda é separado.
Azure IoT Hub
O Azure IoT Hub suporta MQTT 3.1.1 sobre TLS com autenticação por token SAS (mais simples do que X.509 para uso doméstico).
Provisionamento
-
Portal do Azure → IoT Hub → Devices → New → ID do dispositivo
rbamp-main, autenticação = Symmetric key. -
Guarde a string de ligação:
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Gere um token SAS (por exemplo via
az iot hub generate-sas-tokenou qualquer SDK Azure).
Esboço ESP32 (token SAS de longa duração)
#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);
}
Validade do token SAS
Os tokens SAS têm uma reivindicação expiry — a duração típica vai de 1 hora a 1 ano. Para uma implementação ESP32, gere um token de 1 ano na máquina de compilação e grave-o no firmware. Para uma rotação automática sem supervisão, renove-o periodicamente através do Azure IoT Hub Device Provisioning Service (DPS); isso está fora do âmbito da biblioteca.
Processamento do lado da cloud (Azure)
-
Encaminhe as mensagens para o Event Hubs para ingestão de alto débito → Stream Analytics → painéis do Power BI.
-
Uma alternativa mais barata: mensagens → Conta de Armazenamento [Storage Account] (blob) → Synapse Serverless SQL para consultas ad hoc.
Google Cloud IoT (DESCONTINUADO em 2023)
A Google encerrou o Cloud IoT Core em 2023. Caminhos de migração:
-
Broker MQTT no Compute Engine (instala o Mosquitto numa VM por conta própria) — o mesmo padrão de sketch que em 07 · Integrações DIY, secção Home Assistant, mas apontando para o IP público da sua VM.
-
HiveMQ Cloud / EMQX Cloud — brokers MQTT geridos, ~10–20 USD/mês nos níveis de hobby.
-
Pub/Sub sobre HTTPS — publique diretamente num tópico do Pub/Sub através da API REST (autenticação com uma chave de conta de serviço gravada no ESP32).
Para o Pub/Sub sobre HTTPS, ver a secção «Webhook genérico / REST» abaixo, substituindo pelo endpoint de publicação do Pub/Sub.
InfluxDB Cloud (TLSv1.3 + line-protocol)
O InfluxDB Cloud (nível Serverless) aceita line-protocol sobre HTTPS — a mesma forma do caminho OSS em 07 · Integrações DIY, secção InfluxDB OSS, mas com cloud2.influxdata.com como host e um token de API para autenticação.
#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));
O nível gratuito do InfluxDB Cloud (5 GB / retenção de 30 dias) cobre ~5000 pontos por dia com uma cadência de um minuto — generoso para uso doméstico.
Webhook / REST genérico
Publicação em qualquer endpoint HTTPS com uma chave de API — funciona com webhooks do IFTTT, serviços Flask / FastAPI personalizados, ou qualquer função na cloud (AWS Lambda / Azure Functions / GCP Cloud Run) exposta 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 um ritmo baixo (≤ uma vez por minuto) o custo é aceitável. A ritmos mais altos, agrupe os dados do lado do ESP32 (acumule 10 minutos num buffer circular, publique como um único JSON em lote) para não pagar um handshake TLS por pedido.
Híbrido: armazenamento local + sincronização com a cloud
Para implementações tolerantes a falhas de comunicação: registe em SPIFFS / cartão SD uma vez por minuto e envie para a cloud uma vez por hora. Isto sobrevive a quedas de WiFi sem perda de dados.
#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
}
O acumulador da biblioteca dev.energy().wh(0) continua a contar durante todo o tempo em que a janela offline dura — nenhum dado se perde enquanto o ESP32 estiver alimentado.
Orçamento energético
O handshake TLS é uma operação dispendiosa: ~3 s + ~30 kB de heap por ligação. Para registadores de deep sleep alimentados por bateria (ver o cenário do registador de deep sleep a bateria em 06 · Exemplos):
-
Reutilize a sessão TLS se o intervalo de suspensão for < 24 h (a maioria dos brokers geridos suporta retoma de sessão).
-
Agrupe várias medições num cartão SD local num único POST em lote por ativação.
-
Use MQTT sobre TLS com sessão persistente (
cleansession=0) para não republicar a configuração de descoberta a cada ativação.
Com um intervalo de despertar de 10 minutos numa bateria Li-ion de 2000 mAh, espere ~3 meses de funcionamento em WiFi + TLS, contra ~6 meses em WiFi + MQTT simples.
Ligações
-
06 · Exemplos — os sketches base sobre os quais assentam as integrações cloud
-
07 · Integrações DIY — alternativas auto-alojadas
-
10 · Resolução de problemas — quedas de WiFi / depuração do handshake TLS / problemas de heap
Fonte e problemas: rb-amp/rbamp-arduino · esta página no repositório: docs/08_cloud_integrations.md (v1.6.2)