rbAmp
PT
Loja
Docs
Atualizado · Editar no GitHub [Edit on GitHub]

08 · Integrações na cloud

Como enviar leituras rbamp para plataformas cloud — AWS IoT Core, Azure IoT Hub, Google Cloud e pipelines de observabilidade serverless ou geridos. Para cada plataforma há uma configuração Python mais as instruções do lado da cloud.

Plataformas DIY auto-alojadas (Home Assistant, Node-RED, InfluxDB OSS) — ver 07 · Integrações DIY.

Cloud Transporte Autenticação 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 (descontinuado em 2023) MQTT/TLS JWT (migração — ver abaixo) igual
InfluxDB Cloud HTTPS line-protocol Token de API requests urequests
Webhook genérico / REST POST HTTPS Chave de API requests urequests
Segurança

⚠ Custo de TLS no MicroPython. Um handshake TLS precisa de ~30 kB de heap no ESP32. Em alvos pequenos (ESP32-C2) pode dar OOM se tiver Wi-Fi e buffers a correr em paralelo. No CPython é praticamente irrelevante (Pi 3+/4+ têm 1+ GB de RAM).

Para alvos com pouca memória recomendamos uma ponte Mosquitto local num Pi/SBC: o dispositivo MicroPython publica em mqtts://local-broker (com TLS mínimo, ou sem TLS dentro da LAN), e a ponte retransmite para o broker cloud via TLS.

Certificados TLS — duas abordagens

CPython — caminhos do sistema de ficheiros

O CPython vem com o ca-certificates do sistema (Debian/Ubuntu: /etc/ssl/certs/). Para certificados adicionais do dispositivo, coloque os ficheiros junto ao script e passe os caminhos para 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 — embutido em bytes ou sistema de ficheiros

MicroPython não tem armazenamento TLS completo num sistema de ficheiros. Duas opções:

  1. Bytes embutidos — ficheiros de certificado como objetos Python no 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 o sistema de ficheiros flash — coloque os ficheiros de certificado em /lib/certs/ no dispositivo (via mpremote cp) e leia-os através do open() standard:
Python
with open("/lib/certs/ca.pem", "rb") as f:
    ca_bytes = f.read()
ctx.load_verify_locations(cadata=ca_bytes)
Nota

Em algumas portas de MicroPython (sobretudo ESP8266) ssl.SSLContext está ausente — em vez disso usa-se um ussl.wrap_socket(...) simplificado, com validação limitada. Para implementações em produção, escolha um alvo da família ESP32 com uma pilha TLS completa.


AWS IoT Core

O AWS IoT Core usa TLS mútuo com um certificado de dispositivo X.509.

Provisionamento

  1. Consola AWS → IoT Core → Gerir [Manage] → Coisas [Things] → Criar coisas [Create things] → Coisa única [Single thing].
  2. Gere o certificado + as chaves; descarregue device.cert.pem, device.private.key, AmazonRootCA1.pem.

  3. Anexe uma política que conceda iot:Connect, iot:Publish sobre arn:aws:iot:::topic/rbamp/+/state.

  4. Anote o seu endpoint AWS IoT: xxxxxx-ats.iot..amazonaws.com:8883.

Versão 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)

Versão 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

Processamento do lado da cloud

  • Crie uma IoT Rule: SELECT *, topic(2) AS device FROM 'rbamp/+/state' → Kinesis Data Firehose ou Lambda para armazenamento.

  • Para painéis — AWS IoT SiteWise (historiador industrial) ou Timestream (base de dados de séries temporais) → QuickSight.

  • Se o Home Assistant correr num Pi e consumir dados da AWS, configure uma ponte Mosquitto local (mais barata e mais rápida do que HA → AWS diretamente).

Alternativa CPython — boto3 via API REST

Para publicações pouco frequentes (uma vez por hora ou menos), pode dispensar o MQTT e 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))

A autorização é feita pela cadeia standard de credenciais AWS (variáveis de ambiente / ~/.aws/credentials / função IAM). Prática para publicação em lote por cron a partir de um Pi. O MicroPython não tem boto3.

Sobre o custo

Publicar uma vez por minuto por dispositivo, o AWS IoT custa ~525 mil mensagens por ano → ~$2.60/ano/dispositivo tarifa "Connectivity" + "Messaging" (2026, us-east-1). Os custos do Timestream / Lambda são à parte.


Azure IoT Hub

O Azure IoT Hub suporta MQTT 3.1.1 sobre TLS com autenticação por token SAS (mais simples do que X.509 para uso doméstico).

Provisionamento

  1. Portal do Azure → IoT Hub → Devices → New → ID do dispositivo rbamp-main, autenticação = Symmetric key.

  2. Guarde a string de ligação: HostName=foo.azure-devices.net;DeviceId=rbamp-main;SharedAccessKey=….

  3. Gere um token SAS. Em CPython através do SDK azure-iot-device ou um 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. Em MicroPython — ou ucryptolib + um HMAC manual (lento), ou simplesmente fixar um token SAS de 1 ano gerado na máquina de compilação.

Versão 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)

Versão 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)

Validade do token SAS

Os tokens SAS têm uma cláusula expiry — a duração típica vai de 1 hora a 1 ano. Para uma implementação em CPython, use o SDK azure-iot-device; ele roda o token por si. Para MicroPython, gere um token de 1 ano na máquina de compilação e incorpore-o no script; ou implemente a rotação HMAC via ucryptolib.

Processamento do lado da cloud (Azure)

  • Encaminhe as mensagens para o Event Hubs para ingestão de alto débito → Stream Analytics → painéis do Power BI.

  • Uma alternativa mais barata: mensagens → Conta de Armazenamento [Storage Account] (blob) → Synapse Serverless SQL para consultas ad hoc.


Google Cloud IoT (DESCONTINUADO em 2023)

A Google encerrou o Cloud IoT Core em 2023. Caminhos de migração:

  • Um broker MQTT no Compute Engine (instala o seu próprio Mosquitto numa VM) — o mesmo padrão de 07 · Integrações DIY, mas apontando para o IP público da sua VM.

  • HiveMQ Cloud / EMQX Cloud — brokers MQTT geridos, ~10–20 USD/mês nos níveis de hobby.

  • Pub/Sub sobre HTTPS — publique diretamente num tópico Pub/Sub através da API REST. Em CPython é mais fácil com o SDK google-cloud-pubsub + uma chave JSON de conta de serviço:

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 em MicroPython sobre HTTPS — ver a secção "Webhook genérico / REST" abaixo, substituindo pelo endpoint de publicação do Pub/Sub e um token bearer OAuth.


InfluxDB Cloud (TLSv1.3 + line-protocol)

O InfluxDB Cloud (nível Serverless) aceita line-protocol sobre HTTPS — a mesma forma do caminho OSS em 07 · Integrações DIY, mas com cloud2.influxdata.com como host e um token de API para autenticação.

Versão 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))

O requests usa o pacote de CA do sistema — numa instalação padrão de Debian/Ubuntu com CPython isto "simplesmente funciona".

Versão 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

Na maioria das portas de MicroPython o urequests usa um pacote de CA integrado (sem verificação) ou o do sistema. Para validação estrita — use urequests.post(..., verify=True) se a sua porta o suportar; caso contrário, passe por ssl.SSLContext + usocket de baixo nível.

O nível gratuito do InfluxDB Cloud (5 GB / 30 dias de retenção) cobre cerca de 5000 pontos por dia a uma cadência de um minuto — generoso para uso doméstico.


Webhook / REST genérico

Publicar em qualquer endpoint HTTPS com uma chave de API — funciona com webhooks do IFTTT, serviços Flask / FastAPI próprios, ou qualquer função cloud (AWS Lambda / Azure Functions / GCP Cloud Run) exposta como 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 uma taxa baixa (≤ uma vez por minuto) o custo é aceitável. A taxas mais altas, agregue os dados do lado do Python (acumule 10 minutos num buffer circular e publique um único JSON em bloco) para não pagar um handshake TLS por pedido.


Híbrido: armazenamento local + sincronização com a cloud

Para implementações tolerantes a falhas de rede: registe localmente uma vez por minuto e envie para a nuvem uma vez por hora. Isto sobrevive a quedas do Wi-Fi e a falhas da nuvem sem perda de dados.

CPython (ficheiro rotativo + sincronização horária)

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 (acrescentar ao ficheiro + nova tentativa ao ligar)

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

O acumulador dev.energy.wh(0) do pacote continua a contar durante toda a janela offline — nenhum dado se perde enquanto o anfitrião Python estiver alimentado.


Orçamento de energia (para instalações de bateria com MicroPython)

Um handshake TLS é uma operação cara: ~3 s + ~30 kB de heap por ligação. Para cenários de deep-sleep em MicroPython (ver 06 · Exemplos, Cenário 9):

  • Reutilize a sessão TLS entre despertares através de retoma de sessão TLS — umqtt.simple suporta uma sessão persistente com clean_session=False, e o broker lembra-se das suas subscrições.

  • Agregue várias medições no flash local e publique-as como um único POST em bloco por despertar — o padrão da secção "Híbrido" acima.

  • O keepalive MQTT não precisa de ser mantido fora do deep sleep — o dispositivo dorme entre acordares, e o handshake TLS corre em cada acordar (a menos que seja retomado).

Com um intervalo de despertar de 10 minutos numa bateria Li-ion de 2000 mAh, conte com ~3 meses de autonomia em Wi-Fi + TLS, contra ~6 meses em Wi-Fi + MQTT simples (ver Cenário 9).

O CPython num Raspberry Pi corre normalmente 24/7 com alimentação de rede — o orçamento energético do TLS não é crítico. Para uma implementação em produção com otimização de consumo do Pi, ver 10 · Resolução de problemas, secção "O script bloqueia / falha por timeout" (um ciclo sensível a sinais para systemctl suspend).



Fonte e problemas: rb-amp/rbamp-python · esta página no repositório: docs/08_cloud_integrations.md (v1.6.1)