rbAmp
ES
Tienda
Docs
Actualizado · Editar en GitHub [Edit on GitHub]

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
Seguridad

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

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 — integrado en bytes o en sistema de archivos

MicroPython no dispone de almacenamiento TLS completo en un sistema de archivos. Dos opciones:

  1. Bytes embebidos — archivos de certificado como objetos Python en el 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. Mediante el sistema de archivos de la flash: coloque los archivos de certificado en /lib/certs/ en el dispositivo (con mpremote cp) y léalos con el open() estándar:
Python
with open("/lib/certs/ca.pem", "rb") as f:
    ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
Nota

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

  1. AWS Console → IoT Core → Manage → Things → Create things → Single thing.
  2. Genere el certificado y las claves; descargue device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Asocie una política que conceda iot:Connect e iot:Publish sobre arn:aws:iot:::topic/rbamp/+/state.

  4. Anote su endpoint de AWS IoT: xxxxxx-ats.iot..amazonaws.com:8883.

Versión de 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)

Versión de 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

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

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

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

  1. Azure Portal → IoT Hub → Devices → New → ID de dispositivo rbamp-main, autenticación = Symmetric key.

  2. Guarde la cadena de conexión: HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Genere un token SAS. En CPython, mediante el SDK azure-iot-device o un HMAC manual:

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

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)

Versión de 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)

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-pubsub y una clave JSON de cuenta de servicio:

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

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)

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

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

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

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

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 (añadir al archivo + reintento al conectar)

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

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.simple admite una sesión persistente con clean_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).


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