08 · Cloud-Integrationen
So senden Sie RbAmp-Messwerte an Cloud-Plattformen — AWS IoT Core, Azure IoT Hub, Google Cloud und serverlose/verwaltete Observability-Pipelines. Für jede Plattform: ein ESP32-Sketch und was Sie auf der Cloud-Seite konfigurieren müssen.
Selbst gehostete DIY-Plattformen (Home Assistant, Node-RED, InfluxDB OSS) — siehe 07 · DIY-Integrationen.
| Cloud | Transport | Authentifizierung | Latenz | Kosten |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | X.509-Zertifikat | niedrig | 5 $/Mio. Nachrichten |
| Azure IoT Hub | MQTT/TLS oder AMQP | SAS-Token | niedrig | $0.40–2 je Mio. Nachrichten |
| Google Cloud IoT (eingestellt 2023) | MQTT/TLS | JWT | — | n/a |
| InfluxDB Cloud | HTTPS-Line-Protokoll | API-Token | mittel | $250/mo+ |
| Generischer Webhook / REST | HTTPS-POST | API-Schlüssel | hoch | abhängig |
⚠ TLS auf dem ESP32. Jede Cloud-Verbindung über TLS fügt ca. 30 kB Code und ca. 30 kB Heap für den Handshake hinzu. AVR / ESP8266 haben keinen RAM für TLS — für diese Plattformen brauchen Sie einen lokalen MQTT-Broker, der zur Cloud weiterleitet (Mosquitto → Brücke → AWS IoT).
AWS IoT Core
AWS IoT Core verwendet gegenseitiges TLS mit einem X.509-Gerätezertifikat.
Bereitstellung
- AWS-Konsole → IoT Core → Manage → Things → Create things → Single thing.
-
Erzeugen Sie ein Zertifikat + Schlüssel; laden Sie
device.cert.pem,device.private.key,AmazonRootCA1.pemherunter. -
Hängen Sie eine Richtlinie an, die
iot:Connectundiot:Publishaufarn:aws:iot:erlaubt.: :topic/rbamp/+/state -
Beachten Sie den AWS-IoT-Endpunkt:
xxxxxx-ats.iot...amazonaws.com:8883
ESP32-Sketch
#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);
}
Verarbeitung auf der Cloud-Seite
-
Legen Sie eine IoT-Regel an:
SELECT *, topic(2) AS device FROM 'rbamp/+/state'→ Kinesis Data Firehose oder Lambda zur Speicherung. -
Für Dashboards — AWS IoT SiteWise (Industrie-Historian) oder Timestream (Zeitreihendatenbank) → QuickSight.
-
Läuft Home Assistant auf einem Pi und bezieht Daten aus AWS, richten Sie eine lokale Mosquitto-Brücke ein (günstiger und schneller als HA → AWS direkt).
Zu den Kosten
Veröffentlicht man einmal pro Minute und Gerät, ergeben sich bei AWS IoT ca. 525k Nachrichten pro Jahr → ca. $2.60 pro Jahr und Gerät im Tarif "Connectivity" + "Messaging" (2026, us-east-1). Timestream- / Lambda-Kosten kommen separat hinzu.
Azure IoT Hub
Azure IoT Hub unterstützt MQTT 3.1.1 über TLS mit SAS-Token-Authentifizierung (einfacher als X.509 für den Heimgebrauch).
Bereitstellung
-
Azure-Portal → IoT Hub → Geräte → Neu → Geräte-ID
rbamp-main, Authentifizierung = Symmetrischer Schlüssel. -
Speichern Sie den Verbindungsstring:
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Erzeugen Sie ein SAS-Token (zum Beispiel über
az iot hub generate-sas-tokenoder ein beliebiges Azure-SDK).
ESP32-Sketch (langlebiges SAS-Token)
#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);
}
SAS-Token-Ablauf
SAS-Token tragen einen expiry-Anspruch — die typische Laufzeit reicht von 1 Stunde bis 1 Jahr. Für ein ESP32-Einsatz erzeugen Sie auf dem Build-Rechner ein 1-Jahres-Token und brennen es in die Firmware. Für eine automatische, unbeaufsichtigte Erneuerung aktualisieren Sie es regelmäßig über den Azure IoT Hub Device Provisioning Service (DPS); das geht über den Umfang der Bibliothek hinaus.
Verarbeitung auf der Cloud-Seite (Azure)
-
Leiten Sie Nachrichten für hohen Durchsatz an Event Hubs → Stream Analytics → Power-BI-Dashboards weiter.
-
Eine günstigere Alternative: Nachrichten → Storage Account (Blob) → Synapse Serverless SQL für Ad-hoc-Abfragen.
Google Cloud IoT (EINGESTELLT 2023)
Google hat Cloud IoT Core 2023 eingestellt. Migrationswege:
-
MQTT-Broker auf Compute Engine (Mosquitto installieren Sie selbst in einer VM) — dasselbe Sketch-Muster wie in 07 · DIY-Integrationen, Abschnitt Home Assistant, aber mit der öffentlichen IP Ihrer VM.
-
HiveMQ Cloud / EMQX Cloud — verwaltete MQTT-Broker, ca. 10–20 $/Monat in Hobby-Tarifen.
-
Pub/Sub über HTTPS — direkt an ein Pub/Sub-Thema über die REST-API veröffentlichen (Authentifizierung über einen Dienstkontoschlüssel, der auf dem ESP32 hinterlegt ist).
Für Pub/Sub über HTTPS siehe den Abschnitt "Generischer Webhook / REST" weiter unten, mit dem Pub/Sub-Veröffentlichungsendpunkt als Ersatz.
InfluxDB Cloud (TLSv1.3 + Line-Protokoll)
InfluxDB Cloud (Serverless-Stufe) nimmt Line-Protokoll über HTTPS an — dieselbe Form wie der OSS-Pfad in 07 · DIY-Integrationen, Abschnitt InfluxDB OSS, nur mit cloud2.influxdata.com als Host und einem API-Token zur Authentifizierung.
#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));
Die kostenlose InfluxDB-Cloud-Stufe (5 GB / 30 Tage Aufbewahrung) deckt ca. 5000 Punkte bei einem Minutentakt pro Tag ab — großzügig für den Heimgebrauch.
Generischer Webhook / REST
Veröffentlichung an einen beliebigen HTTPS-Endpunkt mit API-Schlüssel — funktioniert mit IFTTT-Webhooks, eigenen Flask-/FastAPI-Diensten oder jeder über HTTPS erreichbaren Cloud-Funktion (AWS Lambda / Azure Functions / GCP Cloud Run).
#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);
}
}
Bei niedriger Rate (≤ einmal pro Minute) ist der Mehraufwand akzeptabel. Bei höheren Raten bündeln Sie die Daten auf dem ESP32 (sammeln Sie 10 Minuten in einem Ringpuffer und veröffentlichen Sie sie als ein JSON-Stapel), damit Sie nicht für jeden Request einen TLS-Handshake bezahlen.
Hybrid: lokale Speicherung + Synchronisation in die Cloud
Für Einsätze, die Offline-Ausfälle tolerieren: protokollieren Sie einmal pro Minute auf SPIFFS / einer SD-Karte und senden Sie einmal pro Stunde an die Cloud. So überstehen Sie WLAN-Abbrüche ohne Datenverlust.
#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
}
Der Akkumulator der Bibliothek dev.energy().wh(0) zählt die ganze Zeit weiter, solange das Offline-Fenster dauert — es gehen keine Daten verloren, solange der ESP32 mit Strom versorgt bleibt.
Energiebudget
Der TLS-Handshake ist eine aufwendige Operation: ca. 3 s + ca. 30 kB Heap pro Verbindung. Für Logger im Tiefschlaf (siehe das Szenario des batteriebetriebenen Tiefschlaf-Loggers in 06 · Beispiele):
-
Verwenden Sie die TLS-Sitzung erneut, wenn das Schlafintervall < 24 h beträgt (die meisten verwalteten Broker unterstützen die Wiederaufnahme der Sitzung).
-
Fassen Sie mehrere Messungen auf einer lokalen SD-Karte zu einem Sammel-POST pro Aufwachvorgang zusammen.
-
Verwenden Sie MQTT über TLS mit einer persistenten Sitzung (
cleansession=0), damit Sie die Discovery-Konfiguration nicht bei jedem Aufwachen neu veröffentlichen.
Bei einem Weckintervall von 10 Minuten auf einer 2000-mAh-Li-Ion-Zelle ist mit ca. 3 Monaten Betrieb über WLAN + TLS zu rechnen, gegenüber ca. 6 Monaten über WLAN + reines MQTT.
Links
-
06 · Beispiele — die Basis-Sketches, auf denen die Cloud-Integrationen aufbauen
-
07 · DIY-Integrationen — selbst gehostete Alternativen
-
10 · Fehlerbehebung — WLAN-Abbrüche / Fehlersuche beim TLS-Handshake / Heap-Probleme
Quelle & Probleme: rb-amp/rbamp-arduino · diese Seite im Repo: docs/08_cloud_integrations.md (v1.6.2)