rbAmp
IT
Negozio
Docs
Aggiornato · Modifica su GitHub [Edit on GitHub]

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
Sicurezza

⚠ 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:

Python
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:

  1. Byte incorporati — file di certificato come oggetti Python nello script:
Python
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)
  1. Tramite il filesystem della flash — collochi i file dei certificati in /lib/certs/ sul dispositivo (con mpremote cp) e li legga con il comune open():
Python
with open("/lib/certs/ca.pem", "rb") as f:
    ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
Nota

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

  1. Console AWS → IoT Core → Manage → Things → Create things → Single thing.
  2. Generi il certificato + le chiavi; scarichi device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Associi una policy che conceda iot:Connect, iot:Publish su arn:aws:iot:::topic/rbamp/+/state.

  4. Annoti il suo endpoint AWS IoT: xxxxxx-ats.iot..amazonaws.com:8883.

Versione CPython (AWS IoT)

Python
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)

Python
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():

Python
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

  1. Portale Azure → IoT Hub → Dispositivi → Nuovo → ID dispositivo rbamp-main, autenticazione = Chiave simmetrica.

  2. Salvare la stringa di connessione: HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Generare un token SAS. Su CPython tramite l'SDK azure-iot-device oppure un HMAC manuale:

Python
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=")
  1. 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)

Python
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)

Python
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:

Python
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)

Python
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)

Python
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)
Nota

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

Python
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

Python
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)

Python
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)

Python
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.simple supporta una sessione persistente con clean_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).



Sorgente e segnalazioni: rb-amp/rbamp-python · questa pagina nel repo: docs/08_cloud_integrations.md (v1.6.1)