Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

Tutorial: Conexión de un dispositivo a AWS IoT Core mediante el SDK AWS IoT de dispositivo

En este tutorial se muestra cómo conectar un dispositivo para que AWS IoT Core pueda enviar y recibir datos desde y hacia AWS IoT. Después de completar este tutorial, el dispositivo se configurará para conectarse AWS IoT Core y comprenderá cómo se comunican los dispositivos con AWS IoT.

En este tutorial, podrá:

Este tutorial tarda aproximadamente una hora en completarse.

Preparar los dispositivos para AWS IoT

En Cómo empezar con AWS IoT Core los tutoriales, preparó su dispositivo y su cuenta AWS para que pudieran comunicarse. En esta sección se analizan los aspectos de esa preparación aplicables a cualquier dispositivo que se conecte a AWS IoT Core.

Para conectar un dispositivo a AWS IoT Core:

Revise el protocolo MQTT

Antes de hablar de la aplicación de ejemplo, es útil entender el protocolo MQTT. El protocolo MQTT ofrece algunas ventajas sobre otros protocolos de comunicación de red, como HTTP, que lo convierten en una opción popular para los dispositivos IoT. En esta sección se analizan los aspectos clave del MQTT aplicables a este tutorial. Para obtener información sobre la comparación entre MQTT y HTTP, consulte Elegir un protocolo de aplicación para la comunicación de su dispositivo.

MQTT utiliza un modelo de comunicación publicar/suscribir

El protocolo MQTT utiliza un modelo de comunicación de publicación/suscripción con su host. Este modelo difiere del modelo de solicitud/respuesta que utiliza HTTP. Con MQTT, los dispositivos establecen una sesión con el host que se identifica mediante un ID de cliente único. Para enviar datos, los dispositivos publican los mensajes identificados por temas en un agente de mensajes del host. Para recibir mensajes del agente de mensajes, los dispositivos se suscriben a los temas enviando filtros de temas en las solicitudes de suscripción al agente de mensajes.

MQTT admite sesiones persistentes

El agente de mensajes recibe los mensajes de los dispositivos y los publica en los dispositivos que se han suscrito a ellos. Con las sesiones persistentes (sesiones que permanecen activas incluso cuando el dispositivo de inicio está desconectado), los dispositivos pueden recuperar los mensajes que se publicaron mientras estaban desconectados. En cuanto al dispositivo, MQTT admite niveles de calidad de servicio (QoS) que garantizan que el host reciba los mensajes enviados por el dispositivo.

Consulte la aplicación de ejemplo del SDK de dispositivo pubsub.py

En esta sección se revisa la aplicación de ejemplo pubsub.py del SDK de dispositivos AWS IoT v2 para Python utilizada en este tutorial. Aquí veremos cómo se conecta a AWS IoT Core para publicar y suscribirse a los mensajes de MQTT. En la siguiente sección se presentan algunos ejercicios que le ayudarán a explorar cómo se conecta y se comunica un dispositivo con AWS IoT Core.

Protocolos de comunicación

En el ejemplo pubsub.py se muestra una conexión MQTT mediante los protocolos MQTT y MQTT sobre WSS. La biblioteca de tiempo de ejecución común de AWS (AWS-CRT) proporciona el soporte de protocolo de comunicación de bajo nivel y se incluye con el SDK de dispositivos AWS IoT v2 para Python.

MQTT

Las llamadas de ejemplo pubsub.py mtls_from_path (mostradas aquí) en el mqtt_connection_builder para establecer una conexión con AWS IoT Core mediante el protocolo MQTT. mtls_from_path utiliza certificados X.509 y TLS v1.2 para autenticar el dispositivo. La biblioteca CRT AWS gestiona los detalles de nivel inferior de esa conexión.

mqtt_connection = mqtt_connection_builder.mtls_from_path(
    endpoint=args.endpoint,
    cert_filepath=args.cert,
    pri_key_filepath=args.key,
    ca_filepath=args.ca_file,
    client_bootstrap=client_bootstrap,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    client_id=args.client_id,
    clean_session=False,
    keep_alive_secs=6
)

MQTT a través de WSS

La muestra pubsub.py llama a websockets_with_default_aws_signing (se muestra aquí) en el mqtt_connection_builder para establecer una conexión con AWS IoT Core utilizando el protocolo MQTT sobre WSS. websockets_with_default_aws_signing crea una conexión MQTT sobre WSS utilizando Signature V4 para autenticar el dispositivo.

mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
    endpoint=args.endpoint,
    client_bootstrap=client_bootstrap,
    region=args.signing_region,
    credentials_provider=credentials_provider,
    websocket_proxy_options=proxy_options,
    ca_filepath=args.ca_file,
    on_connection_interrupted=on_connection_interrupted,
    on_connection_resumed=on_connection_resumed,
    client_id=args.client_id,
    clean_session=False,
    keep_alive_secs=6
)

HTTPS

¿Qué pasa con HTTPS? AWS IoT Core admite dispositivos que publican solicitudes HTTPS. Desde el punto de vista de la programación, los dispositivos envían solicitudes HTTPS a AWS IoT Core igual que cualquier otra aplicación. Para ver un ejemplo de un programa de Python que envía un mensaje HTTP desde un dispositivo, consulta el ejemplo de código HTTPS con la biblioteca requests de Python. En este ejemplo, se envía un mensaje a AWS IoT Core mediante HTTPS de forma que AWS IoT Core lo interpreta como un mensaje MQTT.

Si bien AWS IoT Core es compatible con las solicitudes HTTPS de los dispositivos, asegúrese de revisar la información sobre Elegir un protocolo de aplicación para la comunicación de su dispositivo para poder tomar una decisión informada sobre qué protocolo utilizar para las comunicaciones de su dispositivo.

Sesiones persistentes

En la aplicación de ejemplo, si se establece el parámetro clean_session en False indica que la conexión debe ser persistente. En la práctica, esto significa que la conexión abierta por esta llamada se vuelve a conectar a una sesión persistente existente, si existe alguna. De lo contrario, crea una nueva sesión persistente y se conecta a ella.

Con una sesión persistente, el agente de mensajes almacena los mensajes que se envían al dispositivo mientras el dispositivo no está conectado. Cuando un dispositivo se vuelve a conectar a una sesión persistente, el agente de mensajes envía al dispositivo todos los mensajes almacenados a los que se haya suscrito.

Sin una sesión persistente, el dispositivo no recibirá los mensajes que se envíen mientras no esté conectado. La opción que utilices dependerá de la aplicación que utilices y de si es necesario comunicar los mensajes que se produzcan mientras el dispositivo no está conectado. Para obtener más información, consulte MQTTsesiones persistentes.

Calidad de servicio

Cuando el dispositivo publica mensajes y se suscribe a ellos, se puede establecer la calidad de servicio (QoS) preferida. AWS IoTadmite los niveles de QoS 0 y 1 para las operaciones de publicación y suscripción. Para obtener más información acerca de los niveles de QoS en AWS IoT, consulte MQTTOpciones de calidad de servicio (QoS).

El tiempo de ejecución CRT de AWS para Python define estas constantes para los niveles de QoS que admite:

En la aplicación de ejemplo, las solicitudes de publicación y suscripción se realizan con un nivel de QoS de 1 (mqtt.QoS.AT_LEAST_ONCE).

Publicación de mensajes

Tras establecer correctamente una conexión con AWS IoT Core, los dispositivos pueden publicar mensajes. La muestra pubsub.py lo hace llamando a la operación publish de la cosa mqtt_connection.

mqtt_connection.publish(
    topic=args.topic,
    payload=message,
    qos=mqtt.QoS.AT_LEAST_ONCE
)

Suscripción a mensajes

Para recibir mensajes de AWS IoT y otros servicios y dispositivos, los dispositivos se suscriben a esos mensajes por el nombre del tema. Los dispositivos pueden suscribirse a mensajes individuales especificando un nombre de tema y a un grupo de mensajes especificando un filtro de tema, que puede incluir caracteres comodín. En el ejemplo pubsub.py, se utiliza el código que se muestra aquí para suscribirse a los mensajes y registrar las funciones de devolución de llamada para procesar el mensaje una vez recibido.

subscribe_future, packet_id = mqtt_connection.subscribe(
    topic=args.topic,
    qos=mqtt.QoS.AT_LEAST_ONCE,
    callback=on_message_received
)
subscribe_result = subscribe_future.result()

La función mqtt_connection.subscribe devuelve un futuro y un ID de paquete. Si la solicitud de suscripción se inició correctamente, el identificador del paquete devuelto es superior a 0. Para asegurarse de que el agente de mensajes recibió y registró la suscripción, debe esperar a que se devuelva el resultado de la operación asíncrona, como se muestra en el ejemplo de código.

Función de devolución de llamada

La devolución de llamada del ejemplo pubsub.py procesa los mensajes suscritos a medida que el dispositivo los recibe.

def on_message_received(topic, payload, **kwargs):
    print("Received message from topic '{}': {}".format(topic, payload))
    global received_count
    received_count += 1
    if received_count == args.count:
        received_all_event.set()

En el ejemplo pubsub.py, on_message_received solo muestra el tema y su carga útil. También cuenta los mensajes recibidos para finalizar el programa una vez alcanzado el límite.

Su aplicación evaluaría el tema y la carga útil para determinar qué acciones debe realizar.

Desconexión y reconexión del dispositivo

El ejemplo pubsub.py incluye funciones de devolución de llamada que se invocan cuando el dispositivo se desconecta y cuando se restablece la conexión. Las acciones que realiza el dispositivo ante estos eventos son específicas de la aplicación.

Cuando un dispositivo se conecta por primera vez, debe suscribirse a los temas para poder recibirlos. Si la sesión de un dispositivo está presente cuando se vuelve a conectar, sus suscripciones se restauran y todos los mensajes almacenados en esas suscripciones se envían al dispositivo una vez que se vuelve a conectar.

Si la sesión de un dispositivo ya no existe cuando se vuelve a conectar, debe volver a suscribirse a sus suscripciones. Las sesiones persistentes tienen una vida útil limitada y pueden caducar si el dispositivo se desconecta durante demasiado tiempo.

Conecte su dispositivo y comuníquese con AWS IoT Core

En esta sección se presentan algunos ejercicios que le ayudarán a explorar diferentes aspectos de la conexión del dispositivo a AWS IoT Core. Para estos ejercicios, utilizará el cliente de pruebas MQTT de la consola de AWS IoT para ver lo que publica el dispositivo y publicar los mensajes en el dispositivo. Estos ejercicios utilizan el ejemplo pubsub.py del SDK AWS IoT de dispositivo v2 para Python y se basan en su experiencia con los tutoriales Cómo empezar con AWS IoT Core los tutoriales.

Para estos ejercicios, empezará con el programa de ejemplo pubsub.py.

Suscríbase a los filtros de temas comodín

En este ejercicio, modificará la línea de comandos utilizada para llamar a pubsub.py para suscribirse a un filtro de temas comodín y procesará los mensajes recibidos en función del tema del mensaje.

Procedimiento del ejercicio

Para este ejercicio, imagine que su dispositivo contiene un control de temperatura y un control de luz. Utiliza estos nombres de temas para identificar los mensajes sobre ellos.

Resultado del ejercicio

Con esto, pubsub.py, se suscribió a los mensajes mediante un filtro de temas comodín, los recibió y los mostró en la ventana del terminal. Observa cómo te has suscrito a un único filtro de temas y que se ha llamado a la función de devolución de llamada para procesar los mensajes que tienen dos temas distintos.

Procesar suscripciones de filtro de temas

Basándose en el ejercicio anterior, modifique la aplicación de ejemplo pubsub.py para evaluar los temas de los mensajes y procesar los mensajes suscritos en función del tema.

Procedimiento del ejercicio

Debería ver algo similar a esto en la ventana de su terminal.

Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!

Resultado del ejercicio

En este ejercicio, ha añadido código para que la aplicación de ejemplo reconozca y procese varios mensajes en la función de devolución de llamada. Con ello, su dispositivo podrá recibir mensajes y actuar en consecuencia.

Otra forma de que el dispositivo reciba y procese varios mensajes consiste en suscribirse a distintos mensajes por separado y asignar cada suscripción a su propia función de devolución de llamada.

Publique mensajes desde su dispositivo

Puede utilizar la aplicación de ejemplo pubsub.py para publicar mensajes desde su dispositivo. Aunque publicará los mensajes tal cual, éstos no podrán leerse como documentos JSON. Este ejercicio modifica la app de ejemplo para poder publicar documentos JSON en la carga útil del mensaje que puedan ser leídos por AWS IoT Core.

Procedimiento del ejercicio

En este ejercicio, se enviará el siguiente mensaje con el tema device/data.

{
    "timestamp": 1601048303,
    "sensorId": 28,
    "sensorData": [
        {
        "sensorName": "Wind speed",
        "sensorValue": 34.2211224
        }
    ]
}

De forma predeterminada, pubsub3.py también se suscribe a los mensajes que envía. Debería ver que recibió los mensajes en la salida de la aplicación. La ventana de la terminal debe tener un aspecto similar al siguiente.

Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!

Resultado del ejercicio

Con esto, su dispositivo puede generar mensajes para enviar a AWS IoT Core para probar la conectividad básica y proporcionar mensajes de dispositivo para AWS IoT Core para procesar. Por ejemplo, puedes usar esta aplicación para enviar datos de prueba desde tu dispositivo para probar las acciones de las reglas AWS IoT.

Revisión de los resultados.

Los ejemplos de este tutorial le proporcionaron una experiencia práctica sobre los conceptos básicos de cómo los dispositivos pueden comunicarse con AWS IoT Core, una parte fundamental de su solución AWS IoT. Cuando sus dispositivos pueden comunicarse con AWS IoT Core, pueden enviar mensajes a los servicios AWS y otros dispositivos desde los que pueden actuar. Del mismo modo, los servicios AWS y otros dispositivos pueden procesar información que resulta en el envío de mensajes a tus dispositivos.

Cuando esté listo para seguir explorando AWS IoT Core, pruebe estos tutoriales: