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 AWS IoT Core mediante el SDK del AWS IoT 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 ellos AWS IoT.
**Topics**
+ [Requisitos previos](#sdk-tutorials-prereq)
+ [Prepara tu dispositivo para AWS IoT](#sdk-tutorials-prepare)
+ [Revise el protocolo MQTT](#sdk-tutorials-mqtt-review)
+ [Consulte la aplicación de ejemplo del SDK de dispositivo pubsub.py](#sdk-tutorials-explore-sample)
+ [Conecta tu dispositivo y comunícate con AWS IoT Core](#sdk-tutorials-experiment)
+ [Revisión de los resultados.](#sdk-tutorials-conclusion)
+ [Tutorial: Uso de la AWS IoT Device SDK para Embedded C](iot-embedded-c-sdk.md)
## Requisitos previos
Antes de empezar este tutorial, asegúrese de que ha:
+
**Finalizado [Cómo empezar con AWS IoT Core los tutoriales](iot-gs.md)**
En la sección de ese tutorial donde debe [Configuración del dispositivo](configure-device.md), seleccione la opción [Conexión de una Raspberry Pi u otro dispositivo](connecting-to-existing-device.md) para su dispositivo y utilice las opciones del lenguaje Python para configurar su dispositivo.
**nota**
Mantenga abierta la ventana de terminal que utilizó en ese tutorial porque también la utilizará en este.
+
**Un dispositivo que puede ejecutar el AWS IoT Device SDK v2 para Python.**
Este tutorial muestra cómo conectar un dispositivo AWS IoT Core mediante ejemplos de código de Python, que requieren un dispositivo relativamente potente. Si trabaja con dispositivos con recursos limitados, es posible que estos ejemplos de código no funcionen en ellos. En dicho caso, es posible que tenga más éxito con el tutorial de [Tutorial: Uso de la AWS IoT Device SDK para Embedded C](iot-embedded-c-sdk.md).
+
**Obtención de la información necesaria para conectarse al dispositivo**
Para conectar el dispositivo AWS IoT, debe tener información sobre el nombre del dispositivo, el nombre del host y el número de puerto.
**nota**
También puede usar la autenticación personalizada para conectar dispositivos a AWS IoT Core. Los datos de conexión que se transfieren a la función de Lambda de su autorizador dependen del protocolo que utilice.
+ **Nombre de la cosa**: el nombre de la AWS IoT cosa a la que quieres conectarte. Debes haberte registrado como dispositivo como una AWS IoT cosa. Para obtener más información, consulte [Administrar dispositivos con AWS IoT](iot-thing-management.md).
+ **Nombre de host:** el nombre de host del punto de conexión de IoT específico de la cuenta.
+ **Número de puerto:** el número de puerto al que desea conectarse.
Puede usar el `configureEndpoint` método del SDK de AWS IoT Python para configurar el nombre de host y el número de puerto.
```
myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883)
```
## Prepara tu dispositivo para AWS IoT
En [Cómo empezar con AWS IoT Core los tutoriales](iot-gs.md), preparó su dispositivo y su cuenta AWS para que pudieran comunicarse. En esta sección se analizan los aspectos de esa preparación que se aplican a cualquier dispositivo que se conecte a AWS IoT Core.
Para conectar un dispositivo a AWS IoT Core:
1. Debe tener una **Cuenta de AWS**.
En el procedimiento [Configurar Cuenta de AWS](setting-up.md) se describe cómo crear una Cuenta de AWS si aún no tiene una.
1. En esa cuenta, debe tener definidos los siguientes **AWS IoT recursos** para el dispositivo de su Cuenta de AWS región.
El procedimiento en [Crea AWS IoT recursos](create-iot-resources.md) se describe en este documento describe cómo crear estos recursos para el dispositivo en su Cuenta de AWS y su región.
+ Un **certificado de dispositivo** registrado con AWS IoT y activado para autenticar el dispositivo.
El certificado suele crearse con un **objeto y adjuntarse a AWS IoT él**. Si bien no se requiere un objeto para conectarse a un dispositivo AWS IoT, este pone a su disposición AWS IoT funciones adicionales.
+ Una **política** adjunta al certificado del dispositivo que lo autoriza a conectarse AWS IoT Core y realizar todas las acciones que desee.
1. Una **conexión a Internet** que pueda acceder a los puntos de conexión del dispositivo Cuenta de AWS.
Los puntos finales del dispositivo se describen en la [página de configuración de la consola [AWS IoT datos del dispositivo y puntos finales de servicio](iot-connect-devices.md#iot-connect-device-endpoints) y se pueden ver en ella](https://console.aws.amazon.com/iot/home#/settings). AWS IoT
1. **Software de comunicación**, como el que SDKs proporciona el AWS IoT dispositivo. En este tutorial se utiliza el [SDK de AWS IoT dispositivo v2 para Python](https://github.com/aws/aws-iot-device-sdk-python-v2#aws-iot-device-sdk-v2-for-python).
## 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 [Elección de un protocolo de aplicación para la comunicación entre dispositivos](protocols.md#protocol-selection).
**MQTT utiliza un modelo de publish/subscribe comunicación**
El protocolo MQTT utiliza un modelo de publish/subscribe comunicación con su anfitrión. Este modelo es diferente del request/response modelo 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](mqtt.md#mqtt-persistent-sessions) (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](mqtt.md#mqtt-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 para publicar y suscribirse AWS IoT Core a los mensajes 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él.
**La aplicación `pubsub.py` de ejemplo muestra estos aspectos de una conexión MQTT con AWS IoT Core:**
+ [Protocolos de comunicación](#sdk-tutorials-explore-protocols)
+ [Sesiones persistentes](#sdk-tutorials-explore-persistent)
+ [Calidad de servicio](#sdk-tutorials-explore-qos)
+ [Publicación de mensajes](#sdk-tutorials-explore-publish)
+ [Suscripción a mensajes](#sdk-tutorials-explore-subscribe)
+ [Desconexión y reconexión del dispositivo](#sdk-tutorials-explore-connect)
### 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 [AWS Common Runtime (AWS CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) proporciona compatibilidad con el protocolo de comunicación de bajo nivel y se incluye en el AWS IoT Device SDK v2 para Python.
#### MQTT
El `pubsub.py` ejemplo de llamadas `mtls_from_path` (que se muestra aquí) es [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)para establecer una conexión AWS IoT Core mediante el protocolo MQTT. `mtls_from_path`utiliza los certificados X.509 y TLS v1.2 para autenticar el dispositivo. La biblioteca AWS CRT 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
)
```
`endpoint`
El punto final Cuenta de AWS de su dispositivo IoT
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`cert_filepath`
La ruta al archivo del certificado del dispositivo
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`pri_key_filepath`
La ruta al archivo de clave privada del dispositivo que se creó con su archivo de certificado
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`ca_filepath`
La ruta al archivo de la CA Raíz. Solo es obligatorio si el servidor MQTT usa un certificado que aún no esté en tu almacén de confianza.
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`client_bootstrap`
El objeto de tiempo de ejecución común que gestiona las actividades de comunicación de los sockets
En la aplicación de ejemplo, se crea una instancia de este objeto antes de la llamada a `mqtt_connection_builder.mtls_from_path`.
`on_connection_interrupted``on_connection_resumed`
y son funciones de devolución de llamada para llamar cuando la conexión del dispositivo se interrumpe y se reanuda.
`client_id`
El identificador que identifica de forma exclusiva a este dispositivo en la Región de AWS
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`clean_session`
Si se debe iniciar una nueva sesión persistente o, si hay una, volver a conectarse a una existente
`keep_alive_secs`
El valor keep alive, en segundos, para enviar la solicitud `CONNECT`. Se enviará automáticamente un ping en este intervalo. Si el servidor no recibe un ping después de 1,5 veces este valor, asume que la conexión se ha perdido.
#### MQTT a través de WSS
Las llamadas de ejemplo `pubsub.py` `websockets_with_default_aws_signing` (mostradas aquí) en el [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) para establecer una conexión con AWS IoT Core mediante el protocolo MQTT sobre WSS. `websockets_with_default_aws_signing` crea una conexión de MQTT sobre WSS mediante [Signature V4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) 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
)
```
`endpoint`
El punto final Cuenta de AWS de su dispositivo IoT
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`client_bootstrap`
El objeto de tiempo de ejecución común que gestiona las actividades de comunicación de los sockets
En la aplicación de ejemplo, se crea una instancia de este objeto antes de la llamada a `mqtt_connection_builder.websockets_with_default_aws_signing`.
`region`
La región de AWS firma utilizada por la autenticación Signature V4. En `pubsub.py`, pasa el parámetro introducido en la línea de comandos.
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`credentials_provider`
Las AWS credenciales proporcionadas para usarlas en la autenticación
En la aplicación de ejemplo, se crea una instancia de este objeto antes de la llamada a `mqtt_connection_builder.websockets_with_default_aws_signing`.
`websocket_proxy_options`
Opciones del proxy HTTP, si utiliza un host proxy
En la aplicación de ejemplo, este valor se inicializa antes de la llamada a `mqtt_connection_builder.websockets_with_default_aws_signing`.
`ca_filepath`
La ruta al archivo de la CA Raíz. Solo es obligatorio si el servidor MQTT usa un certificado que aún no esté en tu almacén de confianza.
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`on_connection_interrupted``on_connection_resumed`
La función de devolución de llamada para llamar cuando la conexión del dispositivo se interrumpe y se reanuda.
`client_id`
El identificador que identifica de forma exclusiva a este dispositivo en la Región de AWS.
En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.
`clean_session`
Si se debe iniciar una nueva sesión persistente o, si hay una, volver a conectarse a una existente
`keep_alive_secs`
El valor keep alive, en segundos, para enviar la solicitud `CONNECT`. Se enviará automáticamente un ping en este intervalo. Si el servidor no recibe un ping después de 1,5 veces este valor, se supone que se ha perdido la conexión.
#### 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](http.md#codeexample) con la biblioteca `requests` de Python. En este ejemplo, se envía un mensaje AWS IoT Core mediante HTTPS de forma que se AWS IoT Core 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 al respecto [Elección de un protocolo de aplicación para la comunicación entre dispositivos](protocols.md#protocol-selection) 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 [Sesiones persistentes de MQTT](mqtt.md#mqtt-persistent-sessions).
### Calidad de servicio
Cuando el dispositivo publica mensajes y se suscribe a ellos, se puede establecer la calidad de servicio (QoS) preferida. AWS IoT admite los niveles de QoS 0 y 1 para las operaciones de publicación y suscripción. Para obtener más información sobre los niveles de QoS en AWS IoT, consulte. [Opciones de calidad de servicio (QoS) de MQTT](mqtt.md#mqtt-qos)
El tiempo de ejecución AWS CRT para Python define estas constantes para los niveles de QoS que admite:
**Niveles de calidad de servicio de Python**
| Nivel de QoS de MQTT | Valor simbólico de Python utilizado por el SDK | Description (Descripción) |
| --- | --- | --- |
| QoS nivel 0 | mqtt.QoS.AT\$1MOST\$1ONCE | Solo se intentará enviar el mensaje una vez, tanto si se recibe como si no. Es posible que el mensaje no se envíe en absoluto, por ejemplo, si el dispositivo no está conectado o si hay un error de red. |
| QoS nivel 1 | mqtt.QoS.AT\$1LEAST\$1ONCE | El mensaje se envía repetidamente hasta que se recibe un acuse de recibo PUBACK. |
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`).
+
**QoS al publicar**
Cuando un dispositivo publica un mensaje con el nivel 1 de QoS, envía el mensaje repetidamente hasta que recibe una respuesta `PUBACK` del agente de mensajes. Si el dispositivo no está conectado, el mensaje queda en cola para enviarse una vez que se vuelva a conectar.
+
**QoS al suscribirse**
Cuando un dispositivo se suscribe a un mensaje con QoS de nivel 1, el agente de mensajes guarda los mensajes a los que está suscrito el dispositivo hasta que se puedan enviar al dispositivo. El agente de mensajes vuelve a enviar los mensajes hasta que recibe una respuesta `PUBACK` del dispositivo.
### Publicación de mensajes
Tras establecer correctamente una conexión 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
)
```
`topic`
El nombre del tema del mensaje que lo identifica
En la aplicación de ejemplo, este se transfiere desde la línea de comandos.
`payload`
La carga útil del mensaje está formateada como una cadena (por ejemplo, un documento JSON)
En la aplicación de ejemplo, este se transfiere desde la línea de comandos.
Un documento JSON es un formato de carga útil común y otros AWS IoT servicios lo reconocen; sin embargo, el formato de datos de la carga útil del mensaje puede ser cualquier formato que acuerden los editores y los suscriptores. Sin embargo, otros servicios AWS IoT solo reconocen JSON y, en algunos casos, CBOR para la mayoría de las operaciones.
`qos`
El nivel de QoS de este mensaje
### Suscripción a mensajes
Para recibir mensajes de otros servicios AWS IoT 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](topics.md#topicnames) y a un grupo de mensajes especificando un [filtro de tema](topics.md#topicfilters), 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()
```
`topic`
El tema al que suscribirse. Puede ser el nombre de un tema o un filtro de tema.
En la aplicación de ejemplo, este se transfiere desde la línea de comandos.
`qos`
Si el agente de mensajes debe almacenar estos mensajes mientras el dispositivo está desconectado.
Un valor de `mqtt.QoS.AT_LEAST_ONCE` (nivel de QoS 1) requiere que se especifique una sesión persistente (`clean_session=False`) al crear la conexión.
`callback`
La función a la que se debe llamar para procesar el mensaje suscrito.
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()
```
`topic`
El tema del mensaje
Es el nombre del tema específico del mensaje recibido, incluso si te has suscrito a un filtro de temas.
`payload`
La carga útil del mensaje
El formato es específico de la aplicación.
`kwargs`
Posibles argumentos adicionales, tal como se describe en [https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe](https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe).
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.
## Conecta tu dispositivo y comunícate 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](https://console.aws.amazon.com/iot/home#/test) 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 [https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py) del [SDK para dispositivos con AWS IoT v2 para Python](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/master/samples#sample-apps-for-the-aws-iot-device-sdk-v2-for-python) y se basan en su experiencia con los tutoriales de [Cómo empezar con AWS IoT Core los tutoriales](iot-gs.md).
**Topics**
+ [Suscríbase a los filtros de temas comodín](#sdk-tutorials-experiment-wild)
+ [Procesar suscripciones de filtro de temas](#sdk-tutorials-experiment-process)
+ [Publique mensajes desde su dispositivo](#sdk-tutorials-experiment-publish)
Para estos ejercicios, empezará con el programa de ejemplo `pubsub.py`.
**nota**
En estos ejercicios se presupone que ha completado los tutoriales [Cómo empezar con AWS IoT Core los tutoriales](iot-gs.md) y ha utilizado la ventana de terminal del dispositivo que aparece en ese tutorial.
### 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.
1. Antes de empezar el ejercicio, intente ejecutar este comando de los tutoriales [Cómo empezar con AWS IoT Core los tutoriales](iot-gs.md) del dispositivo para asegurarse de que todo está listo para el ejercicio.
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Debería ver el mismo resultado que en el [tutorial de introducción](connecting-to-existing-device.md#gs-device-node-app-run).
1. Para este ejercicio, cambie estos parámetros de la línea de comandos.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/sdk-tutorials.html)
Al realizar estos cambios en la línea de comandos inicial, se obtiene esta línea de comandos. Introduzca este comando en la ventana del terminal de su dispositivo.
```
python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
El programa debe mostrar algo similar al siguiente:
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
```
Si ve algo como esto en su terminal, su dispositivo está listo y a la escucha de mensajes cuyos nombres de tema empiecen por `device` y terminen por `/detail`. Así que, vamos a probarlo.
1. Aquí hay un par de mensajes que su dispositivo podría recibir.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/sdk-tutorials.html)
1. Con el cliente de prueba MQTT de la AWS IoT consola, envíe los mensajes descritos en el paso anterior a su dispositivo.
1. Abra el [cliente de prueba MQTT](https://console.aws.amazon.com/iot/home#/test) en la AWS IoT consola.
1. En **Suscribirse a un tema**, en el campo **Tema de suscripción** escriba **device/\$1/details** y, a continuación, elija **Suscribirse al tema**.
1. En la columna **Suscripciones** del cliente de prueba de MQTT, elija **device/\$1/details**.
1. Para cada uno de los temas de la tabla anterior, haga lo siguiente en el cliente de prueba de MQTT:
1. En **Publicar**, introduzca el valor de la columna **Nombre del tema** de la tabla.
1. En el campo de carga útil del mensaje situado debajo del nombre del tema, introduzca el valor de la columna de **carga útil del mensaje** de la tabla.
1. Observe la ventana del terminal en la que `pubsub.py` se está ejecutando y, en el cliente de prueba de MQTT, elija **Publicar en un tema**.
Debería ver que el mensaje ha sido recibido por `pubsub.py` en la ventana del terminal.
#### 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
**Para evaluar el tema del mensaje**
1. Copie `pubsub.py` en `pubsub2.py`.
1. Abra `pubsub2.py` en el editor de texto o IDE.
1. En `pubsub2.py`, busque la función `on_message_received`.
1. En `on_message_received`, inserte el siguiente código después de la línea que empieza por `print("Received message` y antes de la línea que empieza por `global received_count`.
```
topic_parsed = False
if "/" in topic:
parsed_topic = topic.split("/")
if len(parsed_topic) == 3:
# this topic has the correct format
if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
# this is a topic we care about, so check the 2nd element
if (parsed_topic[1] == 'temp'):
print("Received temperature request: {}".format(payload))
topic_parsed = True
if (parsed_topic[1] == 'light'):
print("Received light request: {}".format(payload))
topic_parsed = True
if not topic_parsed:
print("Unrecognized message topic.")
```
1. Guarde los cambios y ejecute el programa modificado mediante esta línea de comandos.
```
python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
1. En la AWS IoT consola, abra el cliente de [pruebas MQTT](https://console.aws.amazon.com/iot/home#/test).
1. En **Suscribirse a un tema**, en el campo **Tema de suscripción** escriba **device/\$1/details** y, a continuación, elija **Suscribirse al tema**.
1. En la columna **Suscripciones** del cliente de prueba de MQTT, elija **device/\$1/details**.
1. Para cada uno de los temas de la tabla, haga lo siguiente en el cliente de prueba de MQTT:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/sdk-tutorials.html)
1. En **Publicar**, introduzca el valor de la columna **Nombre del tema** de la tabla.
1. En el campo de carga útil del mensaje situado debajo del nombre del tema, introduzca el valor de la columna de **carga útil del mensaje** de la tabla.
1. Observe la ventana del terminal en la que `pubsub.py` se está ejecutando y, en el cliente de prueba de MQTT, elija **Publicar en un tema**.
Debería ver que el mensaje ha sido recibido por `pubsub.py` en la ventana del terminal.
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. En este ejercicio se modifica la aplicación de ejemplo para poder publicar documentos JSON en la carga útil del mensaje que puedan leerse. 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
}
]
}
```
**Para preparar su cliente de pruebas de MQTT para supervisar los mensajes de este ejercicio**
1. En **Suscribirse a un tema**, en el campo **Tema de suscripción** escriba **device/data** y, a continuación, elija **Suscribirse al tema**.
1. En la columna **Suscripciones** del cliente de prueba MQTT, elija **device/data**.
1. Mantenga abierta la ventana del cliente de prueba de MQTT para esperar a que lleguen los mensajes de su dispositivo.
**Para enviar documentos JSON con la aplicación de ejemplo pubsub.py**
1. En su dispositivo, copie `pubsub.py` en`pubsub3.py`.
1. Edite `pubsub3.py` para cambiar el formato de los mensajes que publica.
1. Abra `pubsub3.py` en un editor de texto.
1. Localice esta línea de código:
`message = "{} [{}]".format(message_string, publish_count)`
1. Cambie a:
`message = "{}".format(message_string)`
1. Localice esta línea de código:
`message_json = json.dumps(message)`
1. Cambie a:
`message = "{}".json.dumps(json.loads(message))`
1. Guarde los cambios.
1. En su dispositivo, ejecute este comando para enviar el mensaje dos veces.
```
python3 pubsub3.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --topic device/data --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}' --endpoint your-iot-endpoint
```
1. En el cliente de prueba de MQTT, compruebe que ha interpretado y formateado el documento JSON de la carga útil del mensaje, de la siguiente manera:
![\[Imagen que muestra cómo se muestra la carga útil de un mensaje JSON en el cliente MQTT de la consola. AWS IoT\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/images/mqtt-test-client-output.png)
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
De este modo, el dispositivo puede generar mensajes para enviarlos a fin de probar AWS IoT Core la conectividad básica y proporcionar mensajes del dispositivo AWS IoT Core para su procesamiento. Por ejemplo, puedes usar esta aplicación para enviar datos de prueba desde tu dispositivo para probar las acciones de las AWS IoT reglas.
## 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 ellos AWS IoT Core, una parte fundamental de su AWS IoT solución. Cuando sus dispositivos pueden comunicarse AWS IoT Core, pueden enviar mensajes a los AWS servicios y otros dispositivos desde los que pueden actuar. Del mismo modo, AWS los servicios y otros dispositivos pueden procesar información que hace que los mensajes se envíen a tus dispositivos.
Cuando esté listo para AWS IoT Core seguir explorando, pruebe estos tutoriales:
+ [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md)
+ [Tutorial: Almacenamiento de datos de dispositivos en una tabla de DynamoDB](iot-ddb-rule.md)
+ [Tutorial: Formatear una notificación mediante una AWS Lambda función](iot-lambda-rule.md)
# Tutorial: Uso de la AWS IoT Device SDK para Embedded C
En esta sección, se explica cómo se ejecuta el AWS IoT Device SDK para Embedded C.
**Topics**
+ [Paso 1: Instalar la AWS IoT Device SDK para Embedded C](#install-embedded-c-sdk)
+ [Paso 2: Configurar la aplicación de ejemplo](#iot-c-sdk-app-config)
+ [Paso 3: Compilar y ejecutar la aplicación de ejemplo](#iot-c-sdk-app-run)
## Paso 1: Instalar la AWS IoT Device SDK para Embedded C
AWS IoT Device SDK para Embedded C generalmente se dirige a dispositivos con limitaciones de recursos que requieren un tiempo de ejecución optimizado del lenguaje C. Puede usar el SDK en cualquier sistema operativo y alojarlo en cualquier tipo de procesador (por ejemplo, MCU y MPU). Si dispone de más memoria y recursos de procesamiento, le recomendamos que utilice uno de los SDK de AWS IoT para dispositivos y móviles superiores (por ejemplo, C\$1\$1, Java, JavaScript y Python).
En general, AWS IoT Device SDK para Embedded C está dirigido a sistemas que utilizan MCU o MPU de bajo rendimiento que ejecutan sistemas operativos integrados. Para el ejemplo de programación de esta sección, asumimos que su dispositivo utiliza Linux.
**Example**
1. Descarga el AWS IoT Device SDK para Embedded C en tu dispositivo desde [GitHub](https://github.com/aws/aws-iot-device-sdk-embedded-C).
```
git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules
```
Esto crea un directorio denominado `aws-iot-device-sdk-embedded-c` en el directorio actual.
1. Vaya hasta ese directorio y consulte la última versión. Observe [github.com/aws/aws-iot-device-sdk-embedded-C/tags](https://github.com/aws/aws-iot-device-sdk-embedded-C/tags) para ver la etiqueta de la última versión.
```
cd aws-iot-device-sdk-embedded-c
git checkout latest-release-tag
```
1. Instale OpenSSL 1.1.0 o una versión posterior. Las bibliotecas de desarrollo de OpenSSL suelen denominarse «libssl-dev» u «openssl-devel» cuando se instalan mediante un administrador de paquetes.
```
sudo apt-get install libssl-dev
```
## Paso 2: Configurar la aplicación de ejemplo
El AWS IoT Device SDK para Embedded C contiene aplicaciones de ejemplo que puede probar. Para simplificar, este tutorial utiliza la aplicación `mqtt_demo_mutual_auth`, que ilustra cómo puede conectarse al agente de mensajes de AWS IoT Core, así como suscribirse a temas de MQTT y publicar en ellos.
1. Copie el certificado y la clave privada que ha creado en [Cómo empezar con AWS IoT Core los tutoriales](iot-gs.md) en el directorio `build/bin/certificates`.
**nota**
Los certificados de dispositivo y de entidad de certificación raíz están sujetos a vencimiento o revocación. Si estos certificados caducan o se revocan, debe copiar un nuevo certificado de entidad de certificación o un certificado de clave privada y dispositivo en el dispositivo.
1. Debe configurar el ejemplo con su punto de conexión de AWS IoT Core, su clave privada, su certificado y su certificado de la entidad de certificación raíz personales. Vaya al directorio `aws-iot-device-sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth`.
Si tiene instalada la AWS CLI, puede utilizar este comando para buscar la URL del punto de conexión de su cuenta.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Si no tiene instalada la AWS CLI, abra la [consola de AWS IoT](https://console.aws.amazon.com/iot/home). Desde el panel de navegación, elija **Manage (Administrar)** y, a continuación, **Things (Objetos)**. Elija el objeto IoT para su Raspberry Pi y, a continuación, elija **Interactuar**. Su punto de conexión se muestra en la sección ** HTTPS** de la página de detalles del objeto.
1. Abra el archivo `demo_config.h` y actualice los valores de los elementos siguientes:
AWS\$1IOT\$1ENDPOINT
Su punto de conexión personal.
CLIENT\$1CERT\$1PATH
La ruta del archivo de su certificado, por ejemplo, `certificates/device.pem.crt"`.
CLIENT\$1PRIVATE\$1KEY\$1PATH
El nombre de su archivo de clave privada, por ejemplo `certificates/private.pem.key`.
Por ejemplo:
```
// Get from demo_config.h
// =================================================
#define AWS_IOT_ENDPOINT "my-endpoint-ats.iot.us-east-1.amazonaws.com"
#define AWS_MQTT_PORT 8883
#define CLIENT_IDENTIFIER "testclient"
#define ROOT_CA_CERT_PATH "certificates/AmazonRootCA1.crt"
#define CLIENT_CERT_PATH "certificates/my-device-cert.pem.crt"
#define CLIENT_PRIVATE_KEY_PATH "certificates/my-device-private-key.pem.key"
// =================================================
```
1. Compruebe si tiene CMake instalado en su dispositivo mediante este comando.
```
cmake --version
```
Si ve la información de la versión del compilador, puede continuar con la siguiente sección.
Si aparece un error o no ve ninguna información, deberá instalar el paquete cmake con este comando.
```
sudo apt-get install cmake
```
Vuelva a ejecutar el comando **cmake --version** y confirme que CMake se ha instalado y que está listo para continuar.
1. Compruebe si tiene las herramientas de desarrollo instaladas en su dispositivo mediante este comando.
```
gcc --version
```
Si ve la información de la versión del compilador, puede continuar con la siguiente sección.
Si aparece un error o no ve la información del compilador, deberá instalar el paquete `build-essential` con este comando.
```
sudo apt-get install build-essential
```
Vuelva a ejecutar el comando **gcc --version** y confirme que las herramientas de compilación se han instalado y que está listo para continuar.
## Paso 3: Compilar y ejecutar la aplicación de ejemplo
Este procedimiento explica cómo generar la aplicación `mqtt_demo_mutual_auth` en el dispositivo y conectarla a la [consola de AWS IoT](https://console.aws.amazon.com/iot/home) con el AWS IoT Device SDK para Embedded C.
**Para ejecutar las aplicaciones de ejemplo de AWS IoT Device SDK para Embedded C**
1. Vaya a `aws-iot-device-sdk-embedded-c` y cree un directorio de compilación.
```
mkdir build && cd build
```
1. Introduzca el siguiente comando CMake para generar los Makefiles necesarios para la compilación.
```
cmake ..
```
1. Escriba el siguiente comando para crear el archivo ejecutable de la aplicación.
```
make
```
1. Ejecute la aplicación `mqtt_demo_mutual_auth` con este comando.
```
cd bin
./mqtt_demo_mutual_auth
```
Debería ver una salida similar a esta:
![\[Salida de la línea de comandos para ejecutar la aplicación AWS IoT Device SDK para Embedded C de ejemplo.\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/images/successful-run2.png)
El dispositivo está conectado a AWS IoT mediante la AWS IoT Device SDK para Embedded C.
También puede utilizar la consola de AWS IoT para ver los mensajes de MQTT que está publicando la aplicación de ejemplo. Para obtener información sobre cómo utilizar el cliente MQTT en la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), consulte [Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md).