08 · Integraciones en la nube
Cómo enviar lecturas de rbamp a plataformas en la nube: AWS IoT Core, Azure IoT Hub, Google Cloud y pipelines de observabilidad serverless o gestionados. Para cada plataforma hay una configuración en Python y las instrucciones del lado de la nube.
Plataformas DIY autoalojadas (Home Assistant, Node-RED, InfluxDB OSS): véase 07 · Integraciones DIY.
| Nube | Transporte | Autenticación | CPython | MicroPython |
|---|---|---|---|---|
| AWS IoT Core | MQTT/TLS | Certificado 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 (obsoleto desde 2023) | MQTT/TLS | JWT | (migración: véase más abajo) | igual |
| InfluxDB Cloud | Protocolo de línea HTTPS | Token de API | requests |
urequests |
| Webhook genérico / REST | POST HTTPS | Clave de API | requests |
urequests |
⚠ Coste de TLS en MicroPython. Un handshake TLS necesita ~30 kB de heap en el ESP32. En objetivos pequeños (ESP32-C2) puede quedarse sin memoria (OOM) si tiene Wi-Fi y buffers funcionando en paralelo. En CPython es prácticamente irrelevante (las Pi 3+/4+ tienen 1 GB o más de RAM).
Para objetivos con poca memoria recomendamos un puente Mosquitto local en una Pi/SBC: el dispositivo MicroPython publica en mqtts://local-broker (con TLS mínimo, o sin TLS dentro de la LAN), y el puente reenvía al broker en la nube por TLS.
Certificados TLS — dos enfoques
CPython — rutas del sistema de archivos
CPython trae de serie los ca-certificates del sistema (Debian/Ubuntu: /etc/ssl/certs/). Para certificados adicionales del dispositivo, coloque los archivos junto a su script y pase las rutas 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 — integrado en bytes o en sistema de archivos
MicroPython no dispone de almacenamiento TLS completo en un sistema de archivos. Dos opciones:
- Bytes embebidos — archivos de certificado como objetos Python en el 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)
- Mediante el sistema de archivos de la flash: coloque los archivos de certificado en
/lib/certs/en el dispositivo (conmpremote cp) y léalos con elopen()estándar:
with open("/lib/certs/ca.pem", "rb") as f:
ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
En algunos puertos de MicroPython (sobre todo ESP8266) ssl.SSLContext no existe: se usa en su lugar un ussl.wrap_socket(...) simplificado con validación limitada. Para despliegues en producción, elija un destino de la familia ESP32 con una pila TLS completa.
AWS IoT Core
AWS IoT Core usa TLS mutuo con un certificado de dispositivo X.509.
Aprovisionamiento
- AWS Console → IoT Core → Manage → Things → Create things → Single thing.
-
Genere el certificado y las claves; descargue
device.cert.pem,device.private.key,AmazonRootCA1.pem. -
Asocie una política que conceda
iot:Connecteiot:Publishsobrearn:aws:iot:.: :topic/rbamp/+/state -
Anote su endpoint de AWS IoT:
xxxxxx-ats.iot...amazonaws.com:8883
Versión de 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)
Versión de 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
Procesamiento en la nube
-
Cree una IoT Rule:
SELECT *, topic(2) AS device FROM 'rbamp/+/state'→ Kinesis Data Firehose o Lambda para almacenamiento. -
Para paneles: AWS IoT SiteWise (historiador industrial) o Timestream (base de datos de series temporales) → QuickSight.
-
Si Home Assistant se ejecuta en una Pi y consume datos de AWS, configure un puente local de Mosquitto (más barato y rápido que HA → AWS directamente).
Alternativa CPython: boto3 mediante la API REST
Para publicaciones poco frecuentes (una vez por hora o menos) puede prescindir de MQTT y usar 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))
La autorización se hace mediante la cadena estándar de credenciales de AWS (variables de entorno / ~/.aws/credentials / rol IAM). Práctico para publicaciones por lotes con cron desde una Pi. MicroPython no tiene boto3.
Sobre el coste
Publicar una vez por minuto por dispositivo supone unos 525 k mensajes al año, es decir, ~$2.60/año/dispositivo con la tarifa «Connectivity» + «Messaging» (2026, us-east-1). Los costes de Timestream / Lambda son aparte.
Azure IoT Hub
Azure IoT Hub admite MQTT 3.1.1 sobre TLS con autenticación por token SAS (más sencillo que X.509 para uso doméstico).
Aprovisionamiento
-
Azure Portal → IoT Hub → Devices → New → ID de dispositivo
rbamp-main, autenticación = Symmetric key. -
Guarde la cadena de conexión:
HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=…. -
Genere un token SAS. En CPython, mediante el SDK
azure-iot-deviceo un HMAC manual:
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=")
- En MicroPython: o bien
ucryptolib+ un HMAC manual (lento), o bien incluir de forma fija un token SAS de 1 año generado en la máquina de compilación.
Versión de 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)
Versión de 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)
Caducidad del token SAS
Los tokens SAS llevan una reclamación expiry; una vida útil típica va de 1 hora a 1 año. Para un despliegue en CPython, use el SDK azure-iot-device, que rota el token por sí mismo. En MicroPython, genere un token de 1 año en la máquina de compilación e incrústelo en el script; o implemente la rotación HMAC mediante ucryptolib.
Procesamiento en la nube (Azure)
-
Enrute los mensajes a Event Hubs para una ingesta de alto rendimiento → Stream Analytics → paneles de Power BI.
-
Una alternativa más barata: mensajes → Storage Account (blob) → Synapse Serverless SQL para consultas ad hoc.
Google Cloud IoT (OBSOLETO desde 2023)
Google cerró Cloud IoT Core en 2023. Vías de migración:
-
Un broker MQTT en Compute Engine (despliega tu propio Mosquitto en una VM): el mismo patrón que en 07 · Integraciones DIY, pero apuntando a la IP pública de tu VM.
-
HiveMQ Cloud / EMQX Cloud: brokers MQTT gestionados, ~$10-20/mes en niveles para aficionados.
-
Pub/Sub mediante HTTPS: publique directamente en un tema de Pub/Sub a través de la API REST. En CPython es más sencillo con el SDK
google-cloud-pubsuby una clave JSON de cuenta de servicio:
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())
Para Pub/Sub de MicroPython sobre HTTPS, véase la sección "Webhook / REST genérico" más abajo, sustituyendo el endpoint de publicación de Pub/Sub y un token bearer OAuth.
InfluxDB Cloud (TLSv1.3 + protocolo de línea)
InfluxDB Cloud (nivel Serverless) acepta line-protocol sobre HTTPS: la misma forma que la ruta OSS de 07 · Integraciones DIY, pero con cloud2.influxdata.com como host y un token de API para la autenticación.
Versión de 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 el paquete de CA del sistema: en una instalación estándar de Debian/Ubuntu con CPython, esto «simplemente funciona».
Versión de 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)
En la mayoría de puertos de MicroPython, urequests usa un paquete de CA integrado (sin verificación) o el del sistema. Para una validación estricta, use urequests.post(..., verify=True) si su puerto lo admite; si no, pase por ssl.SSLContext + usocket de bajo nivel.
El nivel gratuito de InfluxDB Cloud (5 GB / retención de 30 días) cubre unos 5000 puntos con una cadencia de un minuto al día: generoso para uso doméstico.
Webhook / REST genérico
Publicación a cualquier endpoint HTTPS con clave de API: funciona con webhooks de IFTTT, servicios Flask / FastAPI propios o cualquier función en la nube (AWS Lambda / Azure Functions / GCP Cloud Run) expuesta por 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 una tasa baja (≤ una vez por minuto) la sobrecarga es aceptable. A tasas mayores, agrupe los datos en el lado de Python (acumule 10 minutos en un búfer circular y publique un JSON masivo) para no pagar un handshake TLS por cada petición.
Híbrido: almacenamiento local + sincronización con la nube
Para despliegues tolerantes a fallos de conexión: registre localmente una vez por minuto y envíe a la nube una vez por hora. Así se sobrevive a caídas de Wi-Fi o de la nube sin pérdida de datos.
CPython (registro rotativo + sincronización horaria)
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 (añadir al archivo + reintento al conectar)
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
El acumulador dev.energy.wh(0) del paquete sigue contando durante toda la ventana sin conexión: no se pierden datos mientras el host Python siga alimentado.
Presupuesto energético (para despliegues con batería en MicroPython)
Un handshake TLS es una operación costosa: ~3 s + ~30 kB de heap por conexión. Para escenarios de sueño profundo en MicroPython (véase 06 · Ejemplos, Escenario 9):
-
Reutilice la sesión TLS entre despertares mediante reanudación de sesión TLS:
umqtt.simpleadmite una sesión persistente conclean_session=False, y el broker recuerda sus suscripciones. -
Agrupe varias medidas en la memoria flash local y publíquelas como un único POST masivo en cada despertar: el patrón de la sección «Híbrido» de arriba.
-
El keepalive de MQTT no necesita mantenerse fuera del sueño profundo: el dispositivo duerme entre despertares, y el handshake TLS se ejecuta en cada despertar (salvo que se reanude).
Con un intervalo de despertar de 10 minutos en una Li-ion de 2000 mAh, cabe esperar unos 3 meses de autonomía con Wi-Fi + TLS, frente a unos 6 meses con Wi-Fi + MQTT sin cifrar (véase el Escenario 9).
CPython en una Raspberry Pi normalmente funciona 24/7 con fuente de alimentación; el presupuesto energético de TLS no es crítico. Para un despliegue en producción con optimización del consumo de la Pi, véase 10 · Solución de problemas, la sección "El script se cuelga / falla por timeout" (un bucle sensible a señales para systemctl suspend).
Enlaces
-
06 · Ejemplos — los proyectos base sobre los que se construyen las integraciones en la nube (especialmente el Escenario 9 "registrador de sueño profundo" y el Escenario 10 "streaming asíncrono")
-
07 · Integraciones DIY: alternativas autoalojadas
-
10 · Solución de problemas: handshake TLS / presupuesto de memoria / gestión de señales
Fuente y incidencias: rb-amp/rbamp-python · esta página en el repositorio: docs/08_cloud_integrations.md (v1.6.1)