08 · Cloud-Integrationen
So senden Sie rbamp-Messwerte an Cloud-Plattformen — AWS IoT Core, Azure IoT Hub, Google Cloud sowie serverlose und verwaltete Observability-Pipelines. Für jede Plattform: wie das ESP-IDF-Projekt aufgesetzt wird und was auf der Cloud-Seite zu konfigurieren ist.
Selbst gehostete DIY-Plattformen (Home Assistant, Node-RED, InfluxDB OSS) — siehe 07 · DIY-Integrationen.
Flotte → MQTT-Topics je Modul
In der kanonischen Installation (Netzanschluss + N Teillasten an einem Bus) veröffentlicht der Master Messwerte auf einem eigenen Topic für jedes Modul. Ein praktisches Muster ist, die Flotte über die Adresse des Moduls oder dessen benutzerdefiniertes LABEL zu durchlaufen:
char topic[64];
for (size_t i = 0; i < rbamp_fleet_count(fleet); ++i) {
rbamp_handle_t dev = rbamp_fleet_get(fleet, i);
char label[9]; rbamp_read_label(dev, label);
snprintf(topic, sizeof topic, "rbamp/%s/snapshot",
label[0] ? label : "unlabeled");
/* publish snaps[i] as JSON to topic */
}
Weitere Themen: rbamp/ (gesteuert durch rbamp_has_error), rbamp/fleet/total_power, rbamp/fleet/total_energy_wh, rbamp/fleet/balance (Netz − Σ(Teillasten) im kanonischen 80-%-Szenario). Ein vollständiges Beispiel mit retained Nutzlasten und Home-Assistant-Auto-Discovery steht in Kapitel 06 · Beispiele, Szenario 1.
| 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. Jeder Cloud-Transport über TLS fügt ~30 kB Code + ~30 kB Heap pro Handshake hinzu. Auf sehr kleinen Zielen mit begrenztem Speicher (insbesondere ESP32-C2, vor allem mit aktiviertem Bluetooth) kann der TLS-Heap ein Problem werden — siehe 10 · Fehlerbehebung, Abschnitt „TLS handshake fail“.
TLS-Zertifikate — dateibasiertes Muster über SPIFFS
Anders als bei der Arduino-Bibliothek, wo Zertifikate meist per PROGMEM-Strings in die Firmware eingebettet werden, bevorzugt ESP-IDF einen dateibasierten Ansatz: Zertifikatsdateien werden in einer eigenen SPIFFS-Partition abgelegt, und eine URI der Form file:///certs/aws_root_ca.pem wird an die Konfiguration übergeben.
Partitionstabelle
Fügen Sie einen Eintrag für die Zertifikatspartition in die partitions.csv Ihres Projekts ein:
# Name, Type, SubType, Offset, Size, Flags
nvs, data, nvs, 0x9000, 0x6000,
phy_init, data, phy, 0xf000, 0x1000,
factory, app, factory, 0x10000, 0x100000,
certs, data, spiffs, , 0x20000,
In sdkconfig.defaults:
CONFIG_PARTITION_TABLE_CUSTOM=y
CONFIG_PARTITION_TABLE_CUSTOM_FILENAME="partitions.csv"
SPIFFS-Image mit Zertifikaten
Legen Sie die Zertifikatsdateien in einem Verzeichnis spiffs_image/ neben main/ ab und aktivieren Sie die Image-Erzeugung in main/CMakeLists.txt:
idf_component_register(
SRCS "main.c"
INCLUDE_DIRS "."
REQUIRES rbamp mqtt esp_http_client nvs_flash esp_wifi esp_event esp_netif
)
# SPIFFS image with certificates — built at build-time and flashed into
# the "certs" partition by one of the `idf.py spiffs-certs-flash` commands.
spiffs_create_partition_image(certs
${CMAKE_SOURCE_DIR}/spiffs_image
FLASH_IN_PROJECT
)
Nach idf.py build flash liegen die Dateien aus spiffs_image/* in der Partition certs und sind über VFS unter /certs/ erreichbar.
Montage zur Laufzeit
esp_vfs_spiffs_conf_t spiffs_cfg = {
.base_path = "/certs",
.partition_label = "certs",
.max_files = 4,
.format_if_mount_failed = false,
};
ESP_ERROR_CHECK(esp_vfs_spiffs_register(&spiffs_cfg));
Danach kann der URI "file:///certs/ca.pem" an esp_mqtt_client_config_t.broker.verification.certificate_uri und ähnliche Felder übergeben werden.
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.
-
Zertifikat und Schlüssel erzeugen;
device.cert.pem,device.private.key,AmazonRootCA1.pemherunterladen. -
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
Zertifikatsdateien in SPIFFS
Legen Sie in spiffs_image/ ab:
spiffs_image/
ca.pem # AmazonRootCA1.pem
client.crt # device.cert.pem
client.key # device.private.key
ESP-IDF-Projekt
#include "freertos/FreeRTOS.h"
#include "esp_event.h"
#include "esp_log.h"
#include "esp_spiffs.h"
#include "esp_wifi.h"
#include "mqtt_client.h"
#include "nvs_flash.h"
#include "rbamp.h"
#define AWS_URI "mqtts://xxxxxx-ats.iot.eu-west-1.amazonaws.com:8883"
#define AWS_CLIENT_ID "rbamp-main"
static const char *TAG = "aws_iot";
static esp_mqtt_client_handle_t mqtt;
void app_main(void) {
/* ...nvs + netif + wifi STA until IP_EVENT_STA_GOT_IP is received... */
/* ...mount SPIFFS at /certs (see the TLS certificates section above)... */
/* ...I²C bus + rbamp_new + rbamp_begin + set_sensor_class + set_ct_model... */
rbamp_handle_t dev = NULL;
const esp_mqtt_client_config_t cfg = {
.broker.address.uri = AWS_URI,
.broker.verification.certificate_uri = "file:///certs/ca.pem",
.credentials.client_id = AWS_CLIENT_ID,
.credentials.authentication.certificate_uri = "file:///certs/client.crt",
.credentials.authentication.key_uri = "file:///certs/client.key",
.session.keepalive = 60,
};
mqtt = esp_mqtt_client_init(&cfg);
ESP_ERROR_CHECK(esp_mqtt_client_start(mqtt));
while (1) {
vTaskDelay(pdMS_TO_TICKS(60000));
rbamp_period_snapshot_t snap;
if (rbamp_read_period_snapshot(dev, &snap, 50, false) != ESP_OK ||
!snap.valid) continue;
float u, freq;
rbamp_read_voltage(dev, 0, &u);
rbamp_read_frequency(dev, &freq);
char payload[256];
snprintf(payload, sizeof(payload),
"{\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f,\"freq\":%.1f}",
(double)u, (double)snap.avg_p[0],
rbamp_energy_wh(dev, 0), (double)freq);
esp_mqtt_client_publish(mqtt, "rbamp/main/state",
payload, 0, /*qos*/0, /*retain*/0);
}
}
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 verwenden Sie AWS IoT SiteWise (industrieller Historian) oder Timestream (Zeitreihen-DB) → 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öffentlichung einmal pro Minute und Gerät ergibt bei AWS IoT ~525k Nachrichten pro Jahr → ~$2.60/Jahr/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 Anwendungen im Haushalt).
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).
Zertifikat + Konfiguration
Legen Sie das Azure-Root-CA (Baltimore CyberTrust Root oder DigiCert Global Root G2) in spiffs_image/ca.pem ab.
#define AZ_URI "mqtts://foo.azure-devices.net:8883"
#define AZ_USER "foo.azure-devices.net/rbamp-main/?api-version=2021-04-12"
#define AZ_SAS "SharedAccessSignature sr=foo.azure-devices.net%2Fdevices%2Frbamp-main&sig=…&se=…"
#define AZ_DEVICE_ID "rbamp-main"
const esp_mqtt_client_config_t cfg = {
.broker.address.uri = AZ_URI,
.broker.verification.certificate_uri = "file:///certs/ca.pem",
.credentials.client_id = AZ_DEVICE_ID,
.credentials.username = AZ_USER, /* SAS auth — no mTLS */
.credentials.authentication.password = AZ_SAS,
.session.keepalive = 60,
};
/* Publish to the Azure D2C topic: */
char topic[128];
snprintf(topic, sizeof(topic), "devices/%s/messages/events/", AZ_DEVICE_ID);
esp_mqtt_client_publish(mqtt, topic, payload, 0, /*qos*/0, /*retain*/0);
SAS-Token-Ablauf
SAS-Token tragen einen Anspruch expiry — typische Laufzeiten liegen zwischen 1 Stunde und 1 Jahr. Für eine ESP32-Installation erzeugen Sie auf dem Build-Rechner ein Token mit 1 Jahr Laufzeit und brennen es in die Firmware. Für eine automatische, unbeaufsichtigte Rotation erneuern Sie es regelmäßig über den Device Provisioning Service (DPS) von Azure IoT Hub; das liegt außerhalb des Umfangs der Komponente.
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 richten Sie selbst in einer VM ein) — dasselbe Muster wie im Abschnitt Home Assistant in 07 · DIY-Integrationen, nur mit der öffentlichen IP Ihrer VM als Ziel.
-
HiveMQ Cloud / EMQX Cloud — verwaltete MQTT-Broker, ca. 10–20 $/Monat in Hobby-Tarifen.
-
Pub/Sub über HTTPS — direkt über die REST-API an ein Pub/Sub-Thema veröffentlichen (Authentifizierung über einen JSON-Schlüssel eines Dienstkontos, im ESP32 eingebettet).
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) akzeptiert Line-Protocol über HTTPS — dieselbe Form wie der OSS-Pfad in 07 · DIY-Integrationen, Abschnitt InfluxDB OSS, aber mit cloud2.influxdata.com als Host und einem API-Token zur Authentifizierung.
Legen Sie die CA für cloud2.influxdata.com (DigiCert Global Root G2 oder ähnlich) in spiffs_image/influx_ca.pem ab.
#include "esp_http_client.h"
#include "esp_log.h"
#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"
static const char *TAG = "influx_cloud";
static esp_err_t read_ca(char *buf, size_t buflen, size_t *out_len) {
FILE *f = fopen("/certs/influx_ca.pem", "rb");
if (!f) return ESP_FAIL;
*out_len = fread(buf, 1, buflen - 1, f);
buf[*out_len] = '\0';
fclose(f);
return ESP_OK;
}
static void push_influx_cloud(float u, float p, double e_wh) {
static char ca_buf[2048];
static size_t ca_len = 0;
if (ca_len == 0) {
if (read_ca(ca_buf, sizeof(ca_buf), &ca_len) != ESP_OK) {
ESP_LOGE(TAG, "CA read failed");
return;
}
}
char body[256];
snprintf(body, sizeof(body),
"rbamp,device=main voltage=%.1f,power=%.1f,energy=%.3f",
(double)u, (double)p, e_wh);
esp_http_client_config_t cfg = {
.url = INFLUX_URL,
.method = HTTP_METHOD_POST,
.cert_pem = ca_buf,
.timeout_ms = 10000, /* TLS handshake may take up to 3 s */
};
esp_http_client_handle_t client = esp_http_client_init(&cfg);
esp_http_client_set_header(client, "Authorization", "Token " INFLUX_TOKEN);
esp_http_client_set_header(client, "Content-Type", "text/plain");
esp_http_client_set_post_field(client, body, strlen(body));
esp_err_t err = esp_http_client_perform(client);
int status = esp_http_client_get_status_code(client);
esp_http_client_cleanup(client);
if (err != ESP_OK || status != 204) {
ESP_LOGW(TAG, "influx HTTP %d (err %s)", status, esp_err_to_name(err));
}
}
/* In the 60-second loop, after rbamp_read_period_snapshot(): */
float u;
rbamp_read_voltage(dev, 0, &u);
push_influx_cloud(u, snap.avg_p[0], rbamp_energy_wh(dev, 0));
Die kostenlose InfluxDB-Cloud-Stufe (5 GB / 30 Tage Aufbewahrung) deckt ~5000 Datenpunkte bei einem Minutentakt pro Tag ab — großzügig für Heimanwendungen.
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 "esp_http_client.h"
#include "esp_log.h"
#include "esp_timer.h"
#define WEBHOOK_URL "https://your-api.example.com/ingest"
#define API_KEY "Bearer your-token-here"
static const char *TAG = "webhook";
/* CA for your HTTPS endpoint (read from /certs/webhook_ca.pem,
* via snprintf+fopen as in push_influx_cloud). */
extern const char *get_server_ca(void); /* implementation as in the InfluxDB section */
static void push_webhook(float u, float p, double e_wh) {
char body[256];
snprintf(body, sizeof(body),
"{\"ts\":%lld,\"voltage\":%.1f,\"power\":%.1f,\"energy\":%.3f}",
(long long)(esp_timer_get_time() / 1000000),
(double)u, (double)p, e_wh);
esp_http_client_config_t cfg = {
.url = WEBHOOK_URL,
.method = HTTP_METHOD_POST,
.cert_pem = get_server_ca(),
.timeout_ms = 10000,
};
esp_http_client_handle_t client = esp_http_client_init(&cfg);
esp_http_client_set_header(client, "Authorization", API_KEY);
esp_http_client_set_header(client, "Content-Type", "application/json");
esp_http_client_set_post_field(client, body, strlen(body));
esp_err_t err = esp_http_client_perform(client);
int status = esp_http_client_get_status_code(client);
esp_http_client_cleanup(client);
if (err != ESP_OK || status < 200 || status >= 300) {
ESP_LOGW(TAG, "webhook HTTP %d (err %s)", status, esp_err_to_name(err));
}
}
⚠ .skip_cert_common_name_check = false muss in der Produktion false bleiben. Beim Prototyping können Sie .use_global_ca_store = true verwenden (das Binary enthält dann keine spezifische CA, was die TLS-Sicherheit senkt) — das darf aber NIEMALS ohne eine explizite CA in die Produktion gehen.
Bei niedriger Rate (≤ einmal pro Minute) ist der Overhead 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 dann als ein einziges Bulk-JSON), damit Sie nicht für jede Anfrage einen TLS-Handshake bezahlen.
Hybrid: lokale Speicherung + Synchronisation mit der Cloud
Für Deployments, die ohne Verbindung auskommen müssen: einmal pro Minute lokal in SPIFFS protokollieren und einmal pro Stunde in die Cloud übertragen. So überstehen Sie WiFi-Ausfälle ohne Datenverlust.
#include
#include "esp_log.h"
#include "esp_timer.h"
#include "rbamp.h"
#define LOG_PATH "/storage/log.csv"
static const char *TAG = "hybrid";
static void log_to_spiffs(const rbamp_period_snapshot_t *snap,
float u, double e_wh) {
FILE *f = fopen(LOG_PATH, "a");
if (!f) {
ESP_LOGE(TAG, "fopen failed");
return;
}
fprintf(f, "%lld,%.1f,%.1f,%.3f\n",
(long long)(esp_timer_get_time() / 1000),
(double)u, (double)snap->avg_p[0], e_wh);
fclose(f);
}
static void sync_to_cloud_if_due(void) {
static int64_t last_sync_us = 0;
const int64_t now_us = esp_timer_get_time();
if ((now_us - last_sync_us) < 3600LL * 1000000LL) return; /* once per hour */
last_sync_us = now_us;
FILE *f = fopen(LOG_PATH, "r");
if (!f) return;
char line[256];
while (fgets(line, sizeof(line), f)) {
push_webhook_line(line); /* line → JSON → POST */
}
fclose(f);
/* Optionally: rename(LOG_PATH, "/storage/log_pushed.csv") + truncate */
}
Der Akkumulator der Komponente rbamp_energy_wh(dev, 0) zählt während des gesamten Offline-Fensters weiter — es gehen keine Daten verloren, solange der ESP32 mit Strom versorgt ist. Die SPIFFS-Partition storage wird in 06 · Beispiele, Szenario 8 (spiffs_logger), gezeigt.
Energiebudget
Ein TLS-Handshake ist eine aufwendige Operation: ~3 s + ~30 kB Heap pro Verbindung. Für Datenlogger mit Deep-Sleep (siehe 06 · Beispiele, Szenario 9):
-
Verwenden Sie die TLS-Sitzung erneut, wenn das Schlafintervall < 24 h beträgt — das ESP-IDF-
mbedtlsunterstützt die Sitzungswiederaufnahme über die APImbedtls_ssl_get/set_session(). Das verkürzt den Handshake auf ~500 ms. -
Stapeln Sie mehrere Messwerte in lokales SPIFFS zu einem einzigen Bulk-POST pro Aufwachvorgang — das Muster aus dem Abschnitt „Hybrid“ oben.
-
MQTT über TLS mit persistenter Sitzung (
session.disable_clean_session = trueinesp_mqtt_client_config_t) — der Broker merkt sich Ihre Abonnements zwischen den Aufwachvorgängen, sodass Sie die Discovery-Konfiguration nicht erneut veröffentlichen müssen.
Bei einem 10-Minuten-Aufwachintervall auf einer 2000-mAh-Li-Ion-Zelle ist mit ~3 Monaten Betrieb mit WiFi + TLS zu rechnen, gegenüber ~6 Monaten mit WiFi + einfachem MQTT (gemäß dem Energiebudget aus Szenario 9).
Siehe auch
-
06 · Beispiele — die Basisprojekte, auf denen die Cloud-Integrationen aufbauen (besonders Szenario 8 „spiffs_logger“ für den Hybrid-Ansatz)
-
07 · DIY-Integrationen — selbst gehostete Alternativen (Home Assistant / Node-RED / OpenHAB / InfluxDB OSS)
-
10 · Fehlerbehebung — WLAN-Abbrüche / Fehlersuche beim TLS-Handshake / Heap-Probleme
Quelle & Issues: rb-amp/rbamp-esp-idf · diese Seite im Repo: docs/08_cloud_integrations.md (v1.7.3)