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 |
⚠ 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 :
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 :
- Octets intégrés — fichiers de certificat sous forme d'objets Python dans le 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)
- Via le système de fichiers flash — placez les fichiers de certificat dans
/lib/certs/sur l'appareil (viampremote cp) et lisez-les avec leopen()standard :
with open("/lib/certs/ca.pem", "rb") as f:
ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
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
- Console AWS → IoT Core → Manage → Things → Create things → Single thing [Manage → Things → Create things → Single thing].
-
Générez le certificat et les clés ; téléchargez
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Attachez une politique accordant
iot:Connect,iot:Publishsurarn:aws:iot:.: :topic/rbamp/+/state -
Notez votre point de terminaison AWS IoT :
xxxxxx-ats.iot...amazonaws.com:8883
Version 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)
Version 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
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() :
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
-
Portail Azure → IoT Hub → Appareils → Nouveau → ID d'appareil
rbamp-main, authentification = Clé symétrique. -
Enregistrez la chaîne de connexion :
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Générez un jeton SAS. Sur CPython via le SDK
azure-iot-deviceou un HMAC manuel :
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=")
- 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)
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)
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 :
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)
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)
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)
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
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)
À 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)
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)
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.simplegère une session persistante viaclean_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).
Liens
-
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)