08 · Integrazioni cloud
Come inviare le letture di rbamp alle piattaforme cloud — AWS IoT Core, Azure IoT Hub, Google Cloud e pipeline di osservabilità serverless / gestite. Per ciascuna piattaforma ci sono una configurazione Python e le istruzioni lato cloud.
Piattaforme DIY self-hosted (Home Assistant, Node-RED, InfluxDB OSS) — vedi 07 · Integrazioni fai-da-te.
| Cloud | Trasporto | Autenticazione | CPython | MicroPython |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | Certificato X.509 | paho-mqtt + ssl |
umqtt.simple(ssl=True) |
| Azure IoT Hub | MQTT/TLS | Token SAS | paho-mqtt + ssl |
umqtt.simple(ssl=True) |
| Google Cloud IoT (deprecato nel 2023) | MQTT/TLS | JWT | (migrazione — vedi sotto) | uguale |
| InfluxDB Cloud | Line protocol HTTPS | Token API | requests |
urequests |
| Webhook generico / REST | HTTPS POST | chiave API | requests |
urequests |
⚠ Costo del TLS su MicroPython. Un handshake TLS richiede circa 30 kB di heap sull'ESP32. Su target piccoli (ESP32-C2) può esaurire la memoria se Wi-Fi + buffer girano in parallelo. Su CPython è praticamente irrilevante (i Pi 3+/4+ hanno 1+ GB di RAM).
Per i target con memoria limitata raccomandiamo un bridge Mosquitto locale su un Pi/SBC: il dispositivo MicroPython pubblica su mqtts://local-broker (con TLS minimo, o senza TLS del tutto all'interno della LAN), e il bridge inoltra al broker cloud via TLS.
Certificati TLS — due approcci
CPython — percorsi del filesystem
CPython include i ca-certificates di sistema (Debian/Ubuntu: /etc/ssl/certs/). Per certificati aggiuntivi del dispositivo, mettere i file accanto allo script e passare i percorsi a ssl.SSLContext:
import ssl
ctx = ssl.create_default_context(cafile="/etc/ssl/certs/ca-certificates.crt")
# For mutual TLS (AWS IoT) — add the device cert + key:
ctx.load_cert_chain(certfile="device.cert.pem", keyfile="device.private.key")
MicroPython — incorporati nei byte o nel filesystem
MicroPython non dispone di un archivio TLS su filesystem completo. Due opzioni:
- Byte incorporati — file di certificato come oggetti Python nello script:
AWS_ROOT_CA = b"""-----BEGIN CERTIFICATE-----
MIIDQTCC...
-----END CERTIFICATE-----
"""
import ssl
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.load_verify_locations(cadata=AWS_ROOT_CA)
- Tramite il filesystem della flash — collochi i file dei certificati in
/lib/certs/sul dispositivo (conmpremote cp) e li legga con il comuneopen():
with open("/lib/certs/ca.pem", "rb") as f:
ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
Su alcune porte MicroPython (soprattutto ESP8266) ssl.SSLContext non è presente — si usa invece una versione semplificata ussl.wrap_socket(...) con verifica limitata. Per i deployment in produzione scelga un target della famiglia ESP32 con uno stack TLS completo.
AWS IoT Core
AWS IoT Core usa TLS mutuo con un certificato X.509 del dispositivo.
Provisioning
- Console AWS → IoT Core → Manage → Things → Create things → Single thing.
-
Generi il certificato + le chiavi; scarichi
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Associi una policy che conceda
iot:Connect,iot:Publishsuarn:aws:iot:.: :topic/rbamp/+/state -
Annoti il suo endpoint AWS IoT:
xxxxxx-ats.iot...amazonaws.com:8883
Versione CPython (AWS IoT)
import json, ssl, time
from smbus2 import SMBus
import paho.mqtt.client as mqtt_client
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
AWS_ENDPOINT = "xxxxxx-ats.iot.eu-west-1.amazonaws.com"
AWS_CLIENT_ID = "rbamp-main"
ctx = ssl.create_default_context(cafile="AmazonRootCA1.pem")
ctx.load_cert_chain(certfile="device.cert.pem",
keyfile="device.private.key")
mqtt = mqtt_client.Client(AWS_CLIENT_ID, protocol=mqtt_client.MQTTv311)
mqtt.tls_set_context(ctx)
mqtt.connect(AWS_ENDPOINT, 8883, keepalive=60)
mqtt.loop_start()
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
payload = {
"voltage": round(dev.voltage, 1),
"power": round(snap.avg_p[0], 1),
"energy": round(dev.energy.wh(0), 3),
"freq": round(dev.frequency, 1),
}
mqtt.publish("rbamp/main/state", json.dumps(payload), qos=1)
Versione MicroPython (AWS IoT)
import time, ujson, ssl
from machine import I2C, Pin
from umqtt.simple import MQTTClient
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
AWS_ENDPOINT = b"xxxxxx-ats.iot.eu-west-1.amazonaws.com"
# Cert files in `/lib/certs/` (copied over via mpremote cp)
with open("/lib/certs/AmazonRootCA1.pem", "rb") as f:
AWS_ROOT_CA = f.read()
with open("/lib/certs/device.cert.pem", "rb") as f:
DEV_CERT = f.read()
with open("/lib/certs/device.private.key", "rb") as f:
DEV_KEY = f.read()
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
ctx.load_verify_locations(cadata=AWS_ROOT_CA)
ctx.load_cert_chain(certfile="/lib/certs/device.cert.pem",
keyfile="/lib/certs/device.private.key")
mqtt = MQTTClient(b"rbamp-main", AWS_ENDPOINT, port=8883,
keepalive=60, ssl=ctx)
mqtt.connect()
i2c = I2C(0, scl=Pin(22), sda=Pin(21), freq=50_000)
with RbAmp(i2c, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
payload = ujson.dumps({
"voltage": round(dev.voltage, 1),
"power": round(snap.avg_p[0], 1),
"energy": round(dev.energy.wh(0), 3),
"freq": round(dev.frequency, 1),
})
mqtt.publish(b"rbamp/main/state", payload.encode(), qos=1)
mqtt.ping() # keepalive
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).
Alternativa CPython — boto3 tramite l'API REST
Per pubblicazioni poco frequenti (una volta all'ora o meno), si può evitare MQTT e usare boto3.client('iot-data').publish():
import boto3, json
iot = boto3.client("iot-data", region_name="eu-west-1")
iot.publish(topic="rbamp/main/state",
qos=1, payload=json.dumps(payload))
L'autorizzazione avviene tramite la catena standard delle credenziali AWS (variabili d'ambiente / ~/.aws/credentials / ruolo IAM). Comoda per la pubblicazione batch da cron da un Pi. MicroPython non ha boto3.
Sul costo
Pubblicando una volta al minuto per dispositivo, AWS IoT arriva a ~525 k messaggi l'anno → ~$2.60/anno/dispositivo con la tariffa «Connettività» e «Messaggistica» (Connectivity / Messaging) (2026, us-east-1). I costi di Timestream / Lambda sono 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. Su CPython tramite l'SDK
azure-iot-deviceoppure un HMAC manuale:
import time, hmac, hashlib, urllib.parse, base64
def generate_sas(uri, key, expiry_seconds=3600 * 24 * 365):
expiry = int(time.time()) + expiry_seconds
string_to_sign = urllib.parse.quote_plus(uri) + "\n" + str(expiry)
sig = base64.b64encode(hmac.new(
base64.b64decode(key),
string_to_sign.encode(),
hashlib.sha256
).digest())
return ("SharedAccessSignature "
f"sr={urllib.parse.quote_plus(uri)}"
f"&sig={urllib.parse.quote_plus(sig.decode())}"
f"&se={expiry}")
sas = generate_sas("foo.azure-devices.net/devices/rbamp-main", "BASE64KEY=")
- Su MicroPython — o
ucryptolib+ un HMAC manuale (lento), oppure semplicemente un token SAS di 1 anno generato sulla macchina di build e incorporato nel codice.
Versione CPython (Azure IoT Hub)
import json, ssl, time
import paho.mqtt.client as mqtt_client
AZ_HOST = "foo.azure-devices.net"
AZ_DEVICE = "rbamp-main"
AZ_USERNAME = f"{AZ_HOST}/{AZ_DEVICE}/?api-version=2021-04-12"
AZ_SAS = "SharedAccessSignature sr=...&sig=...&se=..." # see above
ctx = ssl.create_default_context() # Uses the system CAs
mqtt = mqtt_client.Client(AZ_DEVICE, protocol=mqtt_client.MQTTv311)
mqtt.username_pw_set(AZ_USERNAME, password=AZ_SAS)
mqtt.tls_set_context(ctx)
mqtt.connect(AZ_HOST, 8883, keepalive=60)
mqtt.loop_start()
# Inside your 60-second loop:
mqtt.publish(f"devices/{AZ_DEVICE}/messages/events/",
json.dumps(payload), qos=1)
Versione MicroPython (Azure IoT Hub)
from umqtt.simple import MQTTClient
import ssl
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
# Azure root CA (Baltimore CyberTrust or DigiCert Global G2):
with open("/lib/certs/azure_ca.pem", "rb") as f:
ctx.load_verify_locations(cadata=f.read())
mqtt = MQTTClient(b"rbamp-main", b"foo.azure-devices.net", port=8883,
user=AZ_USERNAME.encode(),
password=AZ_SAS.encode(),
keepalive=60, ssl=ctx)
mqtt.connect()
# In the loop:
mqtt.publish(b"devices/rbamp-main/messages/events/",
ujson.dumps(payload).encode(), qos=1)
Scadenza del token SAS
I token SAS hanno un'attestazione expiry — una durata tipica va da 1 ora a 1 anno. Per un deploy CPython usare l'SDK azure-iot-device, che rinnova il token da sé. Per MicroPython generare un token di 1 anno sulla macchina di build e incorporarlo nello script; oppure implementare la rotazione HMAC tramite ucryptolib.
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:
-
Un broker MQTT su Compute Engine (si installa il proprio Mosquitto in una VM) — lo stesso schema di 07 · Integrazioni fai-da-te, ma puntato all'IP pubblico della VM.
-
HiveMQ Cloud / EMQX Cloud — broker MQTT gestiti, ~$10-20/mese nei piani per hobbisti.
-
Pub/Sub tramite HTTPS — pubblichi direttamente su un topic Pub/Sub tramite l'API REST. Su CPython è più semplice usare l'SDK
google-cloud-pubsub+ una chiave JSON di account di servizio:
from google.cloud import pubsub_v1
import json
publisher = pubsub_v1.PublisherClient.from_service_account_json("key.json")
topic_path = publisher.topic_path("my-project", "rbamp")
publisher.publish(topic_path, json.dumps(payload).encode())
Per il Pub/Sub MicroPython su HTTPS — vedere la sezione "Webhook / REST generico" più sotto, sostituendo l'endpoint di pubblicazione Pub/Sub + un bearer token OAuth.
InfluxDB Cloud (TLSv1.3 + line protocol)
InfluxDB Cloud (piano Serverless) accetta il line-protocol via HTTPS — la stessa forma del percorso OSS in 07 · Integrazioni fai-da-te, ma con cloud2.influxdata.com come host e un token API per l'autenticazione.
Versione CPython (InfluxDB Cloud)
import requests, time
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
INFLUX_URL = "https://us-east-1-1.aws.cloud2.influxdata.com/api/v2/write?org=MyOrg&bucket=energy&precision=s"
INFLUX_TOKEN = "your-rw-token"
def push_influx(u, p, e_wh):
body = f"rbamp,device=main voltage={u:.1f},power={p:.1f},energy={e_wh:.3f}"
try:
r = requests.post(INFLUX_URL, data=body,
headers={
"Authorization": f"Token {INFLUX_TOKEN}",
"Content-Type": "text/plain",
},
timeout=10) # TLS handshake can take up to 3 s
if r.status_code != 204:
print(f"influx HTTP {r.status_code}: {r.text}")
except requests.RequestException as e:
print("influx request failed:", e)
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
continue
push_influx(dev.voltage, snap.avg_p[0], dev.energy.wh(0))
requests usa il bundle CA di sistema — su una normale installazione CPython Debian/Ubuntu questo «funziona e basta».
Versione MicroPython (InfluxDB Cloud)
import urequests as requests, ujson, ssl, time
from machine import I2C, Pin
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
INFLUX_URL = "https://us-east-1-1.aws.cloud2.influxdata.com/api/v2/write?org=MyOrg&bucket=energy&precision=s"
INFLUX_TOKEN = "your-rw-token"
# Custom SSL context with embedded CA (DigiCert Global G2)
ctx = ssl.SSLContext(ssl.PROTOCOL_TLS_CLIENT)
with open("/lib/certs/digicert_g2.pem", "rb") as f:
ctx.load_verify_locations(cadata=f.read())
def push_influx(u, p, e_wh):
body = "rbamp,device=main voltage={:.1f},power={:.1f},energy={:.3f}".format(u, p, e_wh)
try:
r = requests.post(INFLUX_URL, data=body,
headers={
"Authorization": "Token " + INFLUX_TOKEN,
"Content-Type": "text/plain",
})
if r.status_code != 204:
print("influx HTTP", r.status_code)
r.close() # MicroPython socket cleanup
except OSError as e:
print("influx request failed:", e)
Su molte porte MicroPython urequests usa un bundle CA integrato (senza verifica) oppure quello di sistema. Per una validazione rigorosa — usare urequests.post(..., verify=True) se la porta lo supporta; altrimenti passare da ssl.SSLContext + usocket di basso livello.
Il piano gratuito di InfluxDB Cloud (5 GB / 30 giorni di conservazione) copre circa 5000 punti con una cadenza di un minuto al giorno — abbondante per un uso domestico.
Webhook / REST generico
Pubblicazione su qualsiasi endpoint HTTPS con una chiave API — funziona con webhook IFTTT, servizi Flask / FastAPI personalizzati, o qualsiasi cloud function (AWS Lambda / Azure Functions / GCP Cloud Run) esposta come HTTPS.
CPython
import requests, time, json
WEBHOOK_URL = "https://your-api.example.com/ingest"
API_KEY = "Bearer your-token-here"
def push_webhook(u, p, e_wh):
body = {
"ts": time.time(),
"voltage": u,
"power": p,
"energy": e_wh,
}
try:
r = requests.post(WEBHOOK_URL, json=body, headers={
"Authorization": API_KEY,
}, timeout=10)
if not (200 <= r.status_code < 300):
print(f"webhook HTTP {r.status_code}: {r.text}")
except requests.RequestException as e:
print("webhook failed:", e)
MicroPython
import urequests as requests, ujson, time
def push_webhook(u, p, e_wh):
body = ujson.dumps({
"ts": time.time(),
"voltage": u,
"power": p,
"energy": e_wh,
})
try:
r = requests.post(WEBHOOK_URL, data=body, headers={
"Authorization": API_KEY,
"Content-Type": "application/json",
})
if not (200 <= r.status_code < 300):
print("webhook HTTP", r.status_code)
r.close()
except OSError as e:
print("webhook failed:", e)
A velocità bassa (≤ una volta al minuto) il sovraccarico è accettabile. A frequenze più alte, raggruppare i dati lato Python (accumulare 10 minuti in un buffer circolare e pubblicare un unico JSON in blocco) per non pagare un handshake TLS per ogni richiesta.
Ibrido: archiviazione locale + sincronizzazione con il cloud
Per installazioni tolleranti all'assenza di rete: registrare localmente una volta al minuto e inviare al cloud una volta l'ora. Così si sopravvive a cadute del Wi-Fi o interruzioni del cloud senza perdita di dati.
CPython (file a rotazione + sincronizzazione oraria)
import logging, time, csv, requests
from logging.handlers import RotatingFileHandler
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass, RbAmpStaleError
log = logging.getLogger("rbamp.csv")
log.setLevel(logging.INFO)
handler = RotatingFileHandler("rbamp.csv", maxBytes=1_000_000, backupCount=5)
handler.setFormatter(logging.Formatter("%(asctime)s,%(message)s",
datefmt="%Y-%m-%dT%H:%M:%S"))
log.addHandler(handler)
def sync_to_cloud_if_due():
"""Once an hour: read rbamp.csv, push the new rows to InfluxDB Cloud."""
# ...uses push_influx from the section above + a state file for the offset...
with SMBus(1) as bus, RbAmp(bus, 0x50) as dev:
dev.set_sensor_class(RbAmpSensorClass.SCT_013)
dev.set_ct_model(3)
last_sync = 0
while True:
time.sleep(60)
try:
snap = dev.read_period_snapshot()
except RbAmpStaleError:
log.warning("stale")
continue
log.info(f"{snap.avg_p[0]:.1f},{dev.energy.wh(0):.4f},"
f"{snap.master_dt_ms}")
if time.time() - last_sync > 3600:
sync_to_cloud_if_due()
last_sync = time.time()
MicroPython (aggiunta su file + nuovo tentativo alla connessione)
import time, ujson
def append_local(snap, dev):
with open("/lib/log.csv", "a") as f:
f.write("{:.0f},{:.1f},{:.4f},{}\n".format(
time.time(), snap.avg_p[0], dev.energy.wh(0),
snap.master_dt_ms))
def sync_if_due():
"""Once an hour: read the accumulated log, push it to the cloud."""
try:
with open("/lib/log.csv") as f:
for line in f:
# ...push_webhook(line) with retry on failure...
pass
# archive successful upload
import os
os.rename("/lib/log.csv", "/lib/log_pushed.csv")
except OSError:
pass # offline / no file yet
Il contatore dev.energy.wh(0) del pacchetto continua a contare per tutta la finestra offline — nessun dato va perso finché l'host Python resta alimentato.
Bilancio energetico (per installazioni MicroPython a batteria)
Un handshake TLS è un'operazione costosa: circa 3 s + circa 30 kB di heap per connessione. Per gli scenari di deep sleep su MicroPython (vedere 06 · Esempi, Scenario 9):
-
Riutilizzare la sessione TLS tra i risvegli tramite la ripresa della sessione TLS —
umqtt.simplesupporta una sessione persistente conclean_session=False, e il broker ricorda le sottoscrizioni. -
Raggruppare diverse misure sulla memoria flash locale e pubblicarle come un unico POST in blocco per risveglio — lo schema della sezione «Ibrido» sopra.
-
Il keepalive MQTT non va mantenuto fuori dal deep sleep — il dispositivo dorme tra un risveglio e l'altro, e l'handshake TLS avviene a ogni risveglio (a meno che non venga ripreso).
Con un intervallo di risveglio di 10 minuti su Li-ion da 2000 mAh, aspettarsi circa 3 mesi di autonomia con Wi-Fi + TLS, contro circa 6 mesi con Wi-Fi + MQTT senza TLS (vedi Scenario 9).
Un CPython su Raspberry Pi di norma funziona 24/7 con un alimentatore — il budget energetico del TLS non è critico. Per un deployment in produzione con ottimizzazione del consumo del Pi, vedere 10 · Risoluzione dei problemi, la sezione "Lo script si blocca / si arresta per timeout" (un ciclo consapevole dei segnali per systemctl suspend).
Collegamenti
-
06 · Esempi — i progetti di base su cui si fondano le integrazioni cloud (in particolare lo Scenario 9 "logger deep-sleep" e lo Scenario 10 "streaming asincrono")
-
07 · Integrazioni fai-da-te — alternative self-hosted
-
10 · Risoluzione dei problemi — handshake TLS / budget heap / gestione dei segnali
Sorgente e segnalazioni: rb-amp/rbamp-python · questa pagina nel repo: docs/08_cloud_integrations.md (v1.6.1)