rbAmp
FR
Boutique
Docs
Mis à jour · Modifier sur GitHub [Edit on GitHub]

08 · Intégrations cloud

Comment envoyer les mesures rbamp vers les plateformes cloud — AWS IoT Core, Azure IoT Hub, Google Cloud et les chaînes de supervision serverless ou gérées. Pour chaque plateforme, une configuration Python et les instructions côté plateforme.

Plateformes DIY auto-hébergées (Home Assistant, Node-RED, InfluxDB OSS) — voir 07 · Intégrations DIY.

Cloud Transport Authentification CPython MicroPython
AWS IoT Core MQTT/TLS Certificat X.509 paho-mqtt + ssl umqtt.simple(ssl=True)
Azure IoT Hub MQTT/TLS Jeton SAS paho-mqtt + ssl umqtt.simple(ssl=True)
Google Cloud IoT (déprécié en 2023) MQTT/TLS JWT (migration — voir ci-dessous) identique
InfluxDB Cloud Protocole de ligne HTTPS Jeton API requests urequests
Webhook générique / REST POST HTTPS Clé API requests urequests
Sécurité

⚠ Coût du TLS sous MicroPython. Un handshake TLS nécessite environ 30 ko de tas sur l'ESP32. Sur de petites cibles (ESP32-C2), cela peut provoquer un OOM si le Wi-Fi et les tampons tournent en parallèle. Sous CPython, c'est pratiquement sans problème (les Pi 3+/4+ ont 1 Go de RAM ou plus).

Pour les cibles à mémoire réduite, nous recommandons un pont Mosquitto local sur un Pi/SBC : l'appareil MicroPython publie vers mqtts://local-broker (avec un TLS minimal, ou sans TLS du tout à l'intérieur du LAN), et le pont relaie vers le broker cloud en TLS.

Certificats TLS — deux approches

CPython — chemins de fichiers

CPython est livré avec les ca-certificates du système (Debian/Ubuntu : /etc/ssl/certs/). Pour des certificats d'appareil supplémentaires, placez les fichiers à côté de votre script et passez les chemins à 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 — intégré en octets ou système de fichiers

MicroPython ne dispose pas de stockage TLS complet sur système de fichiers. Deux options :

  1. Octets intégrés — fichiers de certificat sous forme d'objets Python dans le 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. Via le système de fichiers flash — placez les fichiers de certificat dans /lib/certs/ sur l'appareil (via mpremote cp) et lisez-les avec le open() standard :
Python
with open("/lib/certs/ca.pem", "rb") as f:
    ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
Remarque

Sur certains ports MicroPython (surtout ESP8266), ssl.SSLContext est absent — une version simplifiée ussl.wrap_socket(...) avec une validation limitée est utilisée à la place. Pour la production, choisissez une cible de la famille ESP32 avec une pile TLS complète.


AWS IoT Core

AWS IoT Core utilise le TLS mutuel avec un certificat X.509 de l'appareil.

Provisionnement

  1. Console AWS → IoT Core → Manage → Things → Create things → Single thing [Manage → Things → Create things → Single thing].
  2. Générez le certificat et les clés ; téléchargez device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Attachez une politique accordant iot:Connect, iot:Publish sur arn:aws:iot:::topic/rbamp/+/state.

  4. Notez votre point de terminaison AWS IoT : xxxxxx-ats.iot..amazonaws.com:8883.

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

Version 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

Traitement côté cloud

  • Créez une IoT Rule [IoT Rule] : SELECT *, topic(2) AS device FROM 'rbamp/+/state' → Kinesis Data Firehose ou Lambda pour le stockage.

  • Pour les tableaux de bord — AWS IoT SiteWise (historien industriel) ou Timestream (base de séries temporelles) → QuickSight.

  • Si Home Assistant tourne sur un Pi et consomme les données d'AWS, mettez en place un pont Mosquitto local (moins cher et plus rapide que HA → AWS directement).

Alternative CPython — boto3 via l'API REST

Pour des publications peu fréquentes (une fois par heure ou moins), vous pouvez ignorer MQTT et utiliser 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'autorisation passe par la chaîne standard d'identifiants AWS (variables d'environnement / ~/.aws/credentials / rôle IAM). Pratique pour la publication par lots via cron depuis un Pi. MicroPython n'a pas de boto3.

Sur le coût

Avec une publication par minute et par appareil, AWS IoT représente environ 525 k messages par an → ~2.60 $/an/appareil au tarif « Connectivity » + « Messaging » (2026, us-east-1). Les coûts Timestream / Lambda sont à part.


Azure IoT Hub

Azure IoT Hub prend en charge MQTT 3.1.1 sur TLS avec authentification par jeton SAS (plus simple que X.509 pour un usage domestique).

Provisionnement

  1. Portail Azure → IoT Hub → Appareils → Nouveau → ID d'appareil rbamp-main, authentification = Clé symétrique.

  2. Enregistrez la chaîne de connexion : HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Générez un jeton SAS. Sur CPython via le SDK azure-iot-device ou un HMAC manuel :

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. Sur MicroPython — soit ucryptolib + un HMAC manuel (lent), soit simplement un jeton SAS d'une durée de 1 an généré sur la machine de build et codé en dur.

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

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

Expiration du jeton SAS

Les jetons SAS portent une revendication expiry — une durée de vie typique va d'1 heure à 1 an. Pour un déploiement CPython, utilisez le SDK azure-iot-device ; il renouvelle le jeton lui-même. Pour MicroPython, générez un jeton d'1 an sur la machine de build et intégrez-le au script ; ou implémentez la rotation HMAC via ucryptolib.

Traitement côté cloud (Azure)

  • Acheminez les messages vers Event Hubs pour une ingestion à haut débit → Stream Analytics → tableaux de bord Power BI.

  • Une alternative moins chère : messages → Storage Account (blob) → Synapse Serverless SQL pour les requêtes ad hoc.


Google Cloud IoT (DÉPRÉCIÉ en 2023)

Google a arrêté Cloud IoT Core en 2023. Voies de migration :

  • Un broker MQTT sur Compute Engine (vous déployez votre propre Mosquitto dans une VM) — le même schéma que dans 07 · Intégrations DIY, mais pointant vers l'IP publique de votre VM.

  • HiveMQ Cloud / EMQX Cloud — brokers MQTT gérés, ~10-20 $/mois sur les offres d'amateurs.

  • Pub/Sub via HTTPS — publier directement dans un sujet Pub/Sub via l'API REST. Sous CPython, c'est plus simple via le SDK google-cloud-pubsub + une clé JSON de compte de service :

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

Pour la publication Pub/Sub sous MicroPython via HTTPS — voir la section « Webhook générique / REST » ci-dessous, en remplaçant par le point de terminaison de publication Pub/Sub et un jeton bearer OAuth.


InfluxDB Cloud (TLSv1.3 + protocole de ligne)

InfluxDB Cloud (offre Serverless) accepte le line-protocol en HTTPS — même forme que la voie OSS de 07 · Intégrations DIY, mais avec cloud2.influxdata.com comme hôte et un jeton API pour l'authentification.

Version 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 utilise le jeu de CA du système — sur une installation CPython Debian/Ubuntu standard, cela « fonctionne simplement ».

Version 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)
Remarque

Sur la plupart des portages MicroPython, urequests utilise un jeu de CA intégré (sans vérification) ou celui du système. Pour une validation stricte, utilisez urequests.post(..., verify=True) si votre portage le prend en charge ; sinon passez par ssl.SSLContext + usocket de bas niveau.

L'offre gratuite InfluxDB Cloud (5 Go / 30 jours de rétention) couvre environ 5000 points à une cadence d'une minute par jour — largement suffisant pour un usage domestique.


Webhook / REST générique

Publication vers n'importe quel endpoint HTTPS avec une clé d'API — fonctionne avec les webhooks IFTTT, les services Flask / FastAPI maison, ou toute fonction cloud (AWS Lambda / Azure Functions / GCP Cloud Run) exposée en 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)

À faible cadence (≤ une fois par minute), la surcharge est acceptable. À cadence plus élevée, regroupez les données côté Python (accumulez 10 minutes dans un tampon circulaire et publiez un seul JSON en bloc) pour ne pas payer une négociation TLS à chaque requête.


Hybride : stockage local + synchronisation vers le cloud

Pour les déploiements tolérants aux coupures : journalisez localement une fois par minute et envoyez vers le cloud une fois par heure. Cela survit aux coupures Wi-Fi et aux pannes du cloud sans perte de données.

CPython (rotation de fichier + synchro horaire)

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 (ajout au fichier + nouvelle tentative à la connexion)

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

L'accumulateur dev.energy.wh(0) du paquet continue de compter pendant toute la fenêtre hors ligne — aucune donnée n'est perdue tant que l'hôte Python reste alimenté.


Budget énergétique (pour les déploiements MicroPython sur batterie)

Un handshake TLS est une opération coûteuse : ~3 s + ~30 ko de tas par connexion. Pour les scénarios de veille profonde MicroPython (voir 06 · Exemples, scénario 9) :

  • Réutiliser la session TLS entre les réveils via la reprise de session TLS — umqtt.simple gère une session persistante via clean_session=False, et le broker retient vos abonnements.

  • Regrouper plusieurs mesures sur la mémoire flash locale et les publier en un seul POST en bloc à chaque réveil — le schéma de la section « Hybride » ci-dessus.

  • Le keepalive MQTT n'a pas besoin d'être maintenu hors veille profonde — l'appareil dort entre les réveils, et le handshake TLS s'exécute à chaque réveil (sauf reprise).

Avec un intervalle de réveil de 10 minutes sur une batterie Li-ion de 2000 mAh, comptez environ 3 mois d'autonomie en Wi-Fi + TLS, contre environ 6 mois en Wi-Fi + MQTT non chiffré (voir le scénario 9).

CPython sur un Raspberry Pi tourne normalement 24/7 sur une alimentation — le budget énergétique du TLS n'est pas critique. Pour un déploiement en production avec optimisation de la consommation du Pi, voir 10 · Dépannage, section « Le script se bloque / plante sur dépassement de délai » (une boucle sensible aux signaux pour systemctl suspend).


  • 06 · Exemples — les projets de base sur lesquels s'appuient les intégrations cloud (surtout le scénario 9 « enregistreur en veille profonde » et le scénario 10 « streaming asynchrone »)

  • 07 · Intégrations DIY — alternatives auto-hébergées

  • 10 · Dépannage — négociation TLS / budget de tas / gestion des signaux


Sources et problèmes : rb-amp/rbamp-python · cette page dans le dépôt : docs/08_cloud_integrations.md (v1.6.1)