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.
# Creación de soluciones con el AWS IoT dispositivo SDKs
Los tutoriales de esta sección lo guían a través de los pasos para desarrollar una solución de IoT que se pueda implementar en un entorno de producción mediante AWS IoT.
Estos tutoriales pueden tardar más tiempo en completarse que los de la sección correspondiente, [Creación de demostraciones con el cliente de AWS IoT dispositivos](iot-tutorials-dc-intro.md) ya que utilizan el AWS IoT dispositivo SDKs y explican los conceptos que se están aplicando con más detalle para ayudarle a crear soluciones seguras y fiables.
## Comience a crear soluciones con el AWS IoT dispositivo SDKs
Estos tutoriales lo guían a través de diferentes AWS IoT escenarios. Cuando proceda, los tutoriales utilizan el AWS IoT dispositivo SDKs.
**Topics**
+ [Comience a crear soluciones con el AWS IoT dispositivo SDKs](#iot-sdk-tutorial-overview)
+ [Tutorial: Conexión de un dispositivo AWS IoT Core mediante el SDK del AWS IoT dispositivo](sdk-tutorials.md)
+ [Crear AWS IoT reglas para enrutar los datos del dispositivo a otros servicios](iot-rules-tutorial.md)
+ [Retener el estado del dispositivo mientras el dispositivo está fuera de línea con Device Shadows](iot-shadows-tutorial.md)
+ [Tutorial: Crear un autorizador personalizado para AWS IoT Core](custom-auth-tutorial.md)
+ [Tutorial: Monitorización de la humedad del suelo con una AWS IoT Raspberry Pi](iot-moisture-tutorial.md)
# 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).
# Crear AWS IoT reglas para enrutar los datos del dispositivo a otros servicios
Estos tutoriales te muestran cómo crear y probar AWS IoT reglas utilizando algunas de las acciones de reglas más comunes.
AWS IoT las reglas envían datos desde tus dispositivos a otros AWS servicios. Escuchan mensajes MQTT específicos, formatean los datos de las cargas útiles de los mensajes y envían el resultado a otros servicios AWS .
Le recomendamos que las pruebe en el orden en que se muestran aquí, incluso si su objetivo es crear una regla que utilice una función de Lambda o algo más complejo. Los tutoriales se presentan en orden de básico a complejo. Presentan nuevos conceptos de forma gradual para ayudarlo a aprender los conceptos que puede usar para crear las acciones de reglas que no tienen un tutorial específico.
**nota**
AWS IoT las reglas le ayudan a enviar los datos de sus dispositivos de IoT a otros AWS servicios. Sin embargo, para hacerlo correctamente, necesita un conocimiento práctico de los demás servicios a los que desea enviar datos. Si bien estos tutoriales proporcionan la información necesaria para completar las tareas, puede resultarle útil obtener más información sobre los servicios a los que desea enviar datos antes de utilizarlos en su solución. Una explicación detallada de los demás AWS servicios queda fuera del ámbito de estos tutoriales.
**Información general del escenario del tutorial**
El escenario de estos tutoriales es el de un dispositivo sensor meteorológico que publica sus datos periódicamente. Hay muchos dispositivos sensores de este tipo en este sistema imaginario. Los tutoriales de esta sección, sin embargo, se centran en un único dispositivo mientras muestran cómo se pueden acomodar múltiples sensores.
Los tutoriales de esta sección le muestran cómo usar AWS IoT las reglas para realizar las siguientes tareas con este sistema imaginario de dispositivos de sensores meteorológicos.
+
**[Tutorial: Volver a publicar un mensaje MQTT](iot-repub-rule.md)**
En este tutorial se muestra cómo volver a publicar un mensaje MQTT recibido de los sensores meteorológicos como un mensaje que contiene únicamente el identificador del sensor y el valor de temperatura. Utiliza solo servicios AWS IoT Core y muestra una consulta SQL sencilla y cómo utilizar el cliente MQTT para probar la regla.
+
**[Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md)**
Este tutorial muestra cómo enviar un mensaje SNS cuando un valor de un dispositivo sensor meteorológico supera un valor específico. Se basa en los conceptos presentados en el tutorial anterior y añade cómo trabajar con otro AWS servicio, el [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html) (Amazon SNS).
Si es la primera vez que usa Amazon SNS, consulte sus ejercicios de [introducción](https://docs.aws.amazon.com//sns/latest/dg/sns-getting-started.html) antes de comenzar este tutorial.
+
**[Tutorial: Almacenamiento de datos de dispositivos en una tabla de DynamoDB](iot-ddb-rule.md)**
En este tutorial se muestra cómo almacenar los datos de los dispositivos de sensores meteorológicos en una tabla de base de datos. Utiliza la declaración de consulta de reglas y las plantillas de sustitución para dar formato a los datos del mensaje para el servicio de destino, [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html).
Si es la primera vez que usa DynamoDB, consulte sus ejercicios de [introducción](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) antes de comenzar este tutorial.
+
**[Tutorial: Formatear una notificación mediante una AWS Lambda función](iot-lambda-rule.md)**
En este tutorial se muestra cómo llamar a una función de Lambda para volver a formatear los datos del dispositivo y, a continuación, enviarlos como mensaje de texto. Añade un script de Python y funciones de AWS SDK en una [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)función para formatear con el mensaje los datos de carga útil de los dispositivos con sensores meteorológicos y enviar un mensaje de texto.
Si es la primera vez que usa Lambda, consulte sus ejercicios de [introducción](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) antes de comenzar este tutorial.
**AWS IoT descripción general de las reglas**
Todos estos tutoriales crean AWS IoT reglas.
Para que una AWS IoT regla envíe los datos de un dispositivo a otro AWS servicio, utiliza:
+ Una declaración de consulta de reglas que consta de:
+ Una cláusula SELECT de SQL que selecciona y formatea los datos de la carga del mensaje
+ Un filtro de tema (el objeto FROM de la instrucción de consulta de la regla) que identifica los mensajes que se van a utilizar
+ Una sentencia condicional opcional (una cláusula SQL WHERE) que especifica condiciones concretas sobre las que actuar
+ Al menos una acción de regla
Los dispositivos publican mensajes en temas MQTT. El filtro de temas de la instrucción SQL SELECT identifica los temas de MQTT a los que se va a aplicar la regla. Los campos especificados en la sentencia SQL SELECT dan formato a los datos de la carga útil del mensaje MQTT entrante para que los utilicen las acciones de la regla. Para obtener una lista completa de las acciones de las reglas, consulte [Acciones de las reglas de AWS IoT](iot-rule-actions.md).
**Topics**
+ [Tutorial: Volver a publicar un mensaje MQTT](iot-repub-rule.md)
+ [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: Volver a publicar un mensaje MQTT
En este tutorial se muestra cómo crear una AWS IoT regla que publique un mensaje MQTT cuando se reciba un mensaje MQTT específico. La regla puede modificar la carga útil de los mensajes entrantes antes de que se publique. Esto permite crear mensajes que se adapten a aplicaciones específicas sin necesidad de modificar el dispositivo o su firmware. También puede utilizar el aspecto de filtrado de una regla para publicar mensajes sólo cuando se cumpla una condición específica.
Los mensajes que se vuelven a publicar mediante una regla actúan como los mensajes enviados por cualquier otro AWS IoT dispositivo o cliente. Los dispositivos pueden suscribirse a los mensajes republicados del mismo modo que pueden suscribirse a cualquier otro tema de mensajes de MQTT.
**Lo que aprenderá en este tutorial:**
+ Cómo utilizar consultas y funciones SQL sencillas en una declaración de consulta de reglas
+ Cómo usar el cliente MQTT para probar una regla AWS IoT
Para completar este tutorial se necesitan aproximadamente 30 minutos.
**Topics**
+ [Revise los temas y AWS IoT reglas de MQTT](#iot-repub-rule-mqtt)
+ [Paso 1: Cree una AWS IoT regla para volver a publicar un mensaje MQTT](#iot-repub-rule-define)
+ [Paso 2: Probar su nueva regla](#iot-repub-rule-test)
+ [Paso 3: Revisar los resultados y los siguientes pasos](#iot-repub-rule-review)
**Antes de empezar este tutorial, asegúrese de que tiene:**
+
**[Configurar Cuenta de AWS](setting-up.md)**
Necesitará su AWS IoT consola Cuenta de AWS y su consola para completar este tutorial.
+
**[Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md) revisado**
Asegúrese de poder utilizar el cliente MQTT para suscribirse a un tema y publicar en él. En este procedimiento, utilizará el cliente MQTT para probar la nueva regla.
## Revise los temas y AWS IoT reglas de MQTT
Antes de hablar de AWS IoT las reglas, es útil entender el protocolo MQTT. En las soluciones de IoT, el protocolo MQTT ofrece algunas ventajas sobre otros protocolos de comunicación de red, como HTTP, lo que lo convierte en una opción popular para su uso en dispositivos de 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).
**Protocolo MQTT**
El protocolo MQTT utiliza un modelo de publish/subscribe comunicación con su anfitrión. Para enviar datos, los dispositivos publican los mensajes que se identifican por temas en el intermediario de AWS IoT mensajes. Para recibir mensajes del agente de mensajes, los dispositivos se suscriben a los temas que van a recibir enviando filtros de temas en las solicitudes de suscripción al agente de mensajes. El motor de reglas AWS IoT recibe los mensajes MQTT del agente de mensajes.
**AWS IoT reglas**
AWS IoT las reglas constan de una declaración de consulta de reglas y una o más acciones de regla. Cuando el motor de reglas AWS IoT recibe un mensaje MQTT, estos elementos actúan sobre el mensaje de la siguiente manera.
+
**Declaración de consulta de reglas**
La sentencia de consulta de la regla describe los temas de MQTT que se van a utilizar, interpreta los datos de la carga útil del mensaje y les da el formato que describe una sentencia SQL similar a las instrucciones utilizadas en las bases de datos SQL más conocidas. El resultado de la sentencia de consulta son los datos que se envían a las acciones de la regla.
+
**Acción de regla**
Cada acción de una regla actúa sobre los datos que resultan de la declaración de consulta de la regla. AWS IoT admite [muchas acciones de regla](iot-rule-actions.md). Sin embargo, en este tutorial se concentrará en la acción de la regla [Volver a publicar](republish-rule-action.md), que publica el resultado de la declaración de consulta como un mensaje MQTT con un tema específico.
## Paso 1: Cree una AWS IoT regla para volver a publicar un mensaje MQTT
La AWS IoT regla que crearás en este tutorial se basa en los temas de `device/device_id/data` MQTT, donde *device\$1id* está el ID del dispositivo que envió el mensaje. Estos temas se describen mediante un [filtro de temas](topics.md#topicfilters) como `device/+/data`: donde `+` es un carácter comodín que coincide con cualquier cadena entre los dos caracteres de barra diagonal.
Cuando la regla recibe un mensaje de un tema coincidente, vuelve a publicar los valores `device_id` y `temperature` como un nuevo mensaje MQTT con el tema `device/data/temp`.
Por ejemplo, la carga útil de un mensaje MQTT con el tema `device/22/data` tiene el siguiente aspecto:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
La regla toma el valor `temperature` de la carga útil del mensaje, y el `device_id` del tema, y los vuelve a publicar como un mensaje MQTT con el tema `device/data/temp` y una carga útil del mensaje que se parece a esto:
```
{
"device_id": "22",
"temperature": 28
}
```
Con esta regla, los dispositivos que solo necesitan el identificador del dispositivo y los datos de temperatura se suscriben al tema `device/data/temp` para recibir únicamente esa información.
**Para crear una regla que vuelva a publicar un mensaje MQTT**
1. Abre [el centro de **reglas** de la AWS IoT consola](https://console.aws.amazon.com//iot/home#/rulehub).
1. En **Reglas**, elija **Crear** y comience a crear su nueva regla.
1. En la parte superior de **Crear una regla**:
1. En **Nombre**, introduzca el nombre de la regla. Para este tutorial, llámela **republish\$1temp**.
Recuerde que el nombre de una regla debe ser único en su cuenta y región, y no puede tener espacios. Hemos utilizado un carácter de subrayado en este nombre para separar las dos palabras del nombre de la regla.
1. En **Descripción**, describa la regla.
Una descripción significativa le ayuda a recordar lo que hace esta regla y por qué la creó. La descripción puede ser tan larga como sea necesario, por lo que debe ser lo más detallada posible.
1. En **Declaración de consulta de la regla** de **Crear una regla**:
1. En la **versión Uso de SQL**, seleccione **2016-03-23**.
1. En el cuadro de edición de la **declaración de consulta de reglas**, introduzca la siguiente declaración:
```
SELECT topic(2) as device_id, temperature FROM 'device/+/data'
```
Esta declaración:
+ Escucha los mensajes de MQTT con un tema que coincida con el filtro de temas `device/+/data`.
+ Selecciona el segundo elemento de la cadena de temas y lo asigna al campo `device_id`.
+ Selecciona el campo `temperature` de valor de la carga útil del mensaje y lo asigna al campo `temperature`.
1. En **Establecer una o más acciones**:
1. Para abrir la lista de acciones de regla para esta regla, seleccione **Añadir acción**.
1. En **Selecciona una acción**, selecciona **Volver a publicar un mensaje en un AWS IoT tema**.
1. En la parte inferior de la lista de acciones, seleccione **Configurar acción** para abrir la página de configuración de la acción seleccionada.
1. En **Acciones de configuración**:
1. En **Tema**, escriba **device/data/temp**. Este es el tema MQTT del mensaje que publicará esta regla.
1. En **Calidad de servicio**, elija **0: el mensaje se entrega cero o más veces.**
1. En **Elegir o crear un rol para conceder AWS IoT acceso para realizar esta acción**:
1. Seleccione **Crear rol**. Se abre el cuadro de diálogo **Crear un rol de IAM**.
1. Especifique un nombre que describa el recurso. Para este tutorial, use **republish\$1role**.
Al crear un rol nuevo, se crean las políticas correctas para realizar la acción de la regla y se asocian al nuevo rol. Si cambia el tema de esta acción de regla o utiliza este rol en otra acción de regla, debe actualizar la política de ese rol para autorizar el nuevo tema o acción. Para actualizar un rol existente, seleccione **Actualizar rol** en esta sección.
1. Seleccione **Crear rol** para crear el rol y cerrar el cuadro de diálogo.
1. Seleccione **Añadir acción** para añadir la acción a la regla y volver a la página **Crear una regla**.
1. La acción **Volver a publicar un mensaje en un AWS IoT tema** ahora aparece en **Establecer una o más acciones**.
En el icono de la nueva acción, debajo de **Volver a publicar un mensaje en un tema AWS IoT **, puede ver el tema en el que se publicará la acción de volver a publicar.
Esta es la única acción de regla que añadirá a esta regla.
1. En **Crear una regla**, desplácese hasta la parte inferior y seleccione **Crear regla** para crear la regla y completar este paso.
## Paso 2: Probar su nueva regla
Para probar la nueva regla, utilizará el cliente MQTT para publicar y suscribirse a los mensajes MQTT utilizados por esta regla.
Abra el [cliente MQTT de la consola AWS IoT](https://console.aws.amazon.com//iot/home#/test) en una ventana nueva. Esto le permitirá editar la regla sin perder la configuración de su cliente MQTT. El cliente MQTT no conserva las suscripciones ni los registros de mensajes si lo abandona para ir a otra página de la consola.
**Para utilizar el cliente MQTT para probar su regla**
1. En el [cliente MQTT de la consola de AWS IoT](https://console.aws.amazon.com//iot/home#/test), suscríbase a los temas de entrada, en este caso, `device/+/data`.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Suscribirse a un tema**.
1. En el **tema de suscripción**, introduzca el tema del filtro de temas de entrada, **device/\$1/data**.
1. No cambie el resto de los valores predeterminados de los demás ajustes.
1. Elija **Suscribirse al tema**.
En la columna **Suscripciones**, aparece **device/\$1/data** en **Publicar en un tema**.
1. Suscríbase al tema que publicará su regla: `device/data/temp`.
1. En **Suscripciones**, elija **Suscribirse nuevamente a un tema**, y en **Tema de suscripción**, ingrese el tema del mensaje republicado, **device/data/temp**.
1. No cambie el resto de los valores predeterminados de los demás ajustes.
1. Elija **Suscribirse al tema**.
En la columna **Suscripciones**, aparece **device/data/temp** en **device/\$1/data**.
1. Publique un mensaje en el tema de entrada con un identificador de dispositivo específico, **device/22/data** No puede publicar en MQTT temas que contengan caracteres comodín.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Publicar en tema**.
1. En el campo **Publicar**, introduzca el nombre del tema de entrada,. **device/22/data**
1. Copie los datos de ejemplo que se muestran aquí y, en el cuadro de edición situado debajo del nombre del tema, péguelos.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Para enviar su mensaje MQTT, seleccione **Publicar en tema**.
1. Revise los mensajes que se enviaron.
1. En el cliente de MQTT, en **Suscripciones**, hay un punto verde junto a los dos temas a los que se ha suscrito anteriormente.
Los puntos verdes indican que se han recibido uno o más mensajes nuevos desde la última vez que los consultó.
1. En **Suscripciones**, seleccione **device/\$1/data** para comprobar que la carga útil de los mensajes coincide con la que acaba de publicar y tiene este aspecto:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. En **Suscripciones**, selecciona **device/data/temp**comprobar que la carga útil de los mensajes republicados tenga el siguiente aspecto:
```
{
"device_id": "22",
"temperature": 28
}
```
Observe que el valor `device_id` es una cadena entre comillas y el valor `temperature` es numérico. Esto se debe a que la función [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) extrajo la cadena del nombre del tema del mensaje de entrada, mientras que el valor `temperature` utiliza el valor numérico de la carga útil del mensaje de entrada.
Si desea convertir el valor `device_id` en un valor numérico, sustituya `topic(2)` en la declaración de consulta de reglas por:
```
cast(topic(2) AS DECIMAL)
```
Tenga en cuenta que convertir el valor `topic(2)` en un valor numérico solo funcionará si esa parte del tema contiene solo caracteres numéricos.
1. Si ves que se publicó el mensaje correcto en el **device/data/temp**tema, significa que la regla ha funcionado. Vea qué más puede aprender sobre la acción Regla de republicación en la siguiente sección.
Si no ves que se ha publicado el mensaje correcto en el **dispositivo/\$1/data** o en los **device/data/temp**temas, consulta las sugerencias de solución de problemas.
### Solución de problemas con la regla de volver a publicar mensajes
He aquí algunas cosas que debe comprobar en caso de que no esté viendo los resultados que espera.
+
**¿Tiene un mensaje de error**
Si apareció un error al publicar el mensaje de entrada, corrija primero ese error. Los siguientes pasos pueden ayudarle a corregir ese error.
+
**No ve el mensaje de entrada en el cliente MQTT**
Cada vez que publique su mensaje de entrada en el tema `device/22/data`, dicho mensaje debería aparecer en el cliente MQTT si se ha suscrito al filtro de temas `device/+/data` tal y como se describe en el procedimiento.
**Cosas que debe comprobar**
+
**Compruebe el filtro de temas al que se ha suscrito**
Si se ha suscrito al tema del mensaje de entrada como se describe en el procedimiento, debería ver una copia del mensaje de entrada cada vez que lo publique.
Si no ve el mensaje, compruebe el nombre del tema al que se suscribió y compárelo con el tema en el que lo publicó. Los nombres de los temas distinguen entre mayúsculas y minúsculas y el tema al que te suscribiste debe ser idéntico al tema en el que publicaste la carga útil del mensaje.
+
**Compruebe la función de publicación de mensajes**
En el cliente MQTT, en **Suscripciones**, elija **device/\$1/data**, marque el tema del mensaje de publicación y, a continuación, elija **Publicar en tema**. Debería ver la carga útil del mensaje en el cuadro de edición situado debajo del tema en la lista de mensajes.
+
**No ve su mensaje republicado en el cliente MQTT**
Para que su regla funcione, debe tener la política correcta que la autorice a recibir y volver a publicar un mensaje, y debe recibir el mensaje.
**Cosas que debe comprobar**
+
**Comprueba el Región de AWS de tu cliente MQTT y la regla que has creado**
La consola en la que ejecuta el cliente MQTT debe estar en la misma región AWS que la regla que creó.
+
**Compruebe el tema del mensaje de entrada en la declaración de consulta de la regla**
Para que la regla funcione, debe recibir un mensaje con el nombre del tema que coincida con el filtro de tema de la cláusula FROM de la declaración de consulta de la regla.
Compruebe la ortografía del filtro de temas de la declaración de consulta de reglas con la del tema en el cliente MQTT. Los nombres de los temas distinguen mayúsculas de minúsculas y el tema del mensaje debe coincidir con el filtro de tema de la declaración de consulta de reglas.
+
**Compruebe el contenido de la carga útil del mensaje de entrada**
Para que la regla funcione, debe encontrar el campo de datos en la carga útil del mensaje que se declara en la sentencia SELECT.
Compruebe la ortografía del campo `temperature` en la declaración de consulta de la regla con la de la carga útil del mensaje en el cliente MQTT. Los nombres de los campos distinguen mayúsculas de minúsculas y el campo `temperature` de la declaración de consulta de la regla debe ser idéntico al campo `temperature` de la carga útil del mensaje.
Asegúrese de que el documento JSON de la carga útil del mensaje tenga el formato correcto. Si el JSON contiene algún error, como la falta de una coma, la regla no podrá leerlo.
+
**Compruebe el tema del mensaje que se ha vuelto a publicar en la acción de la regla**
El tema en el que la acción de volver a publicar la regla publica el nuevo mensaje debe coincidir con el tema al que se suscribió en el cliente MQTT.
Abra la regla que creó en la consola y seleccione el tema en el que la acción de la regla volverá a publicar el mensaje.
+
**Compruebe el rol que utiliza la regla**
La acción de la regla debe tener permiso para recibir el tema original y publicar el tema nuevo.
Las políticas que autorizan a la regla a recibir datos de los mensajes y volver a publicarlos son específicas de los temas utilizados. Si cambia el tema utilizado para volver a publicar los datos del mensaje, debe actualizar la función de la acción de regla para actualizar su política y que coincida con el tema actual.
Si sospecha que este es el problema, edite la acción Volver a publicar la regla y cree un nuevo rol. Los nuevos roles creados por la acción de regla reciben las autorizaciones necesarias para realizar estas acciones.
## Paso 3: Revisar los resultados y los siguientes pasos
**En este tutorial:**
+ Ha utilizado una consulta SQL sencilla y un par de funciones en una sentencia de consulta de reglas para generar un nuevo mensaje MQTT.
+ Creó una regla que volvió a publicar ese nuevo mensaje.
+ Utilizó el cliente MQTT para probar la regla. AWS IoT
**Siguientes pasos**
Después de volver a publicar algunos mensajes con esta regla, intente experimentar con ella para ver cómo los cambios en algunos aspectos del tutorial afectan al mensaje que se ha vuelto a publicar. He aquí algunos ejemplos para empezar.
+ Cambie *device\$1id* el tema del mensaje de entrada y observe el efecto en la carga útil del mensaje republicado.
+ Cambie los campos seleccionados en la declaración de consulta de la regla y observe el efecto en la carga útil del mensaje republicado.
+ Pruebe el siguiente tutorial de esta serie y aprenda cómo [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md).
La acción Volver a publicar la regla utilizada en este tutorial también puede ayudarle a depurar las sentencias de consulta de reglas. Por ejemplo, puede añadir esta acción a una regla para ver cómo su sentencia de consulta de regla formatea los datos utilizados por sus acciones de regla.
# Tutorial: Envío de una notificación de Amazon SNS
En este tutorial se muestra cómo crear una AWS IoT regla que envíe datos de mensajes MQTT a un tema de Amazon SNS para que puedan enviarse como un mensaje de texto SMS.
En este tutorial, creará una regla que envíe datos de mensajes de un sensor meteorológico a todos los suscriptores de un tema SNS de Amazon, siempre que la temperatura supere el valor establecido en la regla. La regla detecta si la temperatura notificada supera el valor establecido por la regla y, a continuación, crea una nueva carga de mensajes que incluye únicamente el identificador del dispositivo, la temperatura notificada y el límite de temperatura que se ha superado. La regla envía la carga útil del mensaje nuevo como un documento JSON a un tema de SNS, que notifica a todos los suscriptores del tema de SNS.
**Lo que aprenderá en este tutorial:**
+ Cómo crear y probar una notificación de Amazon SNS
+ Cómo llamar a una notificación de Amazon SNS desde una regla AWS IoT
+ Cómo utilizar consultas y funciones SQL sencillas en una declaración de consulta de reglas
+ ¿Cómo usar el cliente MQTT para probar una regla AWS IoT
Para completar este tutorial se necesitan aproximadamente 30 minutos.
**Topics**
+ [Paso 1: crear un tema de Amazon SNS que envía un mensaje de texto SMS](#iot-sns-rule-create-sns-topic)
+ [Paso 2: Crea una AWS IoT regla para enviar el mensaje de texto](#iot-sns-rule-create-rule)
+ [Paso 3: Probar la AWS IoT regla y la notificación de Amazon SNS](#iot-sns-rule-test-rule)
+ [Paso 4: Revisar los resultados y los siguientes pasos](#iot-sns-rule-review-results)
**Antes de empezar este tutorial, asegúrese de que tiene:**
+
**[Configurar Cuenta de AWS](setting-up.md)**
Necesitará su AWS IoT consola Cuenta de AWS y su consola para completar este tutorial.
+
**[Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md) revisado**
Asegúrese de poder utilizar el cliente MQTT para suscribirse a un tema y publicar en él. En este procedimiento, utilizará el cliente MQTT para probar la nueva regla.
+
**Revisado el [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html)**
Si no ha utilizado Amazon SNS anteriormente, consulte [Configuración del acceso a Amazon SNS](https://docs.aws.amazon.com//sns/latest/dg/sns-setting-up.html). Si ya has completado otros AWS IoT tutoriales, ya Cuenta de AWS deberías estar configurado correctamente.
## Paso 1: crear un tema de Amazon SNS que envía un mensaje de texto SMS
Este procedimiento explica cómo crear el tema de Amazon SNS al que su sensor meteorológico puede enviar datos de mensajes. A continuación, el tema de Amazon SNS notificará a todos sus suscriptores mediante un mensaje de texto SMS el límite de temperatura que se ha superado.
**Paso 1: Crear un tema de Amazon SNS que envía un mensaje de texto SMS**
1. **Cree un tema de Amazon SNS**.
1. Inicie sesión en la [consola de Amazon SNS](https://console.aws.amazon.com//sns/home).
1. En el panel de navegación izquierdo, elija **Topics (Temas)**.
1. En la página **Temas**, elija **Crear tema**.
1. En **Detalles**, elija el tipo **Estándar**. De forma predeterminada, la consola crea un tema FIFO.
1. En **Nombre**, introduzca el nombre del tema de SNS. En este tutorial, escriba **high\$1temp\$1notice**.
1. Desplácese hasta el final de la página y elija **Crear tema**.
En la consola se abre la página **Details (Detalles)** del nuevo tema.
1. **Crear un una suscripción de Amazon SNS.**
**nota**
Es posible que el número de teléfono que utilice en esta suscripción conlleve cargos por mensajería de texto debido a los mensajes que envíe en este tutorial.
1. En la página de detalles del tema **high\$1temp\$1notice**, seleccione **Crear suscripción**.
1. En **Crear suscripción**, en la sección **Detalles**, en la lista de **protocolos**, selecciona **SMS**.
1. En **punto de conexión**, introduzca el número de teléfono que puede recibir mensajes de texto. Asegúrese de escribirlo de forma que comience con `+`, incluya el código de país y área y no incluya ningún otro carácter de puntuación.
1. Seleccione **Crear subscripción**.
1. **Pruebe la notificación de Amazon SNS.**
1. En la [consola de Amazon SNS](https://console.aws.amazon.com//sns/home), en el panel de navegación izquierdo, seleccione **Temas**.
1. Para abrir la página de detalles del tema, en **Temas**, en la lista de temas, elija **high\$1temp\$1notice**.
1. Para abrir la página **Publicar mensaje en un tema**, en la página de detalles de **high\$1temp\$1notice**, seleccione **Publicar mensaje.**
1. En **Publicar mensaje en un tema**, en la sección **Cuerpo del mensaje**, en **Cuerpo del mensaje para enviar al punto de conexión**, introduzca un mensaje corto.
1. Desplácese a la parte inferior de la página y seleccione **Publicar mensaje**.
1. En el teléfono con el número que utilizó anteriormente al crear la suscripción, confirme que ha recibido el mensaje.
Si no ha recibido el mensaje de prueba, vuelva a comprobar el número de teléfono y la configuración de su teléfono.
Asegúrese de poder publicar los mensajes de prueba desde la [consola de Amazon SNS](https://console.aws.amazon.com//sns/home) antes de continuar con el tutorial.
## Paso 2: Crea una AWS IoT regla para enviar el mensaje de texto
La AWS IoT regla que crearás en este tutorial se basa en los temas de `device/device_id/data` MQTT, donde `device_id` está el ID del dispositivo que envió el mensaje. Estos temas se describen mediante un filtro de temas como `device/+/data`, donde `+` es un carácter comodín que coincide con cualquier cadena entre los dos caracteres de barra diagonal. Esta regla también comprueba el valor del campo `temperature` en la carga útil del mensaje.
Cuando la regla recibe un mensaje de un tema coincidente, toma el `device_id` del nombre del tema, el valor `temperature` de la carga útil del mensaje y añade un valor constante para el límite que está probando, y envía estos valores como un documento JSON a un tema de notificación de Amazon SNS.
Por ejemplo, un mensaje MQTT del dispositivo sensor meteorológico número 32 utiliza el tema `device/32/data` y tiene una carga útil de mensajes similar a la siguiente:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
La declaración de consulta de reglas de la regla toma el valor `temperature` de la carga útil del mensaje, el `device_id` del nombre del tema, y añade el valor `max_temperature` constante para enviar una carga útil de mensajes similar a la siguiente al tema de Amazon SNS:
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30
}
```
**Para crear una AWS IoT regla que detecte un valor de temperatura superior al límite y crear los datos para enviarlos al tema Amazon SNS**
1. Abra [el centro de **reglas** de la AWS IoT consola](https://console.aws.amazon.com//iot/home#/rulehub).
1. Si esta es su primera regla, elija **Crear** o **Crear una** regla.
1. En **Crear una regla**:
1. En **Name (Nombre)**, escriba **temp\$1limit\$1notify**.
Recuerda que el nombre de una regla debe ser único en tu región Cuenta de AWS y no puede tener espacios. Hemos utilizado un carácter de subrayado en este nombre para separar las dos palabras del nombre de la regla.
1. En **Descripción**, describa la regla.
Una descripción significativa hace que sea más fácil recordar lo que hace esta regla y por qué la creó. La descripción puede ser tan larga como sea necesario, por lo que debe ser lo más detallada posible.
1. En **Declaración de consulta de la regla** de **Crear una regla**:
1. En la **versión Uso de SQL**, seleccione **2016-03-23**.
1. En el cuadro de edición de la **declaración de consulta de reglas**, introduzca la siguiente declaración:
```
SELECT topic(2) as device_id,
temperature as reported_temperature,
30 as max_temperature
FROM 'device/+/data'
WHERE temperature > 30
```
Esta declaración:
+ Escucha los mensajes MQTT con un tema que coincida con el filtro de temas `device/+/data` y que tengan un valor `temperature` superior a 30.
+ Selecciona el segundo elemento de la cadena de temas y lo asigna al campo `device_id`.
+ Selecciona el campo `temperature` de valor de la carga útil del mensaje y lo asigna al campo `reported_temperature`.
+ Crea un valor constante `30` para representar el valor límite y lo asigna al campo `max_temperature`.
1. Para abrir la lista de acciones de la regla para esta regla, en **Establecer una o más acciones**, seleccione **Añadir acción**.
1. En **Seleccionar una acción**, elija **Enviar un mensaje como una notificación push SNS**.
1. Para abrir la página de configuración de la acción seleccionada, en la parte inferior de la lista de acciones, seleccione **Configurar acción**.
1. En **Acciones de configuración**:
1. En el **objetivo SNS**, elija **Seleccionar**, busque su tema SNS llamado **high\$1temp\$1notice** y elija **Seleccionar**.
1. En **Formato del mensaje**, elija **RAW**.
1. En **Elegir o crear un rol para conceder AWS IoT acceso para realizar esta acción**, selecciona **Crear rol**.
1. En **Crear un nuevo rol**, en **Nombre**, escriba un nombre único para el nuevo rol. Para este tutorial, escriba **sns\$1rule\$1role**.
1. Elija **Crear rol**.
Si va a repetir este tutorial o a reutilizar un rol existente, elija **Actualizar rol** antes de continuar. Esto actualiza el documento de política del rol para que funcione con el objetivo de SNS.
1. Seleccione **Añadir acción** y vuelva a la página **Crear una regla**.
En el icono de la nueva acción, debajo de **Enviar un mensaje como notificación push de SNS**, puede ver el tema de SNS al que se referirá su regla.
Esta es la única acción de regla que añadirá a esta regla.
1. Para crear la regla y completar este paso, en **Crear una regla**, desplácese hasta la parte inferior y seleccione **Crear regla**.
## Paso 3: Probar la AWS IoT regla y la notificación de Amazon SNS
Para probar la nueva regla, utilizará el cliente MQTT para publicar y suscribirse a los mensajes MQTT utilizados por esta regla.
Abra el [cliente MQTT de la consola AWS IoT](https://console.aws.amazon.com//iot/home#/test) en una ventana nueva. Esto le permitirá editar la regla sin perder la configuración de su cliente MQTT. Si abandona el cliente MQTT para ir a otra página de la consola, no conservará ningún registro de suscripciones o mensajes.
**Para utilizar el cliente MQTT para probar su regla**
1. En el [cliente MQTT de la consola de AWS IoT](https://console.aws.amazon.com//iot/home#/test), suscríbase a los temas de entrada, en este caso, `device/+/data`.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Suscribirse a un tema**.
1. En el **tema de suscripción**, introduzca el tema del filtro de temas de entrada, **device/\$1/data**.
1. No cambie el resto de los valores predeterminados de los demás ajustes.
1. Elija **Suscribirse al tema**.
En la columna **Suscripciones**, aparece **device/\$1/data** en **Publicar en un tema**.
1. Publique un mensaje en el tema de entrada con un identificador de dispositivo específico, **device/32/data** No puede publicar en MQTT temas que contengan caracteres comodín.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Publicar en tema**.
1. En el campo **Publicar**, introduzca el nombre del tema de entrada,. **device/32/data**
1. Copie los datos de ejemplo que se muestran aquí y, en el cuadro de edición situado debajo del nombre del tema, péguelos.
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Elija **Publicar en tema** para publicar su mensaje MQTT.
1. Confirme que se envió el mensaje de texto.
1. En el cliente de MQTT, en **Suscripciones**, hay un punto verde junto al tema al que se ha suscrito anteriormente.
El punto verdes indica que se han recibido uno o más mensajes nuevos desde la última vez que los consultó.
1. En **Suscripciones**, seleccione **device/\$1/data** para comprobar que la carga útil de los mensajes coincide con la que acaba de publicar y tiene este aspecto:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Compruebe el teléfono que utilizó para suscribirse al tema SNS y confirme que el contenido de la carga útil del mensaje tiene este aspecto:
```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```
Observe que el valor `device_id` es una cadena entre comillas y el valor `temperature` es numérico. Esto se debe a que la función [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) extrajo la cadena del nombre del tema del mensaje de entrada, mientras que el valor `temperature` utiliza el valor numérico de la carga útil del mensaje de entrada.
Si desea convertir el valor `device_id` en un valor numérico, sustituya `topic(2)` en la declaración de consulta de reglas por:
```
cast(topic(2) AS DECIMAL)
```
Tenga en cuenta que la conversión del valor `topic(2)` a un valor numérico `DECIMAL` solo funcionará si esa parte del tema sólo contiene caracteres numéricos.
1. Intente enviar un mensaje MQTT en el que la temperatura no supere el límite.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Publicar en tema**.
1. En el campo **Publicar**, introduzca el nombre del tema de entrada,. **device/33/data**
1. Copie los datos de ejemplo que se muestran aquí y, en el cuadro de edición situado debajo del nombre del tema, péguelos.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Para enviar su mensaje MQTT, seleccione **Publicar en tema**.
Debería ver el mensaje que envió en la suscripción **device/\$1/data**. Sin embargo, como el valor de la temperatura está por debajo de la temperatura máxima en la sentencia de consulta de la regla, no debería recibir un mensaje de texto.
Si no observa el comportamiento correcto, consulte los consejos para la solución de problemas.
### Solución de problemas con la regla de volver a publicar mensajes
He aquí algunas cosas que debe comprobar, en caso de que no esté viendo los resultados que espera.
+
**¿Tiene un mensaje de error**
Si apareció un error al publicar el mensaje de entrada, corrija primero ese error. Los siguientes pasos pueden ayudarle a corregir ese error.
+
**No ve el mensaje de entrada en el cliente MQTT**
Cada vez que publique su mensaje de entrada en el tema `device/22/data`, dicho mensaje debería aparecer en el cliente MQTT si se ha suscrito al filtro de temas `device/+/data` tal y como se describe en el procedimiento.
**Cosas que debe comprobar**
+
**Compruebe el filtro de temas al que se ha suscrito**
Si se ha suscrito al tema del mensaje de entrada como se describe en el procedimiento, debería ver una copia del mensaje de entrada cada vez que lo publique.
Si no ve el mensaje, compruebe el nombre del tema al que se suscribió y compárelo con el tema en el que lo publicó. Los nombres de los temas distinguen entre mayúsculas y minúsculas y el tema al que te suscribiste debe ser idéntico al tema en el que publicaste la carga útil del mensaje.
+
**Compruebe la función de publicación de mensajes**
En el cliente MQTT, en **Suscripciones**, elija **device/\$1/data**, marque el tema del mensaje de publicación y, a continuación, elija **Publicar en tema**. Debería ver la carga útil del mensaje en el cuadro de edición situado debajo del tema en la lista de mensajes.
+
**Si no recibe el mensaje SMS:**
Para que su regla funcione, debe tener la política correcta que la autorice a recibir un mensaje y enviar una notificación SNS, y debe recibir el mensaje.
**Cosas que debe comprobar**
+
**Compruebe el Región de AWS de su cliente MQTT y la regla que creó**
La consola en la que ejecuta el cliente MQTT debe estar en la misma región AWS que la regla que creó.
+
**Compruebe que el valor de temperatura de la carga útil del mensaje supera el umbral de prueba**
Si el valor de temperatura es inferior o igual a 30, tal como se define en la sentencia de consulta de la regla, la regla no realizará ninguna de sus acciones.
+
**Compruebe el tema del mensaje de entrada en la declaración de consulta de la regla**
Para que la regla funcione, debe recibir un mensaje con el nombre del tema que coincida con el filtro de tema de la cláusula FROM de la declaración de consulta de la regla.
Compruebe la ortografía del filtro de temas de la declaración de consulta de reglas con la del tema en el cliente MQTT. Los nombres de los temas distinguen mayúsculas de minúsculas y el tema del mensaje debe coincidir con el filtro de tema de la declaración de consulta de reglas.
+
**Compruebe el contenido de la carga útil del mensaje de entrada**
Para que la regla funcione, debe encontrar el campo de datos en la carga útil del mensaje que se declara en la sentencia SELECT.
Compruebe la ortografía del campo `temperature` en la declaración de consulta de la regla con la de la carga útil del mensaje en el cliente MQTT. Los nombres de los campos distinguen mayúsculas de minúsculas y el campo `temperature` de la declaración de consulta de la regla debe ser idéntico al campo `temperature` de la carga útil del mensaje.
Asegúrese de que el documento JSON de la carga útil del mensaje tenga el formato correcto. Si el JSON contiene algún error, como la falta de una coma, la regla no podrá leerlo.
+
**Compruebe el tema del mensaje que se ha vuelto a publicar en la acción de la regla**
El tema en el que la acción de volver a publicar la regla publica el nuevo mensaje debe coincidir con el tema al que se suscribió en el cliente MQTT.
Abra la regla que creó en la consola y seleccione el tema en el que la acción de la regla volverá a publicar el mensaje.
+
**Compruebe el rol que utiliza la regla**
La acción de la regla debe tener permiso para recibir el tema original y publicar el tema nuevo.
Las políticas que autorizan a la regla a recibir datos de los mensajes y volver a publicarlos son específicas de los temas utilizados. Si cambia el tema utilizado para volver a publicar los datos del mensaje, debe actualizar la función de la acción de regla para actualizar su política y que coincida con el tema actual.
Si sospecha que este es el problema, edite la acción Volver a publicar la regla y cree un nuevo rol. Los nuevos roles creados por la acción de regla reciben las autorizaciones necesarias para realizar estas acciones.
## Paso 4: Revisar los resultados y los siguientes pasos
**En este tutorial:**
+ Creó y probó una suscripción y un tema de notificación de Amazon SNS.
+ Utilizó una consulta SQL sencilla y funciones en una declaración de consulta de reglas para crear un mensaje nuevo para su notificación.
+ Creaste una AWS IoT regla para enviar una notificación de Amazon SNS que utilizaba tu carga de mensajes personalizada.
+ Utilizó el cliente MQTT para probar la regla. AWS IoT
**Siguientes pasos**
Después de enviar unos cuantos mensajes de texto con esta regla, pruebe a experimentar con ella para ver cómo el cambio de algunos aspectos del tutorial afecta al mensaje y al momento en que se envía. He aquí algunos ejemplos para empezar.
+ Cambie *device\$1id* el tema del mensaje de entrada y observe el efecto en el contenido del mensaje de texto.
+ Cambie los campos seleccionados en la sentencia de consulta de la regla y observe el efecto en el contenido del mensaje de texto.
+ Cambie la prueba en la declaración de consulta de reglas para probar una temperatura mínima en lugar de una temperatura máxima. ¡Recuerde cambiar el nombre de `max_temperature`\$1
+ Añada una acción de regla de republicación para enviar un mensaje MQTT cuando se envíe una notificación SNS.
+ Pruebe el siguiente tutorial de esta serie y aprenda cómo [Tutorial: Almacenamiento de datos de dispositivos en una tabla de DynamoDB](iot-ddb-rule.md).
# Tutorial: Almacenamiento de datos de dispositivos en una tabla de DynamoDB
En este tutorial se muestra cómo crear una AWS IoT regla que envíe datos de mensajes a una tabla de DynamoDB.
En este tutorial, va a crear una regla que envía datos de mensajes desde un dispositivo de sensor meteorológico imaginario a una tabla de DynamoDB. La regla formatea los datos de muchos sensores meteorológicos de forma que se puedan añadir a una sola tabla de base de datos.
**Lo que aprenderá en este tutorial:**
+ Cómo crear una tabla de DynamoDB
+ Cómo enviar datos de mensajes a una tabla de DynamoDB desde una regla AWS IoT
+ ¿Cómo utilizar las plantillas de sustitución en una regla AWS IoT
+ Cómo utilizar consultas y funciones SQL sencillas en una declaración de consulta de reglas
+ ¿Cómo usar el cliente MQTT para probar una regla AWS IoT
Para completar este tutorial se necesitan aproximadamente 30 minutos.
**Topics**
+ [Paso 1: Crear la tabla DynamoDB para este tutorial](#iot-ddb-rule-ddb-table)
+ [Paso 2: Crear una AWS IoT regla para enviar datos a la tabla de DynamoDB](#iot-ddb-rule-topic-rule)
+ [Paso 3: Probar la AWS IoT regla y la tabla de DynamoDB](#iot-ddb-rule-test)
+ [Paso 4: Revisar los resultados y los siguientes pasos](#iot-ddb-rule-review)
**Antes de empezar este tutorial, asegúrese de que tiene:**
+
**[Configurar Cuenta de AWS](setting-up.md)**
Necesitará su AWS IoT consola Cuenta de AWS y su consola para completar este tutorial.
+
**[Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md) revisado**
Asegúrese de poder utilizar el cliente MQTT para suscribirse a un tema y publicar en él. En este procedimiento, utilizará el cliente MQTT para probar la nueva regla.
+
**Revisó la descripción [general de Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html)**
Si no ha utilizado DynamoDB anteriormente, [consulte Introducción a DynamoDB para familiarizarse con los conceptos básicos](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) y las operaciones de DynamoDB.
## Paso 1: Crear la tabla DynamoDB para este tutorial
En este tutorial, creará una tabla de DynamoDB con estos atributos para registrar los datos de los dispositivos sensores meteorológicos imaginarios:
+ `sample_time` es una clave principal y describe el momento en que se grabó la muestra.
+ `device_id` es una clave de clasificación y describe el dispositivo que proporcionó la muestra
+ `device_data` son los datos recibidos del dispositivo y formateados según la declaración de consulta de la regla
**Para crear la tabla DynamoDB para este tutorial**
1. Abra la [consola DynamoDB](https://console.aws.amazon.com//dynamodb/home) y elija **Crear tabla**.
1. En **Crear tabla**:
1. En **Nombre de tabla**, introduzca el nombre de la tabla: **wx\$1data**.
1. En **la clave de partición**, introduzca **sample\$1time** y, en la lista de opciones situada junto al campo, elija **Number**.
1. En **la clave de clasificación**, introduzca **device\$1id** y, en la lista de opciones situada junto al campo, elija **Number**.
1. En la parte inferior de la página, elija **Crear**.
Definirá `device_data` más adelante, cuando configure la acción de la regla de DynamoDB.
## Paso 2: Crear una AWS IoT regla para enviar datos a la tabla de DynamoDB
En este paso, utilizará la sentencia de consulta de reglas para formatear los datos de los dispositivos sensores meteorológicos imaginarios y escribirlos en la tabla de la base de datos.
Un ejemplo de carga útil de un mensaje recibido desde un dispositivo sensor meteorológico tiene el siguiente aspecto:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Para la entrada de la base de datos, utilizará la sentencia de consulta de reglas para aplanar la estructura de la carga útil del mensaje de forma similar a la siguiente:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind_velocity": 22,
"wind_bearing": 255
}
```
En esta regla, también utilizarás un par de [Plantillas de sustitución](iot-substitution-templates.md). Las plantillas de sustitución son expresiones que permiten insertar valores dinámicos a partir de funciones y datos de mensajes.
**Para crear la AWS IoT regla para enviar datos a la tabla de DynamoDB**
1. Abra [el centro de reglas de la consola de AWS IoT](https://console.aws.amazon.com//iot/home#/rulehub). O bien, puede abrir la AWS IoT página de inicio dentro de la Consola de administración de AWS y navegar hasta Enrutamiento de **mensajes** > Reglas.
1. Para empezar a crear su nueva regla en **Reglas**, seleccione **Crear regla**.
1. En **Propiedades de la regla**:
1. En **Nombre de la regla**, escriba **wx\$1data\$1ddb**.
Recuerda que el nombre de una regla debe ser único en tu región Cuenta de AWS y no puede tener espacios. Hemos utilizado un carácter de subrayado en este nombre para separar las dos palabras del nombre de la regla.
1. En **Descripción de la regla**, describa la regla.
Una descripción significativa hace que sea más fácil recordar lo que hace esta regla y por qué la creó. La descripción puede ser tan larga como sea necesario, por lo que debe ser lo más detallada posible.
1. Elija **Siguiente** para continuar.
1. En **declaración SQL**:
1. En la **versión de SQL**, seleccione **2016-03-23**.
1. En el cuadro de edición de la **Declaración de SQL**, introduzca la siguiente declaración:
```
SELECT temperature, humidity, barometer,
wind.velocity as wind_velocity,
wind.bearing as wind_bearing,
FROM 'device/+/data'
```
Esta declaración:
+ Escucha los mensajes de MQTT con un tema que coincida con el filtro de temas `device/+/data`.
+ Formatea los elementos del atributo `wind` como atributos individuales.
+ Pasa los atributos `temperature`, `humidity` y `barometer` sin cambios.
1. Elija **Siguiente** para continuar.
1. En **Acciones de reglas**:
1. Para abrir la lista de acciones de la regla para esta regla, en **Acción 1**, seleccione **DynamoDB**.
**nota**
Asegúrese de elegir DynamoDB y no DBv2 Dynamo como acción de regla.
1. En **Nombre de tabla**, elija el nombre de la tabla de DynamoDB que creó en un paso anterior:. **wx\$1data**
Los campos **Tipo de clave de partición** y **Tipo de clave de clasificación** se rellenan con los valores de la tabla de DynamoDB.
1. En **Partition key (Clave de partición)**, escriba **sample\$1time**.
1. En **Partition key value (Valor de clave de partición)**, escriba **\$1\$1timestamp()\$1**.
Esta es la primera de las [Plantillas de sustitución](iot-substitution-templates.md) que utilizará en esta regla. En lugar de usar un valor de la carga útil del mensaje, usará el valor devuelto por la función de marca de tiempo. Para saber más, consulte [timestamp](iot-sql-functions.md#iot-function-timestamp) en la *Guía del desarrollador de AWS IoT Core *.
1. En **Clave de clasificación**, escriba **device\$1id**.
1. En **Sort key value (Valor de clave de clasificación)**, escriba **\$1\$1cast(topic(2) AS DECIMAL)\$1**.
Esta es la segunda de las [Plantillas de sustitución](iot-substitution-templates.md) que utilizará en esta regla. Inserta el valor del segundo elemento en el nombre del tema, que es el identificador del dispositivo, y luego lo convierte en un valor DECIMAL para que coincida con el formato numérico de la clave. Para saber más sobre los temas, consulte el [tema](iot-sql-functions.md#iot-function-topic) en la *Guía del desarrollador de AWS IoT Core *. O para saber más sobre el reparto, consulte [reparto](iot-sql-functions.md#iot-sql-function-cast) en la *Guía del desarrollador de AWS IoT Core *.
1. En **Write message data to this column (Escribir datos del mensaje en esta columna)** introduzca **device\$1data**.
Esto creará la columna `device_data` en la tabla de DynamoDB.
1. Deje **Operation (Operación)** en blanco.
1. En el **rol de IAM**, seleccione **Crear nuevo rol**.
1. En el cuadro de diálogo **Crear rol**, en **Nombre del rol**, escriba **wx\$1ddb\$1role**. Esta nueva función contendrá automáticamente una política con el prefijo aws-iot-rule "» que permitirá a la **wx\$1data\$1ddb** regla enviar datos a la tabla de **wx\$1data** DynamoDB que haya creado.
1. En **Rol de IAM**, seleccione **wx\$1ddb\$1role**.
1. En la parte inferior de la página, elija **Siguiente**.
1. En la parte inferior de la página de **revisión y creación**, seleccione **Crear** para crear la regla.
## Paso 3: Probar la AWS IoT regla y la tabla de DynamoDB
Para probar la nueva regla, utilizará el cliente MQTT para publicar y suscribirse a los mensajes MQTT utilizados en esta prueba.
Abra el [cliente MQTT de la consola AWS IoT](https://console.aws.amazon.com//iot/home#/test) en una ventana nueva. Esto le permitirá editar la regla sin perder la configuración de su cliente MQTT. El cliente MQTT no conserva las suscripciones ni los registros de mensajes si lo abandona para ir a otra página de la consola. También querrá abrir una ventana de consola independiente en el [centro de tablas de DynamoDB de AWS IoT la](https://console.aws.amazon.com//dynamodb/home#tables:) consola para ver las nuevas entradas que envía la regla.
**Para utilizar el cliente MQTT para probar su regla**
1. En el [cliente MQTT AWS IoT de la consola de ](https://console.aws.amazon.com//iot/home#/test)`device/+/data`, suscríbase al tema de entrada, .
1. En el Cliente de MQTT, elija **Suscribirse a un tema**.
1. En el **filtro de temas**, introduzca el tema del filtro de temas de entrada, **device/\$1/data**.
1. Seleccione **Suscribirse**.
1. Ahora, publique un mensaje en el tema de entrada con un identificador de dispositivo específico, **device/22/data** No puede publicar en MQTT temas que contengan caracteres comodín.
1. En el cliente MQTT, elija **Publicar en un tema**.
1. Para **Nombre del tema**, introduzca el nombre del tema de entrada, **device/22/data**.
1. Para la **carga útil de mensajes**, introduzca los siguientes datos de ejemplo.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Para publicar el mensaje MQTT, seleccione **Publicar**.
1. Ahora, en el Cliente de MQTT, elija **Suscribirse a un tema**. En la columna **Suscribirse**, elija la suscripción **device/\$1/data**. Confirme que los datos de muestra del paso anterior aparecen allí.
1. Compruebe la fila de la tabla de DynamoDB que creó la regla.
1. **En el [centro de tablas de DynamoDB de AWS IoT la](https://console.aws.amazon.com//dynamodb/home#tables:) consola, **elija wx\$1data y, a continuación, elija** la pestaña Elementos.**
Si ya está en la pestaña **Elementos**, puede que necesite actualizar la pantalla seleccionando el icono de actualización situado en la esquina superior derecha del encabezado de la tabla.
1. Observa que los valores de **sample\$1time** de la tabla son enlaces y abre uno. Si acaba de enviar su primer mensaje, será el único de la lista.
Este enlace muestra todos los datos de esa fila de la tabla.
1. Amplíe la entrada **device\$1data** para ver los datos resultantes de la declaración de consulta de la regla.
1. Explore las diferentes representaciones de los datos que están disponibles en esta pantalla. También puede editar los datos en esta pantalla.
1. Cuando haya terminado de revisar esta fila de datos, para guardar los cambios que haya realizado, elija **Guardar** o, para salir sin guardar ningún cambio, elija **Cancelar**.
Si no observa el comportamiento correcto, consulte los consejos para la solución de problemas.
### Solución de problemas de la regla de DynamoDB
He aquí algunas cosas que debe comprobar en caso de que no esté viendo los resultados que espera.
+
**¿Tiene un mensaje de error**
Si apareció un error al publicar el mensaje de entrada, corrija primero ese error. Los siguientes pasos pueden ayudarle a corregir ese error.
+
**No ve el mensaje de entrada en el cliente MQTT**
Cada vez que publique su mensaje de entrada en el tema `device/22/data`, dicho mensaje debería aparecer en el cliente MQTT si se ha suscrito al filtro de temas `device/+/data` tal y como se describe en el procedimiento.
**Cosas que debe comprobar**
+
**Compruebe el filtro de temas al que se ha suscrito**
Si se ha suscrito al tema del mensaje de entrada como se describe en el procedimiento, debería ver una copia del mensaje de entrada cada vez que lo publique.
Si no ve el mensaje, compruebe el nombre del tema al que se suscribió y compárelo con el tema en el que lo publicó. Los nombres de los temas distinguen entre mayúsculas y minúsculas y el tema al que te suscribiste debe ser idéntico al tema en el que publicaste la carga útil del mensaje.
+
**Compruebe la función de publicación de mensajes**
En el cliente MQTT, en **Suscripciones**, elija **device/\$1/data**, marque el tema del mensaje de publicación y, a continuación, elija **Publicar en tema**. Debería ver la carga útil del mensaje en el cuadro de edición situado debajo del tema en la lista de mensajes.
+
**No ve sus datos en la tabla de DynamoDB**
La primera cosa que debe hacer es actualizar la pantalla seleccionando el icono de actualización situado en la esquina superior derecha del encabezado de la tabla. Si eso no muestra los datos que busca, compruebe lo siguiente.
**Cosas que debe comprobar**
+
**Compruebe el Región de AWS de su cliente MQTT y la regla que creó**
La consola en la que ejecuta el cliente MQTT debe estar en la misma región AWS que la regla que creó.
+
**Compruebe el tema del mensaje de entrada en la declaración de consulta de la regla**
Para que la regla funcione, debe recibir un mensaje con el nombre del tema que coincida con el filtro de tema de la cláusula FROM de la declaración de consulta de la regla.
Compruebe la ortografía del filtro de temas de la declaración de consulta de reglas con la del tema en el cliente MQTT. Los nombres de los temas distinguen mayúsculas de minúsculas y el tema del mensaje debe coincidir con el filtro de tema de la declaración de consulta de reglas.
+
**Compruebe el contenido de la carga útil del mensaje de entrada**
Para que la regla funcione, debe encontrar el campo de datos en la carga útil del mensaje que se declara en la sentencia SELECT.
Compruebe la ortografía del campo `temperature` en la declaración de consulta de la regla con la de la carga útil del mensaje en el cliente MQTT. Los nombres de los campos distinguen mayúsculas de minúsculas y el campo `temperature` de la declaración de consulta de la regla debe ser idéntico al campo `temperature` de la carga útil del mensaje.
Asegúrese de que el documento JSON de la carga útil del mensaje tenga el formato correcto. Si el JSON contiene algún error, como la falta de una coma, la regla no podrá leerlo.
+
**Compruebe los nombres de las claves y los campos utilizados en la acción de la regla**
Los nombres de campo utilizados en la regla de tema deben coincidir con los que se encuentran en la carga útil del mensaje JSON del mensaje publicado.
Abra la regla que creó en la consola y compruebe los nombres de los campos de la configuración de acciones de la regla con los utilizados en el cliente MQTT.
+
**Compruebe el rol que utiliza la regla**
La acción de la regla debe tener permiso para recibir el tema original y publicar el tema nuevo.
Las políticas que autorizan a la regla a recibir datos de mensajes y actualizar la tabla de DynamoDB son específicas de los temas utilizados. Si cambia el tema o el nombre de la tabla de DynamoDB que utiliza la regla, debe actualizar el rol de la acción de la regla para que su política coincida.
Si sospecha que éste es el problema, edite la acción de la regla y cree un nuevo rol. Los nuevos roles creados por la acción de regla reciben las autorizaciones necesarias para realizar estas acciones.
## Paso 4: Revisar los resultados y los siguientes pasos
Después de enviar algunos mensajes a la tabla de DynamoDB con esta regla, pruebe a experimentar con ella para ver cómo los cambios en algunos aspectos del tutorial afectan a los datos escritos en la tabla. He aquí algunos ejemplos para empezar.
+ Cambie *device\$1id* el tema del mensaje de entrada y observe el efecto en los datos. Puede usarlo para simular la recepción de datos de varios sensores meteorológicos.
+ Cambie los campos seleccionados en la sentencia de consulta de reglas y observe el efecto sobre los datos. Puede usar esto para filtrar los datos almacenados en la tabla.
+ Agregue una acción de regla de republicación para enviar un mensaje MQTT por cada fila agregada a la tabla. Puede utilizarla para la depuración.
Una vez que haya completado este tutorial, consulte [Tutorial: Formatear una notificación mediante una AWS Lambda función](iot-lambda-rule.md).
# Tutorial: Formatear una notificación mediante una AWS Lambda función
En este tutorial se muestra cómo enviar los datos de los mensajes MQTT a una AWS Lambda acción para formatearlos y enviarlos a otro AWS servicio. En este tutorial, la AWS Lambda acción utiliza el AWS SDK para enviar el mensaje formateado al tema de Amazon SNS que creó en el tutorial sobre cómo hacerlo. [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md)
En el tutorial sobre cómo [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md), el documento JSON resultante de la declaración de consulta de la regla se envió como cuerpo del mensaje de texto. El resultado fue un mensaje de texto parecido al siguiente ejemplo:
```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```
En este tutorial, utilizarás una acción de AWS Lambda regla para llamar a una AWS Lambda función que formatea los datos de la declaración de consulta de la regla en un formato más sencillo, como en este ejemplo:
```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```
La AWS Lambda función que crearás en este tutorial formatea la cadena del mensaje con los datos de la declaración de consulta de la regla y llama a la función de [publicación de SNS](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish) del AWS SDK para crear la notificación.
**Lo que aprenderá en este tutorial:**
+ ¿Cómo crear y probar una función? AWS Lambda
+ Cómo utilizar el AWS SDK en una AWS Lambda función para publicar una notificación de Amazon SNS
+ Cómo utilizar consultas y funciones SQL sencillas en una declaración de consulta de reglas
+ ¿Cómo usar el cliente MQTT para probar una regla AWS IoT
Para completar este tutorial se necesitan aproximadamente 45 minutos.
**Topics**
+ [Paso 1: Cree una AWS Lambda función que envíe un mensaje de texto](#iot-lambda-rule-create-lambda)
+ [Paso 2: Crea una AWS IoT regla con una AWS Lambda acción de regla](#iot-lambda-rule-create-rule)
+ [Paso 3: Pruebe la AWS IoT regla y AWS Lambda la acción de la regla](#iot-lambda-rule-test-rule)
+ [Paso 4: Revisar los resultados y los siguientes pasos](#iot-lambda-rule-next-steps)
**Antes de empezar este tutorial, asegúrese de que tiene:**
+
**[Configurar Cuenta de AWS](setting-up.md)**
Necesitará su AWS IoT consola Cuenta de AWS y su consola para completar este tutorial.
+
**[Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md) revisado**
Asegúrese de poder utilizar el cliente MQTT para suscribirse a un tema y publicar en él. En este procedimiento, utilizará el cliente MQTT para probar la nueva regla.
+
**Completó los demás tutoriales de reglas de esta sección**
Este tutorial requiere el tema de notificaciones de SNS que creó en el tutorial sobre cómo [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md). También asume que ha completado los otros tutoriales relacionados con las reglas de esta sección.
+
**Ha revisado la descripción general de [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)**
Si no lo ha utilizado AWS Lambda antes, consulte [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)[Introducción a Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) para conocer sus términos y conceptos.
## Paso 1: Cree una AWS Lambda función que envíe un mensaje de texto
La AWS Lambda función de este tutorial recibe el resultado de la declaración de consulta de reglas, inserta los elementos en una cadena de texto y envía la cadena resultante a Amazon SNS como mensaje en una notificación.
A diferencia del tutorial sobre cómo [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md) hacerlo, que utilizaba una acción de AWS IoT regla para enviar la notificación, este tutorial envía la notificación desde la función Lambda mediante una función del AWS SDK. Sin embargo, el tema de notificación de Amazon SNS que se utiliza en este tutorial es el mismo que utilizó en el tutorial sobre cómo [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md).
**Para crear una AWS Lambda función que envíe un mensaje de texto**
1. Cree una AWS Lambda función nueva.
1. En la [consola de AWS Lambda](https://console.aws.amazon.com//lambda/home), elija **Create function (Crear función)**.
1. En **Crear función**, seleccione **Usar un esquema**.
Busque y seleccione el esquema **hello-world-python** y, a continuación, elija **Configurar**
1. En **Información básica**:
1. En **Nombre de la función**, escriba el nombre de esta función, **format-high-temp-notification**.
1. En **Función de ejecución**, elija **Crear una nueva función a partir de plantillas de AWS políticas**.
1. En Nombre del rol, introduzca el nombre del nuevo rol, **format-high-temp-notification-role**.
1. En **Plantillas de políticas *(opcional)***, busque y seleccione la política de **publicación de Amazon SNS**.
1. Seleccione **Creación de función**.
1. Modifique el código del esquema para formatear y enviar una notificación de Amazon SNS.
1. Tras crear la función, debería ver la página de **format-high-temp-notification**detalles. Si no lo hace, ábrala desde la página de [**Funciones de** Lambda](https://console.aws.amazon.com//lambda/home#/functions).
1. En la página de **format-high-temp-notification**detalles, selecciona la pestaña **Configuración** y desplázate hasta el panel de **códigos de función**.
1. En la ventana **Código de función**, en el panel **Entorno**, elija el archivo Python, `lambda_function.py`.
1. En la ventana de **códigos de funciones**, elimine todo el código original del programa del esquema y sustitúyalo por este código.
```
import boto3
#
# expects event parameter to contain:
# {
# "device_id": "32",
# "reported_temperature": 38,
# "max_temperature": 30,
# "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
# }
#
# sends a plain text string to be used in a text message
#
# "Device {0} reports a temperature of {1}, which exceeds the limit of {2}."
#
# where:
# {0} is the device_id value
# {1} is the reported_temperature value
# {2} is the max_temperature value
#
def lambda_handler(event, context):
# Create an SNS client to send notification
sns = boto3.client('sns')
# Format text message from data
message_text = "Device {0} reports a temperature of {1}, which exceeds the limit of {2}.".format(
str(event['device_id']),
str(event['reported_temperature']),
str(event['max_temperature'])
)
# Publish the formatted message
response = sns.publish(
TopicArn = event['notify_topic_arn'],
Message = message_text
)
return response
```
1. Elija **Implementar**.
1. En una ventana nueva, busque el nombre de recurso de Amazon (ARN) del tema de Amazon SNS del tutorial sobre cómo [Tutorial: Envío de una notificación de Amazon SNS](iot-sns-rule.md)
1. En una nueva ventana, abra la página [Temas de la consola Amazon SNS](https://console.aws.amazon.com//sns/v3/home#/topics).
1. En la página de **temas**, busque el tema de notificación **high\$1temp\$1notice** en la lista de temas de Amazon SNS.
1. Busque el **ARN** del tema de notificación **high\$1temp\$1notice** para usarlo en el siguiente paso.
1. Cree un caso de prueba para la función de Lambda.
1. En la página [**Funciones** Lambda](https://console.aws.amazon.com//lambda/home#/functions) de la consola, en la página de **format-high-temp-notification**detalles, elija **Seleccionar un evento de prueba** en la esquina superior derecha de la página (aunque parezca deshabilitado) y, a continuación, elija **Configurar eventos de prueba**.
1. En **Configurar evento de prueba**, seleccione **Crear nuevo evento de prueba**.
1. En **Nombre del evento**, escriba **SampleRuleOutput**.
1. En el editor de JSON, debajo del **nombre del evento**, pegue este ejemplo de documento JSON. Este es un ejemplo de lo que la AWS IoT regla enviará a la función Lambda.
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30,
"notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```
1. Consulte la ventana que contiene el **ARN** del tema de notificación **high\$1temp\$1notice** y copie el valor del ARN.
1. Sustituya el valor `notify_topic_arn` del editor JSON por el ARN del tema de notificaciones.
Mantenga esta ventana abierta para poder volver a utilizar este valor de ARN al crear la regla AWS IoT .
1. Seleccione **Crear**.
1. Pruebe la función con datos de ejemplo.
1. **En la página de **format-high-temp-notification**detalles, en la esquina superior derecha de la página, confirme que **SampleRuleOutput**aparece junto al botón Probar.** Si no es así, selecciónelo de la lista de eventos de prueba disponibles.
1. Para enviar el ejemplo de mensaje de salida de la regla a su función, elija **Probar**.
Si tanto la función como la notificación han funcionado, recibirá un mensaje de texto en el teléfono suscrito a la notificación.
Si no recibió un mensaje de texto en el teléfono, verifique el resultado de la operación. En el panel de **códigos de función**, en la pestaña **Resultado de la ejecución**, revise la respuesta para encontrar cualquier error que se haya producido. No continúe con el siguiente paso hasta que la función pueda enviar la notificación a su teléfono.
## Paso 2: Crea una AWS IoT regla con una AWS Lambda acción de regla
En este paso, utilizará la sentencia de consulta de reglas para formatear los datos del dispositivo sensor meteorológico imaginario y enviarlos a una función de Lambda, que formateará y enviará un mensaje de texto.
Una muestra de la carga útil de un mensaje recibido de los dispositivos meteorológicos tiene el siguiente aspecto:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
En esta regla, utilizará la sentencia de consulta de reglas para crear una carga de mensajes para la función de Lambda con el siguiente aspecto:
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30,
"notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```
Contiene toda la información que la función de Lambda necesita para formatear y enviar el mensaje de texto correcto.
**Para crear la AWS IoT regla para llamar a una función Lambda**
1. Abra el [centro de **reglas** de la AWS IoT consola](https://console.aws.amazon.com//iot/home#/rulehub).
1. Para empezar a crear su nueva regla en **Reglas**, seleccione **Crear**.
1. En la parte superior de **Crear una regla**:
1. En **Nombre**, introduzca el nombre de la regla, **wx\$1friendly\$1text**
Recuerda que el nombre de una regla debe ser único en tu región Cuenta de AWS y no puede tener espacios. Hemos utilizado un carácter de subrayado en este nombre para separar las dos palabras del nombre de la regla.
1. En **Descripción**, describa la regla.
Una descripción significativa hace que sea más fácil recordar lo que hace esta regla y por qué la creó. La descripción puede ser tan larga como sea necesario, por lo que debe ser lo más detallada posible.
1. En **Declaración de consulta de la regla** de **Crear una regla**:
1. En la **versión Uso de SQL**, seleccione **2016-03-23**.
1. En el cuadro de edición de la **declaración de consulta de reglas**, introduzca la siguiente declaración:
```
SELECT
cast(topic(2) AS DECIMAL) as device_id,
temperature as reported_temperature,
30 as max_temperature,
'arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice' as notify_topic_arn
FROM 'device/+/data' WHERE temperature > 30
```
Esta declaración:
+ Escucha los mensajes MQTT con un tema que coincida con el filtro de temas `device/+/data` y que tengan un valor `temperature` superior a 30.
+ Selecciona el segundo elemento de la cadena de temas, lo convierte en un número decimal y lo asigna al campo `device_id`.
+ Selecciona el valor del campo `temperature`de la carga útil del mensaje y lo asigna al campo `reported_temperature`.
+ Crea un valor constante, `30`, para representar el valor límite y lo asigna al campo `max_temperature`.
+ Crea un valor constante para el campo `notify_topic_arn`.
1. Consulte la ventana que contiene el **ARN** del tema de notificación **high\$1temp\$1notice** y copie el valor del ARN.
1. Sustituya el valor del ARN (*arn:aws:sns:us-east-1:57EXAMPLE833:high\$1temp\$1notice*) en el editor de sentencias de consulta de reglas por el ARN del tema de notificación.
1. En **Establecer una o más acciones**:
1. Para abrir la lista de acciones de regla para esta regla, seleccione **Añadir acción**.
1. En **Seleccionar una acción**, elija **Enviar un mensaje a una función de Lambda**.
1. Para abrir la página de configuración de la acción seleccionada, en la parte inferior de la lista de acciones, seleccione **Configurar acción**.
1. En **Acciones de configuración**:
1. En **Nombre de la función**, elija **Seleccionar**.
1. Elija **format-high-temp-notification**.
1. En la parte inferior de **Configurar acción**, seleccione **Añadir acción**.
1. Para crear la regla, en la parte inferior de **Crear una regla**, seleccione **Crear regla**.
## Paso 3: Pruebe la AWS IoT regla y AWS Lambda la acción de la regla
Para probar la nueva regla, utilizará el cliente MQTT para publicar y suscribirse a los mensajes MQTT utilizados por esta regla.
Abra el [cliente MQTT de la consola AWS IoT](https://console.aws.amazon.com//iot/home#/test) en una ventana nueva. Ahora puede editar la regla sin perder la configuración de su cliente MQTT. Si abandona el cliente MQTT para ir a otra página de la consola, perderá sus suscripciones o los registros de mensajes.
**Para utilizar el cliente MQTT para probar su regla**
1. En el [cliente MQTT de la consola de AWS IoT](https://console.aws.amazon.com//iot/home#/test), suscríbase a los temas de entrada, en este caso, `device/+/data`.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Suscribirse a un tema**.
1. En el **tema de suscripción**, introduzca el tema del filtro de temas de entrada, **device/\$1/data**.
1. No cambie el resto de los valores predeterminados de los demás ajustes.
1. Elija **Suscribirse al tema**.
En la columna **Suscripciones**, aparece **device/\$1/data** en **Publicar en un tema**.
1. Publique un mensaje en el tema de entrada con un identificador de dispositivo específico, **device/32/data** No puede publicar en MQTT temas que contengan caracteres comodín.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Publicar en tema**.
1. En el campo **Publicar**, introduzca el nombre del tema de entrada,. **device/32/data**
1. Copie los datos de ejemplo que se muestran aquí y, en el cuadro de edición situado debajo del nombre del tema, péguelos.
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Para publicar su mensaje MQTT, elija **Publicar en tema**.
1. Confirme que se envió el mensaje de texto.
1. En el cliente de MQTT, en **Suscripciones**, hay un punto verde junto al tema al que se ha suscrito anteriormente.
El punto verdes indica que se han recibido uno o más mensajes nuevos desde la última vez que los consultó.
1. En **Suscripciones**, seleccione **device/\$1/data** para comprobar que la carga útil de los mensajes coincide con la que acaba de publicar y tiene este aspecto:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Compruebe el teléfono que utilizó para suscribirse al tema SNS y confirme que el contenido de la carga útil del mensaje tiene este aspecto:
```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```
Si cambia el elemento ID del tema en el tema del mensaje, recuerde que la conversión del valor `topic(2)` a un valor numérico sólo funcionará si ese elemento en el tema del mensaje sólo contiene caracteres numéricos.
1. Intente enviar un mensaje MQTT en el que la temperatura no supere el límite.
1. En el cliente MQTT, en **Suscripciones**, seleccione **Publicar en tema**.
1. En el campo **Publicar**, introduzca el nombre del tema de entrada,. **device/33/data**
1. Copie los datos de ejemplo que se muestran aquí y, en el cuadro de edición situado debajo del nombre del tema, péguelos.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Para enviar su mensaje MQTT, seleccione **Publicar en tema**.
Debería ver el mensaje que envió en la suscripción **device/\$1/data**; sin embargo, como el valor de la temperatura está por debajo de la temperatura máxima en la sentencia de consulta de la regla, no debería recibir un mensaje de texto.
Si no observa el comportamiento correcto, consulte los consejos para la solución de problemas.
### Solución de problemas con AWS Lambda la regla y la notificación
He aquí algunas cosas que debe comprobar, en caso de que no esté viendo los resultados que espera.
+
**¿Tiene un mensaje de error**
Si apareció un error al publicar el mensaje de entrada, corrija primero ese error. Los siguientes pasos pueden ayudarle a corregir ese error.
+
**No ve el mensaje de entrada en el cliente MQTT**
Cada vez que publique su mensaje de entrada en el tema `device/32/data`, dicho mensaje debería aparecer en el cliente MQTT si se ha suscrito al filtro de temas `device/+/data` tal y como se describe en el procedimiento.
**Cosas que debe comprobar**
+
**Compruebe el filtro de temas al que se ha suscrito**
Si se ha suscrito al tema del mensaje de entrada como se describe en el procedimiento, debería ver una copia del mensaje de entrada cada vez que lo publique.
Si no ve el mensaje, compruebe el nombre del tema al que se suscribió y compárelo con el tema en el que lo publicó. Los nombres de los temas distinguen entre mayúsculas y minúsculas y el tema al que te suscribiste debe ser idéntico al tema en el que publicaste la carga útil del mensaje.
+
**Compruebe la función de publicación de mensajes**
En el cliente MQTT, en **Suscripciones**, elija **device/\$1/data**, marque el tema del mensaje de publicación y, a continuación, elija **Publicar en tema**. Debería ver la carga útil del mensaje en el cuadro de edición situado debajo del tema en la lista de mensajes.
+
**Si no recibe el mensaje SMS:**
Para que su regla funcione, debe tener la política correcta que la autorice a recibir un mensaje y enviar una notificación SNS, y debe recibir el mensaje.
**Cosas que debe comprobar**
+
**Compruebe el Región de AWS de su cliente MQTT y la regla que creó**
La consola en la que ejecuta el cliente MQTT debe estar en la misma región AWS que la regla que creó.
+
**Compruebe que el valor de temperatura de la carga útil del mensaje supera el umbral de prueba**
Si el valor de temperatura es inferior o igual a 30, tal como se define en la sentencia de consulta de la regla, la regla no realizará ninguna de sus acciones.
+
**Compruebe el tema del mensaje de entrada en la declaración de consulta de la regla**
Para que la regla funcione, debe recibir un mensaje con el nombre del tema que coincida con el filtro de tema de la cláusula FROM de la declaración de consulta de la regla.
Compruebe la ortografía del filtro de temas de la declaración de consulta de reglas con la del tema en el cliente MQTT. Los nombres de los temas distinguen mayúsculas de minúsculas y el tema del mensaje debe coincidir con el filtro de tema de la declaración de consulta de reglas.
+
**Compruebe el contenido de la carga útil del mensaje de entrada**
Para que la regla funcione, debe encontrar el campo de datos en la carga útil del mensaje que se declara en la sentencia SELECT.
Compruebe la ortografía del campo `temperature` en la declaración de consulta de la regla con la de la carga útil del mensaje en el cliente MQTT. Los nombres de los campos distinguen mayúsculas de minúsculas y el campo `temperature` de la declaración de consulta de la regla debe ser idéntico al campo `temperature` de la carga útil del mensaje.
Asegúrese de que el documento JSON de la carga útil del mensaje tenga el formato correcto. Si el JSON contiene algún error, como la falta de una coma, la regla no podrá leerlo.
+
**Compruebe la notificación de Amazon SNS**
En [Paso 1: crear un tema de Amazon SNS que envía un mensaje de texto SMS](iot-sns-rule.md#iot-sns-rule-create-sns-topic), consulte el paso 3, que describe cómo probar la notificación de Amazon SNS y probar la notificación para asegurarse de que funciona.
+
**Comprobar la función de Lambda**
En [Paso 1: Cree una AWS Lambda función que envíe un mensaje de texto](#iot-lambda-rule-create-lambda), consulte el paso 5, que describe cómo probar la función de Lambda con datos de prueba y probar la función de Lambda.
+
**Compruebe el rol que utiliza la regla**
La acción de la regla debe tener permiso para recibir el tema original y publicar el tema nuevo.
Las políticas que autorizan a la regla a recibir datos de los mensajes y volver a publicarlos son específicas de los temas utilizados. Si cambia el tema utilizado para volver a publicar los datos del mensaje, debe actualizar la función de la acción de regla para actualizar su política y que coincida con el tema actual.
Si sospecha que este es el problema, edite la acción Volver a publicar la regla y cree un nuevo rol. Los nuevos roles creados por la acción de regla reciben las autorizaciones necesarias para realizar estas acciones.
## Paso 4: Revisar los resultados y los siguientes pasos
**En este tutorial:**
+ Creó una AWS IoT regla para llamar a una función de Lambda que enviaba una notificación de Amazon SNS que utilizaba su carga de mensajes personalizada.
+ Utilizó una consulta y funciones SQL sencillas en una sentencia de consulta de reglas para crear una nueva carga útil de mensajes para la función de Lambda.
+ Utilizó el cliente MQTT para probar la regla. AWS IoT
**Siguientes pasos**
Después de enviar unos cuantos mensajes de texto con esta regla, pruebe a experimentar con ella para ver cómo el cambio de algunos aspectos del tutorial afecta al mensaje y al momento en que se envía. He aquí algunos ejemplos para empezar.
+ Cambie *device\$1id* el tema del mensaje de entrada y observe el efecto en el contenido del mensaje de texto.
+ Cambie los campos seleccionados en la sentencia de consulta de reglas, actualice la función de Lambda para utilizarlos en un nuevo mensaje y observe el efecto en el contenido del mensaje de texto.
+ Cambie la prueba en la declaración de consulta de reglas para probar una temperatura mínima en lugar de una temperatura máxima. Actualice la función de Lambda para formatear un mensaje nuevo y recuerde cambiar el nombre de `max_temperature`.
+ Para obtener más información sobre cómo encontrar los errores que pueden producirse al desarrollar y utilizar AWS IoT reglas, consulte[Monitorización AWS IoT](monitoring_overview.md).
# Retener el estado del dispositivo mientras el dispositivo está fuera de línea con Device Shadows
Estos tutoriales muestran cómo utilizar el servicio AWS IoT Device Shadow para almacenar y actualizar la información de estado de un dispositivo. El documento Shadow, que es un documento JSON, muestra el cambio en el estado del dispositivo en función de los mensajes publicados por un dispositivo, una aplicación local o un servicio. En este tutorial, el documento de sombra muestra el cambio en el color de una bombilla. Estos tutoriales también muestran cómo la sombra almacena esta información incluso cuando el dispositivo está desconectado de Internet y le devuelve la información de estado más reciente cuando vuelve a conectarse y solicita esta información.
Le recomendamos que pruebe estos tutoriales en el orden en que se muestran aquí, empezando por los recursos AWS IoT que necesita para crearlos y la configuración de hardware necesaria, lo que también le ayudará a aprender los conceptos de forma gradual. Estos tutoriales muestran cómo configurar y conectar un dispositivo Raspberry Pi para usarlo con él AWS IoT. Si no dispone del hardware necesario, puede seguir estos tutoriales adaptándolos al dispositivo que prefiera o [creando un dispositivo virtual con Amazon EC2](creating-a-virtual-thing.md).
**Información general del escenario del tutorial**
El escenario de estos tutoriales es una aplicación o un servicio local que cambia el color de una bombilla y publica sus datos en temas ocultos reservados. Estos tutoriales son similares a la funcionalidad Device Shadow descrita en el [tutorial interactivo de introducción](interactive-demo.md) y se implementan en un dispositivo Raspberry Pi. Los tutoriales de esta sección se centran en una única sombra clásica y, al mismo tiempo, muestran cómo se pueden acomodar sombras con nombres o varios dispositivos.
Los siguientes tutoriales le ayudarán a aprender a utilizar el servicio AWS IoT Device Shadow.
+
**[Tutorial: Cómo preparar la Raspberry Pi para ejecutar la aplicación shadow](create-resources-shadow.md)**
Este tutorial muestra cómo configurar un dispositivo Raspberry Pi para conectarlo AWS IoT. También creará un documento de AWS IoT política y un recurso específico, descargará los certificados y, a continuación, adjuntará la política a ese recurso. Para completar este tutorial se necesitan aproximadamente 30 minutos.
+
**[Tutorial: Instalación del SDK del dispositivo y ejecución de la aplicación de ejemplo para Device Shadows](lightbulb-shadow-application.md)**
En este tutorial se muestra cómo instalar las herramientas, el software y el SDK de AWS IoT dispositivos necesarios para Python y, a continuación, ejecutar la aplicación oculta de ejemplo. Este tutorial se basa en los conceptos presentados en [Conexión de una Raspberry Pi u otro dispositivo](connecting-to-existing-device.md) y tarda 20 minutos en completarse.
+
**[Tutorial: Interactuar con Device Shadow mediante la aplicación de ejemplo y el cliente de pruebas MQTT](interact-lights-device-shadows.md)**
En este tutorial se muestra cómo utilizar la aplicación y la **AWS IoT consola** de `shadow.py` ejemplo para observar la interacción entre AWS IoT Device Shadows y los cambios de estado de la bombilla. El tutorial también muestra cómo enviar mensajes MQTT a los temas reservados de Device Shadow. Para completar este tutorial se necesitan aproximadamente 45 minutos.
**AWS IoT Descripción general de Device Shadow**
Un Device Shadow es una representación virtual y persistente de un dispositivo que se administra [mediante un recurso](iot-thing-management.md) creado en el AWS IoT registro. El documento Shadow es un JSON o un documento de JavaScript notación que se utiliza para almacenar y recuperar la información del estado actual de un dispositivo. Puede usar la sombra para obtener y establecer el estado de un dispositivo mediante temas de MQTT o HTTP REST APIs, independientemente de si el dispositivo está conectado a Internet.
Un documento Shadow contiene una propiedad `state` que describe estos aspectos del estado del dispositivo.
+ `desired`: Las aplicaciones especifican los estados deseados de las propiedades del dispositivo actualizando el objeto `desired`.
+ `reported`: Los dispositivos notifican su estado actual en el objeto `reported`.
+ `delta`: AWS IoT informa de las diferencias entre el estado deseado y el estado reportado en el `delta` objeto.
He aquí un ejemplo de documento de estado en Shadow.
```
{
"state": {
"desired": {
"color": "green"
},
"reported": {
"color": "blue"
},
"delta": {
"color": "green"
}
}
}
```
Para actualizar el documento Shadow de un dispositivo, puede utilizar los [temas reservados de MQTT](reserved-topics.md#reserved-topics-shadow), el [Device Shadow REST APIs](device-shadow-rest-api.md) que admite las `GET` operaciones con HTTP y `DELETE` las operaciones con HTTP y la [AWS IoT CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot-data/index.html). `UPDATE`
En el ejemplo anterior, supongamos que desea cambiar el color `desired` a `yellow`. Para ello, envía una solicitud a la API [UpdateThingShadow](device-shadow-rest-api.md#API_UpdateThingShadow) o publica un mensaje en el tema [Actualizar](device-shadow-mqtt.md#update-pub-sub-topic), `$aws/things/THING_NAME/shadow/update`.
```
{
"state": {
"desired": {
"color": yellow
}
}
}
```
Las actualizaciones afectan únicamente a los campos especificados en la solicitud. Tras actualizar correctamente Device Shadow, AWS IoT publica el nuevo `desired` estado del `delta` tema,`$aws/things/THING_NAME/shadow/delta`. El documento Shadow en este caso tiene este aspecto:
```
{
"state": {
"desired": {
"color": yellow
},
"reported": {
"color": green
},
"delta": {
"color": yellow
}
}
}
```
A continuación, se informa del nuevo estado a AWS IoT Device Shadow mediante el `Update` tema `$aws/things/THING_NAME/shadow/update` con el siguiente mensaje JSON:
```
{
"state": {
"reported": {
"color": yellow
}
}
}
```
Si desea obtener la información sobre el estado actual, envíe una solicitud a la API [GetThingShadow](device-shadow-rest-api.md#API_GetThingShadow) o publique un mensaje MQTT en el tema [Obtener](device-shadow-mqtt.md#get-pub-sub-topic), `$aws/things/THING_NAME/shadow/get`.
Para obtener más información sobre el uso del servicio Device Shadow, consulte [AWS IoT Servicio Device Shadow](iot-device-shadows.md).
Para obtener más información sobre el uso de Device Shadows en dispositivos, aplicaciones y servicios, consulte [Uso de sombras en dispositivos](device-shadow-comms-device.md) y [Uso de sombras en aplicaciones y servicios](device-shadow-comms-app.md).
Para obtener información sobre cómo interactuar con AWS IoT las sombras, consulte[Interacción con sombras](device-shadow-data-flow.md).
Para obtener información sobre los temas reservados de MQTT y HTTP REST APIs, consulte [Temas MQTT de sombra de dispositivo](device-shadow-mqtt.md) y[API REST de sombra de dispositivo](device-shadow-rest-api.md).
# Tutorial: Cómo preparar la Raspberry Pi para ejecutar la aplicación shadow
Este tutorial muestra cómo instalar y configurar un dispositivo Raspberry Pi y cómo crear los AWS IoT recursos que un dispositivo necesita para conectarse e intercambiar mensajes MQTT.
**nota**
Si tiene previsto [Crear un dispositivo virtual con Amazon EC2](creating-a-virtual-thing.md), puede saltarse esta página y continuar en [Configuración del dispositivo](configure-device.md). Creará estos recursos cuando cree su objeto virtual. Si desea utilizar un dispositivo diferente en lugar de la Raspberry Pi, puede intentar seguir estos tutoriales adaptándolos a un dispositivo de su elección.
**En este tutorial, aprenderá a:**
+ Configura un dispositivo Raspberry Pi y configúralo para usarlo con AWS IoTél.
+ Cree un documento AWS IoT de política que autorice a su dispositivo a interactuar con AWS IoT los servicios.
+ Cree un recurso específico en AWS IoT los certificados de dispositivo X.509 y, a continuación, adjunte el documento de política.
Se trata de la representación virtual de su dispositivo en el registro AWS IoT . El certificado autentica el dispositivo ante AWS IoT Core y el documento de política autoriza al dispositivo a interactuar con él. AWS IoT
**Cómo ejecutar este tutorial**
Para ejecutar la aplicación de ejemplo `shadow.py` para Device Shadows, necesitará un dispositivo Raspberry Pi que se conecte a AWS IoT. Le recomendamos que siga este tutorial en el orden en que se presenta aquí, comenzando con la configuración de la Raspberry Pi y sus accesorios, y luego la creación de una política y la vinculación de la política a un recurso cosa que usted cree. A continuación, puede seguir este tutorial utilizando la interfaz gráfica de usuario (GUI) compatible con la Raspberry Pi para abrir la AWS IoT consola en el navegador web del dispositivo, lo que también facilita la descarga de los certificados directamente a su Raspberry Pi para conectarse a ella. AWS IoT
**Antes de empezar este tutorial, asegúrese de que tiene:**
+ Un Cuenta de AWS. Si no la tiene, complete los pasos que se describen en [Configurar Cuenta de AWS](setting-up.md) antes de continuar. Necesitarás una consola Cuenta de AWS y una AWS IoT consola para completar este tutorial.
+ La Raspberry Pi y los accesorios necesarios. Necesitará lo siguiente:
+ Una [Raspberry Pi 3 Modelo B](https://www.raspberrypi.com/products/) o un modelo más reciente. Este tutorial puede funcionar en versiones anteriores de la Raspberry Pi, pero no lo hemos probado.
+ [Sistema operativo Raspberry Pi (32 bits)](https://www.raspberrypi.com/software/operating-systems/) o posterior. Recomendamos utilizar la última versión del sistema operativo Raspberry Pi. Este tutorial puede funcionar en versiones anteriores del sistema operativo, pero no lo hemos probado.
+ Una conexión Ethernet o wifi.
+ Teclado, ratón, monitor, cables y fuentes de alimentación.
Para completar este tutorial se necesitan aproximadamente 30 minutos.
## Paso 1: Instalar y configurar el dispositivo Raspberry Pi
En esta sección, configuraremos un dispositivo Raspberry Pi para usarlo con AWS IoT.
**importante**
Adaptar estas instrucciones a otros dispositivos y sistemas operativos puede resultar difícil. Deberás entender el dispositivo lo suficientemente bien como para poder interpretar estas instrucciones y aplicarlas al dispositivo. Si encuentra dificultades, puede probar una de las otras opciones de dispositivos como alternativa, por ejemplo [Crear un dispositivo virtual con Amazon EC2](creating-a-virtual-thing.md) o [Utilice su PC o Mac con Windows o Linux como dispositivo AWS IoT](using-laptop-as-device.md).
Tendrá que configurar su Raspberry Pi de forma que pueda iniciar el sistema operativo (SO), conectarse a Internet y permitirle interactuar con ella en una interfaz de línea de comandos. También puedes usar la interfaz gráfica de usuario (GUI) compatible con la Raspberry Pi para abrir la AWS IoT consola y ejecutar el resto de este tutorial.
**Para configurar el dispositivo Raspberry Pi:**
1. Inserte la tarjeta SD en la ranura para tarjetas MicroSD de la Raspberry Pi. Algunas tarjetas SD vienen precargadas con un administrador de instalación que muestra un menú para instalar el sistema operativo después de arrancar la placa. También puede utilizar el generador de imágenes de la Raspberry Pi para instalar el sistema operativo en su tarjeta.
1. Conecte un televisor o monitor HDMI al cable HDMI que se conecta al puerto HDMI de la Raspberry Pi.
1. Conecte el teclado y el ratón a los puertos USB de la Raspberry Pi y, a continuación, enchufe el adaptador de corriente para arrancar la placa.
Una vez que se inicie la Raspberry Pi, si la tarjeta SD viene precargada con el administrador de instalación, aparecerá un menú para instalar el sistema operativo. Si tiene problemas para instalar el sistema operativo, pruebe los siguientes pasos. Para más información sobre la configuración de la Raspberry Pi, consulte [Configuración de su Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/).
**Si tiene problemas para configurar la Raspberry Pi:**
+ Compruebe si ha insertado la tarjeta SD antes de arrancar la placa. Si conecta la tarjeta SD después de arrancar la placa, es posible que no aparezca el menú de instalación.
+ Asegúrese de que el televisor o el monitor estén encendidos y de que se haya seleccionado la entrada correcta.
+ Asegúrese de utilizar un software compatible con Raspberry Pi.
Una vez que haya instalado y configurado el sistema operativo Raspberry Pi, abra el navegador web de la Raspberry Pi y navegue hasta la AWS IoT Core consola para continuar con el resto de los pasos de este tutorial.
Si puedes abrir la AWS IoT Core consola, tu Raspberry Pi está lista y puedes continuar haciéndolo[Tutorial: Aprovisionar tu dispositivo en AWS IoT](shadow-provision-cloud.md).
Si tiene problemas o necesita ayuda adicional, consulte [Cómo obtener ayuda para su Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/5).
# Tutorial: Aprovisionar tu dispositivo en AWS IoT
En esta sección, se crean los AWS IoT Core recursos que utilizará el tutorial.
**Topics**
+ [Paso 1: Crear una AWS IoT política para Device Shadow](#create-policy-shadow)
+ [Paso 2: Cree un recurso cosa y adjunte la política a la cosa](#create-thing-shadow)
+ [Paso 3: Revisar los resultados y los siguientes pasos](#resources-shadow-review)
## Paso 1: Crear una AWS IoT política para Device Shadow
Los certificados X.509 autentican su dispositivo. AWS IoT Core AWS IoT se adjuntan políticas al certificado que permiten al dispositivo realizar AWS IoT operaciones, como suscribirse o publicar en temas reservados de MQTT utilizados por el servicio Device Shadow. El dispositivo presenta su certificado cuando se conecta y envía mensajes a. AWS IoT Core
En este procedimiento, creará una política que permita al dispositivo realizar las operaciones AWS IoT necesarias para ejecutar el programa de ejemplo. Le recomendamos que cree una política que conceda únicamente los permisos necesarios para realizar la tarea. Primero debe crear la AWS IoT política y, a continuación, adjuntarla al certificado del dispositivo que creará más adelante.
**Para crear una AWS IoT política**
1. En el panel de navegación de la izquierda, seleccione **Seguridad** y, a continuación, elija **Políticas**. Si su cuenta tiene pólizas existentes, elija **Crear**, de lo contrario, en la página **Aún no tiene una política**, elija **Crear una política**.
1. En la página **Crear una política**:
1. Introduzca un nombre para la política en el campo **Nombre** (por ejemplo, **My\$1Device\$1Shadow\$1policy**). No utilice información personalmente identificable en sus nombres de política.
1. En el documento de política, se describen las acciones de conexión, suscripción, recepción y publicación que dan permiso al dispositivo para publicar y suscribirse a los temas reservados de MQTT.
Copie el siguiente ejemplo de política y péguelo en su documento de política. `thingname`Sustitúyala por el nombre de lo que vas a crear (por ejemplo,`My_light_bulb`), `region` por la AWS IoT región en la que utilizas los servicios y `account` por tu Cuenta de AWS número. Para obtener más información sobre AWS IoT las políticas, consulte[AWS IoT Core políticas](iot-policies.md).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/test-*"
}
]
}
```
## Paso 2: Cree un recurso cosa y adjunte la política a la cosa
Los dispositivos conectados a AWS IoT pueden representarse mediante *recursos* de objetos en el AWS IoT registro. Un *recurso de cosa* representa un dispositivo específico o una entidad lógica, como la bombilla de este tutorial.
Para obtener información sobre cómo crear una cosa en AWS IoT, siga los pasos que se describen en[Crear un objeto](create-iot-resources.md#create-aws-thing). He aquí algunas cosas clave que debe tener en cuenta mientras sigue los pasos de ese tutorial:
1. Elija **Crear una sola cosa** y, en el campo **Nombre**, introduzca un nombre para la cosa que sea igual a la `thingname` (por ejemplo, `My_light_bulb`) que especificó al crear la política anteriormente.
No se puede cambiar el nombre de una cosa después de haberla creado. Si le dio un nombre diferente a `thingname`, cree una cosa nueva con el nombre `thingname` y borre la cosa antigua.
**nota**
No utilice información personal identificable en el nombre de la cosa. El nombre de la cosa puede aparecer en comunicaciones e informes no cifrados.
1. Le recomendamos que descargue cada uno de los archivos de certificado de la página **¡Certificado creado\$1** en un lugar donde pueda encontrarlos fácilmente. Necesitará instalar estos archivos para ejecutar la aplicación de ejemplo.
Le recomendamos que descargue los archivos en un subdirectorio `certs` del directorio `home` de su Raspberry Pi y asigne un nombre más simple a cada uno de ellos, tal y como se sugiere en la siguiente tabla.
**Nombres de archivo de certificado**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/shadow-provision-cloud.html)
1. Después de activar el certificado para habilitar las conexiones AWS IoT, elija **Adjuntar una política** y asegúrese de adjuntar la política que creó anteriormente (por ejemplo,**My\$1Device\$1Shadow\$1policy**) a la cosa.
Una vez que hayas creado una cosa, podrás ver tu recurso en la lista de cosas de la AWS IoT consola.
## Paso 3: Revisar los resultados y los siguientes pasos
**En este tutorial, ha aprendido a:**
+ Instalar y configurar el dispositivo Raspberry Pi.
+ Crea un documento AWS IoT de política que autorice a tu dispositivo a interactuar con AWS IoT los servicios.
+ Crear un recurso de cosas y un certificado de dispositivo X.509 asociado, y adjuntarle el documento de política.
**Siguientes pasos**
Ahora puede instalar el SDK del AWS IoT dispositivo para Python, ejecutar la aplicación de `shadow.py` ejemplo y usar Device Shadows para controlar el estado. Para más información sobre cómo ejecutar este tutorial, consulte [Tutorial: Instalación del SDK del dispositivo y ejecución de la aplicación de ejemplo para Device Shadows](lightbulb-shadow-application.md).
# Tutorial: Instalación del SDK del dispositivo y ejecución de la aplicación de ejemplo para Device Shadows
En esta sección se muestra cómo instalar el software necesario y el SDK de AWS IoT dispositivos para Python y ejecutar la aplicación de `shadow.py` ejemplo para editar el documento Shadow y controlar el estado de la sombra.
**En este tutorial, aprenderá a:**
+ Usa el software instalado y el SDK de AWS IoT dispositivo para Python para ejecutar la aplicación de muestra.
+ Descubre cómo al introducir un valor con la aplicación de ejemplo, se publica el valor deseado en la consola de AWS IoT .
+ Revise la aplicación de ejemplo `shadow.py` y descubra cómo utiliza el protocolo MQTT para actualizar el estado de la sombra.
**Antes de ejecutar este tutorial:**
Debe haber configurado su Cuenta de AWS dispositivo Raspberry Pi y creado AWS IoT algo y una política que otorgue al dispositivo permisos para publicar y suscribirse a los temas reservados de MQTT del servicio Device Shadow. Para obtener más información, consulte [Tutorial: Cómo preparar la Raspberry Pi para ejecutar la aplicación shadow](create-resources-shadow.md).
También debes haber instalado Git, Python y el SDK de AWS IoT dispositivos para Python. Este tutorial se basa en los conceptos presentados en el tutorial [Conexión de una Raspberry Pi u otro dispositivo](connecting-to-existing-device.md). Si no ha probado ese tutorial, le recomendamos que siga los pasos descritos en él para instalar los archivos de certificado y el SDK del dispositivo y, a continuación, vuelva a este tutorial para ejecutar la aplicación de ejemplo `shadow.py`.
**Topics**
+ [Paso 1: ejecutar la aplicación de ejemplo shadow.py](#run-sample-application-shadows)
+ [Paso 2: Revisar la aplicación de ejemplo del SDK de dispositivos shadow.py](#review-shadow-sample-code)
+ [Paso 3: Solucionar problemas con la aplicación de ejemplo `shadow.py`](#shadow-sample-app-troubleshoot)
+ [Paso 4: Revisar los resultados y los siguientes pasos](#sample-app-shadow-review)
Para completar este tutorial se necesitan aproximadamente 20 minutos.
## Paso 1: ejecutar la aplicación de ejemplo shadow.py
Antes de ejecutar la aplicación de ejemplo `shadow.py`, necesitará la siguiente información además de los nombres y la ubicación de los archivos de certificado que instaló.
**Valores de los parámetros de la aplicación**
| Parámetro | Dónde encontrar el valor |
| --- | --- |
| your-iot-thing-name | Nombre del elemento AWS IoT que creaste anteriormente en[Paso 2: Cree un recurso cosa y adjunte la política a la cosa](shadow-provision-cloud.md#create-thing-shadow). Para encontrar este valor, en la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), seleccione **Administrar** y, a continuación, seleccione **Cosas**. |
| your-iot-endpoint | El *your-iot-endpoint* valor tiene el formato:`endpoint_id-ats.iot.region.amazonaws.com`, por ejemplo,`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`. Para encontrar este valor: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/lightbulb-shadow-application.html) |
**Instalar y ejecutar la aplicación de ejemplo**
1. Navegue hasta el directorio de la aplicación de ejemplo.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
```
1. En la ventana de la línea de comandos, *your-iot-thing-name* sustituya *your-iot-endpoint* y, como se indica, y ejecute este comando.
```
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
1. Observe que la aplicación de ejemplo:
1. Se conecta al servicio de AWS IoT de tu cuenta.
1. Se suscribe a eventos `Delta` y respuestas `Update` y `Get`.
1. Le pide que introduzca el valor deseado en el terminal.
1. Muestra una salida similar a la siguiente:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow contains reported value 'off'.
Enter desired value:
```
**nota**
Si tiene problemas para ejecutar la aplicación de ejemplo `shadow.py`, revise [Paso 3: Solucionar problemas con la aplicación de ejemplo `shadow.py`](#shadow-sample-app-troubleshoot). Para obtener información adicional que pueda ayudarle a corregir el problema, añada el parámetro `--verbosity debug` a la línea de órdenes para que la aplicación de ejemplo muestre mensajes detallados sobre lo que está haciendo.
**Introduzca los valores y observe las actualizaciones en el documento Shadow**
Puede introducir valores en el terminal para especificar el valor `desired`, lo que también actualiza el valor `reported`. Supongamos que introduce el color `yellow` en el terminal. El valor `reported` también se actualiza al color `yellow`. A continuación se muestran los mensajes que se muestran en el terminal:
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Al publicar esta solicitud de actualización, AWS IoT crea una sombra clásica y predeterminada para el recurso. Puede observar la solicitud de actualización que publicó en `desired` los valores `reported` y de la AWS IoT consola consultando el documento Shadow del recurso de objetos que creó (por ejemplo,`My_light_bulb`). Para ver la actualización en el documento Shadow, siga estos pasos:
1. En la AWS IoT consola, selecciona **Administrar** y, a continuación, selecciona **Cosas**.
1. En la lista de cosas que se muestran, seleccione la cosa que ha creado, elija **Sombras** y, a continuación, **Sombra clásica**.
El documento Shadow debería tener un aspecto similar al siguiente y mostrar los valores `reported` y `desired` establecidos en el color `yellow`. Puede ver estos valores en la sección **Estado de sombra** del documento.
```
{
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
}
```
También verá una sección de **metadatos** que contiene la información de la marca de tiempo y el número de versión de la solicitud.
Puede utilizar la versión del documento de estado para asegurarse de que actualiza la versión más reciente del documento de sombra de un dispositivo. Si envía otra solicitud de actualización, el número de versión aumentará en 1. Cuando se suministra una versión con una solicitud de actualización, el servicio rechaza la solicitud con un código de respuesta de conflicto HTTP 409 si la versión actual del documento de estado no coincide con la versión suministrada.
```
{
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
}
},
"version": 10
}
```
Para obtener más información sobre el documento alternativo y observar los cambios en la información de estado, continúe con el siguiente tutorial [Tutorial: Interactuar con Device Shadow mediante la aplicación de ejemplo y el cliente de pruebas MQTT](interact-lights-device-shadows.md), tal como se describe en la sección [Paso 4: Revisar los resultados y los siguientes pasos](#sample-app-shadow-review) de este tutorial. Si lo desea, también puede obtener información sobre el código de ejemplo `shadow.py` y cómo utiliza el protocolo MQTT en la siguiente sección.
## Paso 2: Revisar la aplicación de ejemplo del SDK de dispositivos shadow.py
En esta sección se revisa la aplicación de ejemplo `shadow.py` del **SDK de dispositivos AWS IoT v2 para Python** utilizada en este tutorial. Aquí veremos cómo se conecta AWS IoT Core mediante los protocolos MQTT y MQTT over WSS. La biblioteca [de tiempo de ejecución AWS común (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.
Si bien este tutorial utiliza MQTT y MQTT sobre WSS, AWS IoT es compatible con los dispositivos que publican solicitudes HTTPS. 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.
Para obtener información sobre cómo tomar una decisión fundamentada sobre qué protocolo utilizar para las comunicaciones de su dispositivo, consulte la [Elección de un protocolo de aplicación para la comunicación entre dispositivos](protocols.md#protocol-selection).
**MQTT**
Las llamadas de ejemplo `shadow.py` `mtls_from_path` (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. `mtls_from_path` utiliza 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`es el AWS IoT punto final que ha introducido desde la línea de comandos y `client_id` es el ID que identifica de forma exclusiva a este dispositivo en. Región de AWS
+ `cert_filepath`, `pri_key_filepath` y `ca_filepath` son las rutas a los archivos de certificados y claves privadas del dispositivo y al archivo CA raíz.
+ `client_bootstrap` es el objeto común en tiempo de ejecución que gestiona las actividades de comunicación del socket, y se instancia antes de la llamada a `mqtt_connection_builder.mtls_from_path`.
+ `on_connection_interrupted` y `on_connection_resumed` son funciones de devolución de llamada para llamar cuando la conexión del dispositivo se interrumpe y se reanuda.
+ `clean_session` es si se debe iniciar una nueva sesión persistente o, si ya existe una, reconectarse a una existente. `keep_alive_secs` es el valor de mantenimiento de vida, en segundos, que se debe enviar en la solicitud `CONNECT`. Se enviará automáticamente un ping en este intervalo. El servidor asume que la conexión se pierde si no recibe un ping después de 1,5 veces este valor.
La muestra `shadow.py` también llama a `websockets_with_default_aws_signing` 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 usando el protocolo MQTT sobre WSS. MQTT sobre WSS también utiliza los mismos parámetros que MQTT y toma estos parámetros adicionales:
+ `region`es la región de AWS firma utilizada en la autenticación de Signature V4 y `credentials_provider` son las AWS credenciales que se proporcionan para utilizarlas en la autenticación. La Región se pasa desde la línea de comandos, y el objeto `credentials_provider` se instancia justo antes de la llamada a `mqtt_connection_builder.websockets_with_default_aws_signing`.
+ `websocket_proxy_options` son las opciones de proxy HTTP, si se utiliza un servidor proxy. En la aplicación de ejemplo `shadow.py`, este valor se crea justo antes de la llamada a `mqtt_connection_builder.websockets_with_default_aws_signing`.
**Suscribirse a los temas y eventos de Sombra**
El ejemplo `shadow.py` intenta establecer una conexión y espera a que esté completamente conectado. Si no está conectado, los comandos se ponen en cola. Una vez conectado, el ejemplo se suscribe a los eventos delta y actualiza y recibe mensajes, y publica los mensajes con un nivel de calidad de servicio (QoS) de 1 (`mqtt.QoS.AT_LEAST_ONCE`).
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.
Para más información sobre el protocolo MQTT, consulte [Revise el protocolo MQTT](sdk-tutorials.md#sdk-tutorials-mqtt-review) y [MQTT](mqtt.md).
Para obtener más información sobre cómo se utilizan MQTT, MQTT sobre WSS, las sesiones persistentes y los niveles de QoS que se utilizan en este tutorial, consulte [Consulte la aplicación de ejemplo del SDK de dispositivo pubsub.py](sdk-tutorials.md#sdk-tutorials-explore-sample).
## Paso 3: Solucionar problemas con la aplicación de ejemplo `shadow.py`
Cuando ejecute la aplicación de ejemplo `shadow.py`, debería ver algunos mensajes en el terminal y un aviso para introducir un valor `desired`. Si el programa arroja un error, para depurarlo puede empezar por comprobar si ha ejecutado el comando correcto para su sistema.
En algunos casos, el mensaje de error puede indicar problemas de conexión y tener un aspecto similar a: `Host name was invalid for dns resolution` o `Connection was closed unexpectedly`. En esos casos, puede comprobar lo siguiente:
+
**Compruebe la dirección del punto de conexión en el comando**
Revise el argumento `endpoint` del comando que introdujo para ejecutar la aplicación de ejemplo, (por ejemplo, `a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com`) y compruebe este valor en la **consola de AWS IoT **.
Para comprobar si ha utilizado el valor correcto:
1. En la **consola de AWS IoT **, seleccione **Administrar** y después **Cosas**.
1. Elija la cosa que creó para su aplicación de ejemplo (por ejemplo, **My\$1light\$1bulb**) y luego elija **Interactuar**.
Su punto de conexión se muestra en la sección ** HTTPS**. También debería ver un mensaje que dice: `This thing already appears to be connected.`
+
**Compruebe la activación del certificado**
Los certificados autentican el dispositivo con AWS IoT Core.
Para comprobar si su certificado está activo:
1. En la **consola de AWS IoT **, seleccione **Administrar** y después **Cosas**.
1. Elija la cosa que creó para su aplicación de ejemplo (por ejemplo, **My\$1light\$1bulb**) y luego elija **Seguridad**.
1. Seleccione el certificado y, a continuación, en la página de detalles del certificado, seleccione **Acciones**.
Si en la lista desplegable **Activar** no está disponible y solo puede elegir **Desactivar**, su certificado está activo. Si no es así, seleccione **Activar** y vuelva a ejecutar el programa de muestra.
Si el programa sigue sin ejecutarse, compruebe los nombres de los archivos de certificado en la carpeta `certs`.
+
**Compruebe la política adjunta al recurso de la cosa**
Si bien los certificados autentican el dispositivo, AWS IoT las políticas permiten que el dispositivo realice AWS IoT operaciones, como suscribirse o publicar en temas reservados de MQTT.
Para comprobar si se adjunta la política correcta:
1. Busque el certificado tal y como se describió anteriormente y, a continuación, elija **Políticas**.
1. Elija la política que se muestra y compruebe si describe las acciones `connect`, `subscribe`, `receive` y `publish` que permiten al dispositivo publicar y suscribirse a los temas reservados de MQTT.
Para ver un ejemplo de política, consulte [Paso 1: Crear una AWS IoT política para Device Shadow](shadow-provision-cloud.md#create-policy-shadow).
Si ves mensajes de error que indican que tienes problemas para conectarte AWS IoT, es posible que se deba a los permisos que utilizas para la política. Si ese es el caso, le recomendamos que comience con una política que proporcione acceso total a AWS IoT los recursos y, a continuación, vuelva a ejecutar el programa de muestra. Puede editar la política actual o elegir la política actual, seleccionar **Separar** y, a continuación, crear otra política que proporcione acceso completo y adjuntarla a su recurso principal. Más adelante, podrá restringir la política únicamente a las acciones y políticas que necesite para ejecutar el programa.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:*"
],
"Resource": "*"
}
]
}
```
+
**Compruebe la instalación de su SDK del dispositivo**
Si el programa sigue sin ejecutarse, puede volver a instalar el SDK del dispositivo para asegurarse de que su instalación del SDK es completa y correcta.
## Paso 4: Revisar los resultados y los siguientes pasos
**En este tutorial, ha aprendido a:**
+ Instale el software, las herramientas y el SDK de AWS IoT dispositivo necesarios para Python.
+ Entender cómo la aplicación de ejemplo, `shadow.py`, utiliza el protocolo MQTT para recuperar y actualizar el estado actual de la sombra.
+ Ejecute la aplicación de ejemplo para Device Shadows y observe la actualización del documento Shadow en la AWS IoT consola. También aprendió a solucionar cualquier problema y a corregir errores al ejecutar el programa.
**Siguientes pasos**
Ahora puede ejecutar la aplicación de ejemplo `shadow.py` y usar Device Shadows para controlar el estado. Puede observar las actualizaciones del documento sombra en la consola de AWS IoT y observar los eventos delta a los que responde la aplicación de muestra. Con el cliente de pruebas MQTT, puede suscribirse a los temas paralelos reservados y observar los mensajes que reciben los temas al ejecutar el programa de ejemplo. Para más información sobre cómo ejecutar este tutorial, consulte [Tutorial: Interactuar con Device Shadow mediante la aplicación de ejemplo y el cliente de pruebas MQTT](interact-lights-device-shadows.md).
# Tutorial: Interactuar con Device Shadow mediante la aplicación de ejemplo y el cliente de pruebas MQTT
Para interactuar con la aplicación de ejemplo `shadow.py`, introduzca un valor para el valor en el terminal `desired`. Por ejemplo, puede especificar colores que se parezcan a los semáforos AWS IoT y responder a la solicitud y actualizar los valores informados.
**En este tutorial, aprenderá a:**
+ Usar la aplicación de ejemplo `shadow.py` para especificar los estados deseados y actualizar el estado actual de la sombra.
+ Editar el documento Shadow para observar los eventos delta y cómo responde a ellos la aplicación de muestra `shadow.py`.
+ Utilizar el cliente de prueba MQTT para suscribirse a temas sombra y observar las actualizaciones cuando ejecute el programa de ejemplo.
**Antes de ejecutar este tutorial, debe disponer de lo siguiente:**
Configura tu Cuenta de AWS, configura tu dispositivo Raspberry Pi y crea una AWS IoT cosa y una política. También debe haber instalado el software necesario, el SDK del dispositivo y los archivos de certificado necesarios y haber ejecutado el programa de muestra en la terminal. Para obtener más información, consulte los tutoriales anteriores [Tutorial: Cómo preparar la Raspberry Pi para ejecutar la aplicación shadow](create-resources-shadow.md) y [Paso 1: ejecutar la aplicación de ejemplo shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows). Si aún no lo ha hecho, debe completar estos tutoriales.
**Topics**
+ [Paso 1: Actualizar los valores deseados y notificados mediante la aplicación de ejemplo `shadow.py`](#update-desired-shadow-sample)
+ [Paso 2: Ver los mensajes de la aplicación de ejemplo `shadow.py` en el cliente de prueba MQTT](#shadow-sample-view-msg)
+ [Paso 3: solucionar los errores de las interacciones de Device Shadow](#shadow-observe-messages-troubleshoot)
+ [Paso 4: Revisar los resultados y los siguientes pasos](#sample-shadow-review)
Para completar este tutorial se necesitan aproximadamente 45 minutos.
## Paso 1: Actualizar los valores deseados y notificados mediante la aplicación de ejemplo `shadow.py`
En el tutorial anterior[Paso 1: ejecutar la aplicación de ejemplo shadow.py](lightbulb-shadow-application.md#run-sample-application-shadows), aprendió a observar un mensaje publicado en el documento Shadow de la AWS IoT consola al introducir el valor deseado, tal y como se describe en la sección[Tutorial: Instalación del SDK del dispositivo y ejecución de la aplicación de ejemplo para Device Shadows](lightbulb-shadow-application.md).
En el ejemplo anterior, configuramos el color deseado en `yellow`. Después de introducir cada valor, el terminal le pide que introduzca otro valor `desired`. Si vuelve a introducir el mismo valor (`yellow`), la aplicación lo reconoce y le pide que introduzca un nuevo valor `desired`.
```
Enter desired value:
yellow
Local value is already 'yellow'.
Enter desired value:
```
Ahora, supongamos que has introducido el color`green`. AWS IoT responde a la solicitud y actualiza el `reported` valor a`green`. Así es como se produce la actualización cuando el estado `desired` es diferente del estado `reported`, lo que provoca un delta.
**Cómo simula la aplicación de ejemplo `shadow.py` las interacciones de Device Shadow:**
1. Introduzca un valor `desired` (por ejemplo`yellow`) en el terminal para publicar el estado deseado.
1. Como el estado `desired` es diferente del estado `reported` (por ejemplo, el color `green`), se produce un delta y la aplicación que está suscrita al delta recibe este mensaje.
1. La aplicación responde al mensaje y actualiza su estado al valor `desired`, `yellow`.
1. A continuación, la aplicación publica un mensaje de actualización con el nuevo valor registrado del estado del dispositivo, `yellow`.
A continuación se muestran los mensajes que se muestran en el terminal y que muestran cómo se publica la solicitud de actualización.
```
Enter desired value:
green
Changed local shadow value to 'green'.
Updating reported shadow value to 'green'...
Update request published.
Finished updating reported shadow value to 'green'.
```
En la AWS IoT consola, el documento oculto refleja el valor actualizado `green` para los `desired` campos `reported` y, además, el número de versión se incrementa en 1. Por ejemplo, si el número de la versión anterior se mostraba como 10, el número de la versión actual aparecerá como 11.
**nota**
Borrar una sombra no restablece el número de versión a 0. Verá que la versión sombra se incrementa en 1 cuando publique una solicitud de actualización o cree otra sombra con el mismo nombre.
**Editar el documento Shadow para observar los eventos delta**
La aplicación de ejemplo `shadow.py` también está suscrita a los eventos `delta` y responde cuando se produce un cambio en el valor `desired`. Por ejemplo, puede cambiar el valor `desired` por el color `red`. Para ello, en la AWS IoT consola, edite el documento oculto haciendo clic en **Editar** y, a continuación, establezca el `desired` valor `red` en en el JSON, manteniendo el `reported` valor en. `green` Antes de guardar los cambios, mantén abierto el terminal de la Raspberry Pi, ya que verás mensajes en el terminal cuando se produzca el cambio.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Tras guardar el nuevo valor, la aplicación de ejemplo `shadow.py` responde a este cambio y muestra mensajes en el terminal que indican el delta. A continuación, verá los siguientes mensajes debajo de la solicitud para introducir el valor `desired`.
```
Enter desired value:
Received shadow delta event.
Delta reports that desired value is 'red'. Changing local value...
Changed local shadow value to 'red'.
Updating reported shadow value to 'red'...
Finished updating reported shadow value to 'red'.
Enter desired value:
Update request published.
Finished updating reported shadow value to 'red'.
```
## Paso 2: Ver los mensajes de la aplicación de ejemplo `shadow.py` en el cliente de prueba MQTT
Puede utilizar el **cliente de prueba de MQTT** de la **consola de AWS IoT ** para supervisar los mensajes de MQTT que se transmiten a su Cuenta de AWS. Al suscribirse a los temas MQTT reservados utilizados por el servicio Device Shadow, puede observar los mensajes recibidos por los temas al ejecutar la aplicación de ejemplo.
Si aún no ha utilizado el cliente de pruebas de MQTT, puede revisar [Vea los mensajes MQTT con el cliente AWS IoT MQTT](view-mqtt-messages.md) Esto le ayudará a aprender a utilizar el **cliente de prueba de MQTT** de la **consola de AWS IoT ** para ver los mensajes MQTT a medida que pasan por el agente de mensajes.
1.
**Abra el cliente de prueba MQTT**
Abra el [cliente de prueba de MQTT en la consola de AWS IoT](https://console.aws.amazon.com//iot/home#/test) en una ventana nueva para poder observar los mensajes recibidos por los temas MQTT sin perder la configuración de su cliente de prueba de MQTT. El cliente de prueba MQTT no conserva las suscripciones ni los registros de mensajes si lo abandona para ir a otra página de la consola. Para esta sección del tutorial, puedes hacer que el documento Shadow que AWS IoT prefieras y el cliente de pruebas de MQTT se abran en ventanas separadas para observar más fácilmente la interacción con Device Shadows.
1.
**Suscribirse a los temas reservados de MQTT Shadow**
Puede utilizar el cliente de pruebas de MQTT para introducir los nombres de los temas reservados de MQTT de Device Shadow y suscribirse a ellos para recibir actualizaciones cuando ejecute la aplicación de ejemplo `shadow.py`. Para suscribirse al tema:
1. En el **cliente de prueba MQTT** de la **consola de AWS IoT **, seleccione **Suscribirse a un tema**.
1. En la sección de **filtros de temas**, introduzca: ***thingname*\$1aws/things/** /shadow/update/ \$1. Aquí `thingname` es el nombre del recurso que creó anteriormente (por ejemplo, `My_light_bulb`).
1. Mantenga los valores predeterminados para los ajustes de configuración adicionales y, a continuación, seleccione **Suscribirse**.
Si utiliza el comodín **\$1** en la suscripción al tema, podrá suscribirse a varios temas de MQTT al mismo tiempo y observar todos los mensajes que se intercambian entre el dispositivo y su Shadow en una sola ventana. Para obtener más información sobre los caracteres comodín y su uso, consulte [Temas de MQTT](topics.md).
1.
**Ejecute un programa de ejemplo `shadow.py` y observe los mensajes**
En la ventana de la línea de comandos de la Raspberry Pi, si ha desconectado el programa, vuelva a ejecutar la aplicación de ejemplo y mire los mensajes en el **cliente de pruebas MQTT** de la **consola de AWS IoT **.
1. Ejecute la siguiente orden para reiniciar el programa de muestra. Sustituya *your-iot-thing-name* y por *your-iot-endpoint* los nombres de AWS IoT lo que creó anteriormente (por ejemplo,`My_light_bulb`) y del punto final para interactuar con el dispositivo.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
A continuación, la aplicación de ejemplo `shadow.py` se ejecuta y recupera el estado de sombra actual. Si ha eliminado la sombra o borrado los estados actuales, el programa fija el valor actual a `off` y luego le pide que introduzca un valor `desired`.
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow document lacks 'color' property. Setting defaults...
Changed local shadow value to 'off'.
Updating reported shadow value to 'off'...
Update request published.
Finished updating reported shadow value to 'off'...
Enter desired value:
```
Por otro lado, si el programa se estaba ejecutando y lo reiniciaste, verás el último valor de color registrado en la terminal. **En el cliente de pruebas de MQTT, verá una actualización de los temas **\$1aws/things/ /shadow/get y *thingname* \$1aws/things/**/. *thingname* shadow/get/accepted**
Supongamos que el último color registrado fue `green`. **A continuación se muestra el contenido del archivo \$1aws/things//JSON. *thingname* shadow/get/accepted**
```
{
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
}
},
"version": 10,
"timestamp": 1620173908
}
```
1. Introduzca un valor `desired` en la terminal, por ejemplo `yellow`. La aplicación de ejemplo `shadow.py` responde y muestra los siguientes mensajes en el terminal que muestran el cambio en el valor `reported` a `yellow`.
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
En la opción **Cliente de prueba de MQTT** de la **consola de AWS IoT **, en **Suscripciones**, verá que los siguientes temas han recibido un mensaje:
+ **\$1aws/things/ *thingname* /shadow/update**: muestra que ambos valores cambian de color. `desired` `updated` `yellow`
+ **\$1aws/things/*thingname*/shadow/update/accepted: muestra los valores actuales de los estados y y sus** metadatos e información de versión. `desired` `reported`
+ **\$1aws/things/*thingname*/shadow/update/documents**: muestra los valores anteriores y actuales de los estados y sus metadatos e información de versión. `desired` `reported`
Como el documento **\$1aws/things/*thingname*/shadow/update/documents**también contiene información incluida en los otros dos temas, podemos revisarla para ver la información sobre el estado. El estado anterior muestra el valor informado establecido en `green`, sus metadatos e información de versión, y el estado actual, que muestra el valor informado actualizado a `yellow`.
```
{
"previous": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
}
},
"version": 10
},
"current": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
}
},
"version": 11
},
"timestamp": 1617297904
}
```
1. Ahora, si introduce otro valor `desired`, verá más cambios en los valores `reported` y en las actualizaciones de los mensajes que se reciben en estos temas. El número de versión también se incrementa en 1. Por ejemplo, si introduce el valor `green`, el estado anterior informa del valor `yellow` y el estado actual informa del valor `green`.
1.
**Editar el documento Shadow para observar los eventos delta**
Para observar los cambios en el tema delta, edite el documento paralelo en la consola de AWS IoT . Por ejemplo, puede cambiar el valor `desired` por el color `red`. Para ello, en la AWS IoT consola, selecciona **Editar** y, a continuación, establece el `desired` valor en rojo en el JSON, manteniendo el valor establecido en. `reported` `green` Antes de guardar el cambio, mantenga el terminal abierto ya que verá el mensaje delta informado en el terminal.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
La aplicación de ejemplo `shadow.py` responde a este cambio y muestra mensajes en el terminal que indican el delta. En el cliente de pruebas de MQTT, los temas `update` habrán recibido un mensaje que muestra los cambios en los valores `desired` y `reported`.
También verás que el tema **\$1aws/things//*thingname***ha recibido un mensaje. shadow/update/delta Para ver el mensaje, seleccione este tema, que aparece en **Suscripciones**.
```
{
"version": 13,
"timestamp": 1617318480,
"state": {
"color": "red"
},
"metadata": {
"color": {
"timestamp": 1617318480
}
}
}
```
## Paso 3: solucionar los errores de las interacciones de Device Shadow
Al ejecutar la aplicación de ejemplo Shadow, es posible que surjan problemas al observar las interacciones con el servicio Device Shadow.
Si el programa se ejecuta correctamente y le pide que introduzca un valor `desired`, debería poder observar las interacciones de Device Shadow mediante el documento Shadow y el cliente de pruebas MQTT, tal y como se ha descrito anteriormente. Sin embargo, si no puede ver las interacciones, puede comprobar lo siguiente:
+
**Comprueba el nombre de la cosa y su sombra en la consola AWS IoT**
Si no ve los mensajes en el documento Shadow, revise el comando y asegúrese de que coincide con el nombre de la cosa en la **consola de AWS IoT **. También puede comprobar si tiene una sombra clásica eligiendo su recurso cosa y luego eligiendo **Sombras**. Este tutorial se centra principalmente en las interacciones con la sombra clásica.
También puede confirmar que el dispositivo que utilizó está conectado a Internet. En la **consola de AWS IoT **, elija lo que ha creado anteriormente y, a continuación, seleccione **Interactuar**. En la página de detalles de la cosa, debería ver un mensaje que dice: `This thing already appears to be connected.`
+
**Compruebe los temas reservados de MQTT a los que se ha suscrito**
Si los mensajes no aparecen en el cliente de prueba de MQTT, compruebe si los temas a los que se ha suscrito tienen el formato correcto. Los temas de Device Shadow de MQTT tienen el formato **\$1aws/things/ *thingname* /shadow/** y pueden tener `update``get`, o `delete` seguir este formato en función de las acciones que desee realizar en la sombra. **En este tutorial se utiliza el tema **\$1aws/things/ *thingname* /shadow/ \$1**, así que asegúrese de haberlo introducido correctamente al suscribirse al tema en la sección de filtro de temas del cliente de prueba.**
Al introducir el nombre del tema, asegúrate de que *thingname* es el mismo que el nombre del tema que has creado anteriormente. AWS IoT También puede suscribirse a otros temas de MQTT para comprobar si la actualización se ha realizado correctamente. Por ejemplo, puedes suscribirte al tema **\$1aws/things/*thingname*/shadow/update/rejected**para recibir un mensaje cada vez que falle una solicitud de actualización y así poder depurar los problemas de conexión. Para más información sobre los temas reservados, consulte [Temas de sombra](reserved-topics.md#reserved-topics-shadow) y [Temas MQTT de sombra de dispositivo](device-shadow-mqtt.md).
## Paso 4: Revisar los resultados y los siguientes pasos
**En este tutorial, ha aprendido a:**
+ Usar la aplicación de ejemplo `shadow.py` para especificar los estados deseados y actualizar el estado actual de la sombra.
+ Editar el documento Shadow para observar los eventos delta y cómo responde a ellos la aplicación de muestra `shadow.py`.
+ Utilizar el cliente de prueba MQTT para suscribirse a temas sombra y observar las actualizaciones cuando ejecute el programa de ejemplo.
**Siguientes pasos**
Puede suscribirse a otros temas reservados de MQTT para ver las actualizaciones de la aplicación oculta. Por ejemplo, si solo te suscribes al tema **\$1aws/things/*thingname*/shadow/update/accepted**, solo verás la información sobre el estado actual cuando la actualización se realice correctamente.
También puede suscribirse a temas sombra adicionales para depurar problemas o aprender más sobre las interacciones de la Sombra de Dispositivos y también depurar cualquier problema con las interacciones de la Sombra de Dispositivos. Para obtener más información, consulte [Temas de sombra](reserved-topics.md#reserved-topics-shadow) y [Temas MQTT de sombra de dispositivo](device-shadow-mqtt.md).
También puedes optar por ampliar tu aplicación utilizando sombras con nombre o utilizando hardware adicional conectado a la Raspberry Pi para observar los cambios en su estado mediante los mensajes enviados desde el LEDs terminal.
Para obtener más información sobre el servicio Device Shadow y el uso del servicio en dispositivos, aplicaciones y servicios, consulte [AWS IoT Servicio Device Shadow](iot-device-shadows.md), [Uso de sombras en dispositivos](device-shadow-comms-device.md), y [Uso de sombras en aplicaciones y servicios](device-shadow-comms-app.md).
# Tutorial: Crear un autorizador personalizado para AWS IoT Core
En este tutorial se muestran los pasos para crear, validar y utilizar la autenticación personalizada mediante la AWS CLI. Si lo desea, con este tutorial, puede utilizar Postman para enviar datos a AWS IoT Core mediante la API de publicación HTTP.
En este tutorial se muestra cómo crear una función de Lambda de ejemplo que implemente la lógica de autorización y autenticación y un autorizador personalizado mediante la llamada a **create-authorizer** con la firma de token habilitada. A continuación, se valida el autorizador mediante la API de publicación HTTP y**test-invoke-authorizer**, por último, se pueden enviar datos a él AWS IoT Core mediante la API de publicación HTTP para un tema de prueba de MQTT. La solicitud de ejemplo especificará el autorizador que se va a invocar mediante el `x-amz-customauthorizer-name` encabezado y pasará los encabezados de la solicitud y pasará los encabezados de la token-key-name solicitud. `x-amz-customauthorizer-signature`
**Lo que aprenderá en este tutorial:**
+ Cómo crear una función de Lambda para que sea un controlador de autorizador personalizado.
+ ¿Cómo crear un autorizador personalizado con la firma de token habilitada AWS CLI
+ Cómo probar su autorizador personalizado con el comando **test-invoke-authorizer**.
+ Cómo publicar un tema de MQTT con [Postman](https://www.postman.com/) y validar la solicitud con su autorizador personalizado.
Para completar este tutorial se necesitan aproximadamente 60 minutos.
**Topics**
+ [Paso 1: crear una función de Lambda para su autorizador personalizado](#custom-auth-tutorial-define)
+ [Paso 2: crear un par de claves pública y privada para su autorizador personalizado](#custom-auth-tutorial-keys)
+ [Paso 3: crear un recurso autorizador personalizado y su autorización](#custom-auth-tutorial-authorizer)
+ [Paso 4: Pruebe el autorizador llamando test-invoke-authorizer](#custom-auth-tutorial-test)
+ [Paso 5: Probar la publicación del mensaje MQTT utilizando Postman](#custom-auth-tutorial-postman)
+ [Paso 6: Visualizar los mensajes en el cliente de prueba MQTT](#custom-auth-tutorial-testclient)
+ [Paso 7: Revisar los resultados y los siguientes pasos](#custom-auth-tutorial-review)
+ [Paso 8: Eliminación](#custom-auth-tutorial-cleanup)
**Antes de empezar este tutorial, asegúrese de que tiene:**
+
**[Configurar Cuenta de AWS](setting-up.md)**
Necesitarás tu AWS IoT consola Cuenta de AWS y tu consola para completar este tutorial.
La cuenta que utiliza para este tutorial funciona mejor cuando incluye al menos estas políticas administradas de AWS :
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor)
**importante**
Las políticas de IAM utilizadas en este tutorial son más permisivas de lo que deberían en una implementación de producción. En un entorno de producción, asegúrese de que sus políticas de cuentas y recursos concedan solo los permisos necesarios.
Cuando cree políticas de IAM para la producción, determine qué acceso necesitan los usuarios y los roles y, a continuación, diseñe las políticas que les permitan realizar solo esas tareas.
Para obtener más información, consulte [Prácticas recomendadas de seguridad en IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/best-practices.html).
+
**Instaló la AWS CLI**
Para obtener información acerca de cómo instalar el AWS CLI, consulte [Instalación de la AWS CLI](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-install.html). Este tutorial requiere una AWS CLI versión `aws-cli/2.1.3 Python/3.7.4 Darwin/18.7.0 exe/x86_64` o posterior.
+
**Herramientas de OpenSSL**
Los ejemplos de este tutorial utilizan [LibreSSL 2.6.5](https://www.libressl.org/). También puede usar las herramientas de [OpenSSL v1.1.1i](https://www.openssl.org/) para este tutorial.
+
**Ha revisado la descripción general de [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)**
Si no lo ha utilizado AWS Lambda antes, consulte [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)[Introducción a Lambda](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) para conocer sus términos y conceptos.
+
**Ha revisado cómo crear solicitudes en Postman**
Para obtener más información, consulte [Creación de solicitudes](https://learning.postman.com/docs/sending-requests/requests/).
+
**Ha eliminado los autorizadores personalizados del tutorial anterior**
Solo Cuenta de AWS puede configurar un número limitado de autorizadores personalizados a la vez. Para obtener información sobre la eliminación de un autorizador personalizado, consulte [Paso 8: Eliminación](#custom-auth-tutorial-cleanup).
## Paso 1: crear una función de Lambda para su autorizador personalizado
La autenticación personalizada AWS IoT Core utiliza los [recursos de autorización que](https://docs.aws.amazon.com//iot/latest/apireference/API_AuthorizerDescription.html) usted crea para autenticar y autorizar a los clientes. La función que creará en esta sección autentica y autoriza a los clientes a medida que se conectan a los recursos y acceden a AWS IoT Core ellos. AWS IoT
La función de Lambda hace lo siguiente:
+ Si una solicitud procede de **test-invoke-authorizer**, devuelve una política de IAM con una acción `Deny`.
+ Si una solicitud procede de Postman mediante HTTP y el parámetro `actionToken` tiene un valor de `allow`, devuelve una política de IAM con una acción `Allow`. En caso contrario, devuelve una política de IAM con una acción `Deny`.
**Para crear la función de Lambda para su autorizador personalizado**
1. En la consola de [Lambda](https://console.aws.amazon.com//lambda/home#), abra [Funciones](https://console.aws.amazon.com//lambda/home#/functions).
1. Seleccione **Creación de función**.
1. Confirme que se ha seleccionado **Crear desde cero**.
1. En **Basic information**:
1. Bajo **Function name (Nombre de función)**, escriba **custom-auth-function**.
1. En **Tiempo de ejecución**, confirme **Node.js 18.x**.
1. Elija **Create function (Crear función)**.
Lambda crea una función Node.js y un [rol de ejecución](https://docs.aws.amazon.com//lambda/latest/dg/lambda-intro-execution-role.html) que otorga a la función permiso para cargar los registros. La función Lambda asume la función de ejecución cuando se invoca la función y la utiliza para crear credenciales para el AWS SDK y leer los datos de las fuentes de eventos.
1. Para ver el código y la configuración de la función en el [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)editor, elija **custom-auth-function**en la ventana del diseñador y, a continuación, elija **index.js** en el panel de navegación del editor.
Para lenguajes de scripting como Node.js, Lambda incluye una función básica que devuelve una respuesta de éxito. Puede utilizar el editor de [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html) para editar su función siempre que su código fuente no supere los 3 MB.
1. Reemplace el código **index.js** en el editor por el siguiente código:
```
// A simple Lambda function for an authorizer. It demonstrates
// How to parse a CLI and Http password to generate a response.
export const handler = async (event, context, callback) => {
//Http parameter to initiate allow/deny request
const HTTP_PARAM_NAME='actionToken';
const ALLOW_ACTION = 'Allow';
const DENY_ACTION = 'Deny';
//Event data passed to Lambda function
var event_str = JSON.stringify(event);
console.log('Complete event :'+ event_str);
//Read protocolData from the event json passed to Lambda function
var protocolData = event.protocolData;
console.log('protocolData value---> ' + protocolData);
//Get the dynamic account ID from function's ARN to be used
// as full resource for IAM policy
var ACCOUNT_ID = context.invokedFunctionArn.split(":")[4];
console.log("ACCOUNT_ID---"+ACCOUNT_ID);
//Get the dynamic region from function's ARN to be used
// as full resource for IAM policy
var REGION = context.invokedFunctionArn.split(":")[3];
console.log("REGION---"+REGION);
//protocolData data will be undefined if testing is done via CLI.
// This will help to test the set up.
if (protocolData === undefined) {
//If CLI testing, pass deny action as this is for testing purpose only.
console.log('Using the test-invoke-authorizer cli for testing only');
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
} else{
//Http Testing from Postman
//Get the query string from the request
var queryString = event.protocolData.http.queryString;
console.log('queryString values -- ' + queryString);
/* global URLSearchParams */
const params = new URLSearchParams(queryString);
var action = params.get(HTTP_PARAM_NAME);
if(action!=null && action.toLowerCase() === 'allow'){
callback(null, generateAuthResponse(ALLOW_ACTION,ACCOUNT_ID,REGION));
}else{
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
}
}
};
// Helper function to generate the authorization IAM response.
var generateAuthResponse = function(effect,ACCOUNT_ID,REGION) {
var full_resource = "arn:aws:iot:"+ REGION + ":" + ACCOUNT_ID + ":*";
console.log("full_resource---"+full_resource);
var authResponse = {};
authResponse.isAuthenticated = true;
authResponse.principalId = 'principalId';
var policyDocument = {};
policyDocument.Version = '2012-10-17';
policyDocument.Statement = [];
var statement = {};
statement.Action = 'iot:*';
statement.Effect = effect;
statement.Resource = full_resource;
policyDocument.Statement[0] = statement;
authResponse.policyDocuments = [policyDocument];
authResponse.disconnectAfterInSeconds = 3600;
authResponse.refreshAfterInSeconds = 600;
console.log('custom auth policy function called from http');
console.log('authResponse --> ' + JSON.stringify(authResponse));
console.log(authResponse.policyDocuments[0]);
return authResponse;
}
```
1. Elija **Implementar**.
1. Después de que los **cambios implementados** aparezcan encima del editor:
1. Desplácese hasta la sección **Información general de la función** situada encima del editor.
1. Copie el **ARN de la función** y guárdelo para utilizarlo más adelante en este tutorial.
1. Comprobación de la función de .
1. Elija la pestaña **Prueba**.
1. Utilizando la configuración predeterminada de la prueba, seleccione **Invocar**.
1. Si la prueba se ha realizado correctamente, abra la vista **Detalles** en **Resultados de la ejecución**. Debería ver el documento de política que devolvió la función.
Si la prueba falló o no ve ningún documento de política, revise el código para encontrar y corregir los errores.
## Paso 2: crear un par de claves pública y privada para su autorizador personalizado
Su autorizador personalizado requiere una clave pública y privada para autenticarlo. Los comandos de esta sección utilizan herramientas OpenSSL para crear este par de claves.
**Para crear un par de claves pública y privada para su autorizador personalizado**
1. Cree el archivo de clave privada.
```
openssl genrsa -out private-key.pem 4096
```
1. Verifique el archivo de clave privada que acaba de crear.
```
openssl rsa -check -in private-key.pem -noout
```
Si el comando no muestra ningún error, el archivo de clave privada es válido.
1. Cree el archivo de clave pública.
```
openssl rsa -in private-key.pem -pubout -out public-key.pem
```
1. Verifique el archivo de clave pública.
```
openssl pkey -inform PEM -pubin -in public-key.pem -noout
```
Si el comando no muestra ningún error, el archivo de clave pública es válido.
## Paso 3: crear un recurso autorizador personalizado y su autorización
El autorizador AWS IoT personalizado es el recurso que une todos los elementos creados en los pasos anteriores. En esta sección, creará un recurso de autorizador personalizado y le dará permiso para ejecutar la función de Lambda que creó anteriormente. Puede crear un recurso de autorización personalizado mediante la AWS IoT consola AWS CLI, la o la AWS API.
Para este tutorial, solo necesita crear un autorizador personalizado. En esta sección se describe cómo crear mediante la AWS IoT consola y el AWS CLI, de modo que pueda utilizar el método que le resulte más conveniente. No hay diferencia entre los recursos del autorizador personalizado creados por uno u otro método.
### Creación de un recurso de autorizador personalizado
**Elija una de estas opciones para crear su recurso de autorizador personalizado**
+ [Cree un autorizador personalizado mediante la consola AWS IoT](#create-custom-auth-in-console)
+ [Creación de un autorizador personalizado utilizando la consola de AWS CLI](#create-custom-auth-in-cli)
**Para crear un autorizador personalizado (consola)**
1. Abra la [página del autorizador personalizado de la AWS IoT consola](https://console.aws.amazon.com//iot/home#/authorizerhub) y elija **Crear** autorizador.
1. En **Crear un autorizador**:
1. En **Nombre del autorizador**, introduzca **my-new-authorizer**.
1. En **Estado del autorizador**, marque **Activo**.
1. En **Función del autorizador**, elija la función de Lambda que creó anteriormente.
1. En **Validación del token - opcional**:
1. Active **Validación del token**.
1. En **Nombre de la clave del token**, introduzca **tokenKeyName**.
1. Elija **Agregar clave**.
1. En **Nombre de la clave**, introduzca **FirstKey**.
1. En **Clave pública**, introduzca el contenido del archivo `public-key.pem`. Asegúrese de incluir las líneas del archivo con `-----BEGIN PUBLIC KEY-----` y `-----END PUBLIC KEY-----`, y no agregue ni elimine ningún salto de línea, retorno de carro u otros caracteres del contenido del archivo. La cadena que introduzca debe parecerse a la de este ejemplo.
```
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----
```
1. Elija **Crear autorizador**.
1. Si se creó el recurso de autorizador personalizado, verá la lista de autorizadores personalizados y su nuevo autorizador personalizado debería aparecer en la lista y podrá continuar con la siguiente sección para probarlo.
Si ve un error, revíselo e intente crear de nuevo su autorizador personalizado y vuelva a comprobar las entradas. Tenga en cuenta que cada recurso de autorizador personalizado debe tener un nombre único.
**Para crear un autorizador personalizado (AWS CLI)**
1. Sustituya sus valores por `authorizer-function-arn` y `token-signing-public-keys`, y ejecute el siguiente comando:
```
aws iot create-authorizer \
--authorizer-name "my-new-authorizer" \
--token-key-name "tokenKeyName" \
--status ACTIVE \
--no-signing-disabled \
--authorizer-function-arn "arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function" \
--token-signing-public-keys FirstKey="-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----"
```
**Donde:**
+ El valor `authorizer-function-arn` es el nombre de recurso de Amazon (ARN) de la función de Lambda que creó para su autorizador personalizado.
+ El valor `token-signing-public-keys` incluye el nombre de la clave, **FirstKey**, y el contenido del archivo `public-key.pem`. Asegúrese de incluir las líneas del archivo con `-----BEGIN PUBLIC KEY-----` y `-----END PUBLIC KEY-----`, y no agregue ni elimine ningún salto de línea, retorno de carro u otros caracteres del contenido del archivo.
Nota: Tenga cuidado al introducir la clave pública, ya que cualquier alteración de su valor la inutilizará.
1. Si se crea el autorizador personalizado, el comando devuelve el nombre y el ARN del nuevo recurso, como se muestra a continuación.
```
{
"authorizerName": "my-new-authorizer",
"authorizerArn": "arn:aws:iot:Region:57EXAMPLE833:authorizer/my-new-authorizer"
}
```
Guarde el valor `authorizerArn` para utilizarlo en el siguiente paso.
Recuerde que cada recurso de autorizador personalizado debe tener un nombre único.
### Autorización del recurso autorizador personalizado
En esta sección, concederá permiso al recurso de autorizador personalizado que acaba de crear para ejecutar la función de Lambda. Para conceder el permiso, puede utilizar el comando de la CLI [add-permission](https://docs.aws.amazon.com//cli/latest/reference/lambda/add-permission.html).
**Conceda permiso a su función Lambda mediante el AWS CLI**
1. Después de insertar sus valores, introduzca el siguiente comando. Tenga en cuenta que el valor `statement-id` debe ser único. Reemplace `Id-1234` por otro valor si ha ejecutado este tutorial antes o si obtiene un error `ResourceConflictException`.
```
aws lambda add-permission \
--function-name "custom-auth-function" \
--principal "iot.amazonaws.com" \
--action "lambda:InvokeFunction" \
--statement-id "Id-1234" \
--source-arn authorizerArn
```
1. Si el comando tiene éxito, devuelve una declaración de permiso, como la de este ejemplo. Puede continuar con la siguiente sección para probar el autorizador personalizado.
```
{
"Statement": "{\"Sid\":\"Id-1234\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"iot.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\"}}}"
}
```
Si el comando no tiene éxito, devuelve un error, como en este ejemplo. Tendrá que revisar y corregir el error antes de continuar.
```
An error occurred (AccessDeniedException) when calling the AddPermission operation: User: arn:aws:iam::57EXAMPLE833:user/EXAMPLE-1 is not authorized to perform: lambda:AddPer
mission on resource: arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function
```
## Paso 4: Pruebe el autorizador llamando test-invoke-authorizer
Con todos los recursos definidos, en esta sección llamarás test-invoke-authorizer desde la línea de comandos para probar la aprobación de la autorización.
Tenga en cuenta que al invocar el autorizador desde la línea de comandos, `protocolData` no está definido, por lo que el autorizador siempre devolverá un documento DENY. Sin embargo, esta prueba confirma que su autorizador personalizado y la función de Lambda están configurados correctamente, aunque no pruebe por completo la función de Lambda.
**Para probar su autorizador personalizado y su función Lambda mediante el AWS CLI**
1. En el directorio que tiene el archivo `private-key.pem` que creó en un paso anterior, ejecute el siguiente comando.
```
echo -n "tokenKeyValue" | openssl dgst -sha256 -sign private-key.pem | openssl base64 -A
```
Este comando crea una cadena de firma que se utilizará en el siguiente paso. La cadena de firma tiene este aspecto:
```
dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mn
VB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeeh
bQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjj
szEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29V
QJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuX
f3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+K
EWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFH
xRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Copie esta cadena de firma para utilizarla en el siguiente paso. Tenga cuidado de no incluir ningún carácter de más ni omitir ninguno.
1. En este comando, reemplace el valor `token-signature` por la cadena de firma del paso anterior y ejecute este comando para probar su autorizador.
```
aws iot test-invoke-authorizer \
--authorizer-name my-new-authorizer \
--token tokenKeyValue \
--token-signature dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mnVB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeehbQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjjszEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29VQJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuXf3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+KEWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFHxRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Si el comando tiene éxito, devuelve la información generada por su función de autorización personalizada, como en este ejemplo.
```
{
"isAuthenticated": true,
"principalId": "principalId",
"policyDocuments": [
"{\"Version\":\"2012-10-17\", \"Statement\":[{\"Action\":\"iot:*\",\"Effect\":\"Deny\",\"Resource\":\"arn:aws:iot:Region:57EXAMPLE833:*\"}]}"
],
"refreshAfterInSeconds": 600,
"disconnectAfterInSeconds": 3600
}
```
Si el comando devuelve un error, revise el error y vuelva a comprobar los comandos que ha utilizado en esta sección.
## Paso 5: Probar la publicación del mensaje MQTT utilizando Postman
1. Para obtener el punto de conexión de datos de su dispositivo desde la línea de comandos, llame a [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html), tal y como se muestra aquí.
```
aws iot describe-endpoint --output text --endpoint-type iot:Data-ATS
```
Guarde esta dirección para utilizarla como *device\$1data\$1endpoint\$1address* en un paso posterior.
1. Abra una nueva ventana de Postman y cree una nueva petición HTTP POST.
1. Desde su ordenador, abra la aplicación Postman.
1. En Postman, en el menú **File**, seleccione **New...**.
1. En el cuadro de diálogo **New**, seleccione **Request**.
1. En Save Request,
1. En **Request Name**, introduzca **Custom authorizer test request**.
1. En **Select a collection or folder to save to:** elija o cree una colección en la que guardar esta solicitud.
1. Selecciona **Guardar en *collection\$1name***.
1. Cree la solicitud POST para probar su autorizador personalizado.
1. En el selector de método de solicitud situado junto al campo URL, elija **POST**.
1. En el campo URL, cree la URL de su solicitud utilizando la siguiente URL con el comando *device\$1data\$1endpoint\$1address* from the [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) en un paso anterior.
```
https://device_data_endpoint_address:443/topics/test/cust-auth/topic?qos=0&actionToken=allow
```
Tenga en cuenta que esta URL incluye el parámetro de consulta `actionToken=allow` que indicará a su función de Lambda que devuelva un documento normativo que permita el acceso a AWS IoT. Después de introducir la URL, los parámetros de consulta también aparecen en la pestaña **Params** de Postman.
1. En la pestaña **Auth**, en el campo **Type**, elija **No Auth**.
1. En la pestaña Headers:
1. Si hay alguna clave de **host** que esté marcada, desmárquela.
1. Al final de la lista de encabezados, agregue estos nuevos y confirme que están marcados. Sustituya el **Host** valor por el *device\$1data\$1endpoint\$1address* suyo y el **x-amz-customauthorizer-signature** valor por la cadena de firma que utilizó con el **test-invoke-authorize** comando en la sección anterior.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/custom-auth-tutorial.html)
1. En la pestaña Body:
1. En el cuadro de opciones de formato de datos, elija **Raw**.
1. En la lista de tipos de datos, elija **JavaScript**.
1. En el campo de texto, introduzca esta carga de mensaje JSON para su mensaje de prueba:
```
{
"data_mode": "test",
"vibration": 200,
"temperature": 40
}
```
1. Elija **Send** para enviar la solicitud.
Si la solicitud se ha realizado correctamente, devuelve:
```
{
"message": "OK",
"traceId": "ff35c33f-409a-ea90-b06f-fbEXAMPLE25c"
}
```
Si la respuesta es correcta, indica que su autorizador personalizado permitió la conexión AWS IoT y que el mensaje de prueba se entregó a Broker In AWS IoT Core.
Si devuelve un error, revisa el mensaje de error*device\$1data\$1endpoint\$1address*, la cadena de firma y los demás valores del encabezado.
Guarde esta solicitud en Postman para utilizarla en la siguiente sección.
## Paso 6: Visualizar los mensajes en el cliente de prueba MQTT
En el paso anterior, enviaste mensajes de un dispositivo AWS IoT simulado a través de Postman. La respuesta correcta indicó que su autorizador personalizado permitió la conexión a AWS IoT y que el mensaje de prueba fue entregado al agente en AWS IoT Core. En esta sección, utilizará el cliente de prueba MQTT de la AWS IoT consola para ver el contenido del mensaje de la misma forma que lo harían otros dispositivos y servicios.
**Para ver los mensajes de prueba autorizados por su autorizador personalizado**
1. En la AWS IoT consola, abra el cliente de [prueba de MQTT](https://console.aws.amazon.com//iot/home#/test).
1. En la pestaña **Suscribirse al tema**, en **Filtro de temas**, introduzca **test/cust-auth/topic**, que es el tema de mensaje utilizado en el ejemplo de Postman de la sección anterior.
1. Elija **Suscribirse**.
Mantenga esta ventana visible para el siguiente paso.
1. En Postman, en la solicitud que creó para la sección anterior, elija **Send**.
Revise la respuesta para asegurarse de que se ha realizado correctamente. Si no es así, solucione el error, tal y como se describe en la sección anterior.
1. En el **cliente de prueba de MQTT** debería ver una nueva entrada que muestra el tema del mensaje y, si está expandido, la carga del mensaje de la solicitud que envió desde Postman.
Si no ve sus mensajes en el **cliente de prueba MQTT**, he aquí algunas cosas que debe comprobar:
+ Asegúrese de que su solicitud de Postman ha sido devuelta correctamente. Si AWS IoT rechaza la conexión y devuelve un error, el mensaje de la solicitud no se pasa al intermediario de mensajes.
+ Asegúrese de que la Cuenta de AWS URL Región de AWS utilizada para abrir la AWS IoT consola sea la misma que la que utiliza en la URL de Postman.
+ Asegúrese de usar el punto de conexión adecuado para el autorizador personalizado. Es posible que el punto de conexión predeterminado de IoT no admita el uso de autorizadores personalizados con funciones de Lambda. En su lugar, puede usar las configuraciones de dominio para definir un nuevo punto de conexión y, a continuación, especificarlo para el autorizador personalizado.
+ Asegúrese de que ha introducido correctamente el tema en el **cliente de prueba MQTT**. El filtro del tema distingue entre mayúsculas y minúsculas. En caso de duda, también puedes suscribirte al **\$1** tema, que contiene todos los mensajes de MQTT que pasan por el intermediario de mensajes Cuenta de AWS y que Región de AWS se utilizan para abrir la consola. AWS IoT
## Paso 7: Revisar los resultados y los siguientes pasos
**En este tutorial:**
+ Ha creado una función de Lambda para que sea un controlador de autorizador personalizado.
+ ha creado un autorizador personalizado con la firma de token habilitada.
+ Ha probado su autorizador personalizado con el comando **test-invoke-authorizer**.
+ Ha publicado un tema de MQTT con [Postman](https://www.postman.com/) y validar la solicitud con su autorizador personalizado.
+ Ha utilizado el **cliente de prueba de MQTT** para ver los mensajes enviados desde su prueba de Postman.
**Siguientes pasos**
Después de enviar algunos mensajes desde Postman para verificar que el autorizador personalizado funciona, pruebe a experimentar para ver cómo afecta a los resultados cambiar diferentes aspectos de este tutorial. He aquí algunos ejemplos para empezar.
+ Cambie la cadena de firma para que deje de ser válida y vea cómo se gestionan los intentos de conexión no autorizados. Debería obtener una respuesta de error, como esta, y el mensaje no debería aparecer en el **cliente de prueba MQTT**.
```
{
"message": "Forbidden",
"traceId": "15969756-a4a4-917c-b47a-5433e25b1356"
}
```
+ Para obtener más información sobre cómo detectar los errores que pueden producirse al desarrollar y utilizar AWS IoT reglas, consulte. [Monitorización AWS IoT](monitoring_overview.md)
## Paso 8: Eliminación
Si desea repetir este tutorial, puede que tenga que eliminar algunos de sus autorizadores personalizados. Solo Cuenta de AWS puede configurar un número limitado de autorizadores personalizados a la vez y puede obtener uno `LimitExceededException` si intenta añadir uno nuevo sin eliminar uno existente.
**Para eliminar un autorizador personalizado (consola)**
1. Abre la [página de autorizadores personalizados de la AWS IoT consola](https://console.aws.amazon.com//iot/home#/authorizerhub) y, en la lista de autorizadores personalizados, busca el autorizador personalizado que deseas eliminar.
1. Abra la página de detalles del autorizador personalizado y, en el menú **Acciones**, seleccione **Editar**.
1. Desmarque la casilla **Activar autorizador** y, a continuación, seleccione **Actualizar**.
No puede eliminar un autorizador personalizado mientras esté activo.
1. En la página de detalles del autorizador personalizado, abra el menú **Acciones** y seleccione **Eliminar**.
**Para eliminar un autorizador personalizado (AWS CLI)**
1. Enumere los autorizadores personalizados que tiene instalados y busque el nombre del autorizador personalizado que desea eliminar.
```
aws iot list-authorizers
```
1. Establezca el autorizador personalizado como `inactive` ejecutando este comando después de sustituir `Custom_Auth_Name` por el `authorizerName` del autorizador personalizado para eliminar.
```
aws iot update-authorizer --status INACTIVE --authorizer-name Custom_Auth_Name
```
1. Elimine el autorizador personalizado ejecutando este comando después de sustituir `Custom_Auth_Name` por el `authorizerName` del autorizador personalizado para eliminar.
```
aws iot delete-authorizer --authorizer-name Custom_Auth_Name
```
# Tutorial: Monitorización de la humedad del suelo con una AWS IoT Raspberry Pi
En este tutorial se muestra cómo utilizar una [Raspberry Pi](https://www.raspberrypi.org/), un sensor de humedad, y cómo AWS IoT controlar el nivel de humedad del suelo de una planta de interior o de un jardín. La Raspberry Pi ejecuta un código que lee el nivel de humedad y la temperatura del sensor y, a continuación, envía los datos a AWS IoT. Creas una regla AWS IoT que envía un correo electrónico a una dirección suscrita a un tema de Amazon SNS cuando el nivel de humedad cae por debajo de un umbral.
**nota**
Es posible que este tutorial no esté actualizado. Es posible que algunas referencias hayan sido reemplazadas desde que se publicó originalmente este tema.
**Contents**
+ [Requisitos previos](#iot-moisture-prereqs)
+ [Con AWS IoT figuración](iot-moisture-setup.md)
+ [Paso 1: Crear la AWS IoT política](iot-moisture-policy.md)
+ [Paso 2: Crea la AWS IoT cosa, el certificado y la clave privada](iot-moisture-create-thing.md)
+ [Paso 3: Crear un tema y una suscripción a Amazon SNS](iot-moisture-create-sns-topic.md)
+ [Paso 4: Crea una AWS IoT regla para enviar un correo electrónico](iot-moisture-create-rule.md)
+ [Configuración del dispositivo Raspberry Pi y el sensor de humedad](iot-moisture-raspi-setup.md)
## Requisitos previos
Para completar este tutorial, se necesita lo siguiente:
+ Y. Cuenta de AWS
+ Un usuario de IAM con permisos de administrador.
+ Un equipo de desarrollo con Windows, macOS, Linux o Unix para obtener acceso a la [consola de AWS IoT](https://console.aws.amazon.com/iot/home).
+ Una [Raspberry Pi 3B o 4B](https://www.raspberrypi.com/products/) ejecutando el último [Raspberry Pi OS](https://www.raspberrypi.com/software/operating-systems/). Para ver instrucciones de instalación, consulte [Instalación de un sistema operativo](https://www.raspberrypi.com/documentation/computers/getting-started.html#installing-the-operating-system) en el sitio web de Rasberry Pi.
+ Un monitor, teclado, ratón y conexión de red wifi o Ethernet para su Raspberry Pi.
+ Un sensor de humedad compatible con Raspberry Pi. El sensor utilizado en este tutorial es un [sensor de humedad capacitivo Adafruit STEMMA I2C](https://www.adafruit.com/product/4026) con un [conector hembra de 4 clavijas JST](https://www.adafruit.com/product/3950).
# Con AWS IoT figuración
Para completar este tutorial, debe crear los siguientes recursos. Para conectar un dispositivo AWS IoT, se crea una cosa de IoT, un certificado de dispositivo y una AWS IoT política.
+ Cualquier AWS IoT cosa.
Un objeto representa un dispositivo físico (en este caso, su Rasberry Pi) e incluye metadatos estáticos sobre el dispositivo.
+ Un certificado de dispositivo.
Todos los dispositivos deben tener un certificado de dispositivo para conectarse a AWS IoT y autenticarse con el mismo.
+ Una AWS IoT política.
Cada certificado de dispositivo tiene una o más AWS IoT políticas asociadas. Estas políticas determinan a qué AWS IoT recursos puede acceder el dispositivo.
+ Un certificado de CA AWS IoT raíz.
Los dispositivos y otros clientes utilizan un certificado de CA AWS IoT raíz para autenticar el AWS IoT servidor con el que se comunican. Para obtener más información, consulte [Autenticación del servidor](server-authentication.md).
+ Una AWS IoT regla.
Una regla incluye una consulta y una o varias acciones de regla. La consulta extrae datos de los mensajes del dispositivo para determinar si los datos de los mensajes deben procesarse. La acción de regla especifica qué hacer si los datos coinciden con la consulta.
+ Un tema de Amazon SNS y una suscripción a un tema.
La regla escucha los datos de humedad del dispositivo Raspberry Pi. Si el valor está por debajo de un umbral, envía un mensaje al tema de Amazon SNS. Amazon SNS envía ese mensaje a todas las direcciones de correo electrónico suscritas al tema.
# Paso 1: Crear la AWS IoT política
Crea una AWS IoT política que permita a tu Raspberry Pi conectarse y enviar mensajes a AWS IoT.
1. En la [consola de AWS IoT](https://console.aws.amazon.com/iot), si aparece un botón **Empezar**, elíjalo. De lo contrario, en el panel de navegación, expanda **Seguridad** y, a continuación, elija **Políticas**.
1. Si aparece el cuadro de diálogo **Aún no tiene ninguna política**, elija **Crear una política**. De lo contrario, seleccione **Crear**.
1. Introduzca un nombre para la AWS IoT política (por ejemplo,**MoistureSensorPolicy**).
1. En la sección **Añadir instrucciones**, sustituya la política existente por el siguiente JSON. Sustituya *region* y *account* por su Cuenta de AWS número Región de AWS and.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/RaspberryPi"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:us-east-1:123456789012:thing/RaspberryPi"
}
]
}
```
1. Seleccione **Crear**.
# Paso 2: Crea la AWS IoT cosa, el certificado y la clave privada
Crea una cosa en el AWS IoT registro que represente tu Raspberry Pi.
1. En la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), en el panel de navegación, elija **Administrar** y, a continuación, seleccione **Objetos**.
1. Si aparece el cuadro de diálogo **Aún no tiene ningún objeto**, elija **Registrar un objeto**. De lo contrario, seleccione **Crear**.
1. En la página **Crear AWS IoT cosas**, selecciona **Crear una sola cosa**.
1. En la página **Añadir su dispositivo al registro de dispositivos**, escriba un nombre para el objeto de IoT (por ejemplo, **RaspberryPi**) y, a continuación, elija **Siguiente**. No puede modificar el nombre de un objeto una vez creado. Para cambiar el nombre de una cosa, debe crear otra nueva, asignarle el nuevo nombre y eliminar después la anterior.
1. En la página **Agregar un certificado para el objeto**, elija **Crear certificado**.
1. Elija los enlaces **Descargar** para descargar el certificado, la clave privada y el certificado de CA raíz.
**importante**
Esta es la única vez que puede descargar el certificado y la clave privada.
1. Para activar el certificado, seleccione **Activar**. El certificado debe estar activo para que un dispositivo pueda conectarse a AWS IoT.
1. Elija **Attach a policy (Asociar una política)**.
1. En **Añadir una política para tu cosa**, selecciona y **MoistureSensorPolicy**, a continuación, selecciona **Registrar cosa**.
# Paso 3: Crear un tema y una suscripción a Amazon SNS
Cree un tema y una suscripción de Amazon SNS.
1. En la [consola SNS de AWS](https://console.aws.amazon.com/sns/home), en el panel de navegación, seleccione **Temas** y, a continuación, seleccione **Crear tema**.
1. Elija el tipo **Estándar** e introduzca un nombre para el tema (por ejemplo, **MoistureSensorTopic**).
1. Escriba un nombre de visualización para el tema (por ejemplo, **Moisture Sensor Topic**). Este es el nombre que se muestra para el tema en la consola de Amazon SNS.
1. Seleccione **Crear tema**.
1. En la página de detalles del tema de Amazon SNS, seleccione **Crear suscripción**.
1. En **Protocolo**, elija **Correo electrónico**.
1. Para **punto de conexión**, introduzca su dirección de correo electrónico.
1. Seleccione **Crear subscripción**.
1. Abra su cliente de correo electrónico y busque un mensaje con el asunto **MoistureSensorTopic**. Abra el correo electrónico y elija el enlace **Confirmar suscripción**.
**importante**
No recibirá ninguna alerta por correo electrónico de este tema de Amazon SNS hasta que confirme la suscripción.
Debería recibir un mensaje de correo electrónico con el texto que escribió.
# Paso 4: Crea una AWS IoT regla para enviar un correo electrónico
Una AWS IoT regla define una consulta y una o más acciones que se deben realizar cuando se recibe un mensaje de un dispositivo. El motor de AWS IoT reglas escucha los mensajes enviados por los dispositivos y utiliza los datos de los mensajes para determinar si se debe realizar alguna acción. Para obtener más información, consulte [Reglas para AWS IoT](iot-rules.md).
En este tutorial el dispositivo Raspberry Pi publica mensajes en `aws/things/RaspberryPi/shadow/update`. Se trata de un tema de MQTT interno utilizado por los dispositivos y el servicio Thing Shadow. El Raspberry Pi publica mensajes que tienen el siguiente formato:
```
{
"reported": {
"moisture" : moisture-reading,
"temp" : temperature-reading
}
}
```
Puede crear una consulta que extraiga los datos de humedad y temperatura del mensaje entrante. También creará una acción de Amazon SNS que tome los datos y los envíe a los suscriptores de temas de Amazon SNS si la lectura de humedad está por debajo de un valor umbral.
**Crear una regla de Amazon SNS**
1. En la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), seleccione **Enrutamiento de mensajes** y, a continuación, selecciona **Reglas**. Si aparece el cuadro de diálogo **You don't have any rules yet (Aún no tiene ninguna regla)**, elija **Create a rule (Crear una regla)**. De lo contrario, seleccione **Crear regla**.
1. En la página de **propiedades de la regla**, introduzca un **nombre de regla**, por ejemplo**MoistureSensorRule**, y proporcione una breve **descripción de la regla**, por ejemplo **Sends an alert when soil moisture level readings are too low**.
1. Seleccione **Siguiente** y configure su sentencia SQL. Elija la **versión SQL** como **23 de marzo de 2016** e introduzca la siguiente AWS IoT sentencia de consulta SQL:
```
SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE state.reported.moisture < 400
```
Esta instrucción activa la acción de la regla cuando la lectura de `moisture` es menor que `400`.
**nota**
Es posible que tenga que utilizar un valor diferente. Una vez que el código se ejecute en el dispositivo Raspberry Pi, si toca el sensor, lo coloca en agua o en una maceta, podrá ver los valores que se obtienen del sensor.
1. Elija **Siguiente** y adjunte las acciones de las reglas. Para la **acción 1**, elija **Servicio de notificación simple**. La descripción de esta acción de regla es **Enviar un mensaje como una notificación push de SNS**.
1. **Para el **tema de SNS**, elija el tema en el que creó y deje el [Paso 3: Crear un tema y una suscripción a Amazon SNS](iot-moisture-create-sns-topic.md) formato **MoistureSensorTopic**del **mensaje** en RAW.** En **Rol de IAM**, elija **Crear un nuevo rol**. Especifique un nombre para el rol (por ejemplo, **LowMoistureTopicRole**) y elija **Crear rol**.
1. Seleccione **Siguiente** para revisarla y, a continuación, seleccione **Crear** para crear la regla.
# Configuración del dispositivo Raspberry Pi y el sensor de humedad
Inserte la tarjeta micro SD en el Raspberry Pi, conecte el monitor, el teclado, el ratón y, si no utiliza una conexión wifi, el cable Ethernet. No conecte aún el cable de alimentación.
Conecte el cable puente JST al sensor de humedad. El otro lado del puente tiene cuatro cables:
+ Verde: I2C SCL
+ Blanco: I2C SDA
+ Rojo: alimentación (3,5 V)
+ Negro: conexión a tierra
Sujete el dispositivo Raspberry Pi con el enchufe hembra Ethernet a la derecha. En esta orientación hay dos filas de clavijas GPIO en la parte superior. Conecte los cables del sensor de humedad a la fila inferior de clavijas en el orden que se indica a continuación. Comenzando por la clavija del extremo izquierdo, conecte el cable rojo (alimentación), el cable blanco (SDA) y el cable verde (SCL). Omita una clavija y, a continuación, conecte el cable negro (conexión a tierra). Para obtener más información, consulte [Cableado de equipos Python](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test).
Conecte el cable de alimentación al dispositivo Raspberry Pi y conecte el otro extremo a una toma de corriente para encenderlo.
**Configuración del dispositivo Raspberry Pi**
1. En **Welcome to Raspberry Pi (Bienvenido a Raspberry Pi)**, elija **Siguiente**.
1. Elija el país, el idioma, la zona horaria y la distribución del teclado. Elija **Siguiente**.
1. Escriba una contraseña para el dispositivo Raspberry Pi y, a continuación, elija **Siguiente**.
1. Elija una red wifi y, a continuación, elija **Siguiente**. Si no utiliza una red wifi, elija **Skip (Omitir)**.
1. Elija **Siguiente** para comprobar si hay actualizaciones de software. Cuando se completen las actualizaciones, elija **Restart (Reiniciar)** para reiniciar el dispositivo Raspberry Pi.
Una vez que se inicie el dispositivo Raspberry Pi, habilite la interfaz de I2C.
1. En la esquina superior izquierda del escritorio de Raspbian, elija el icono de Raspberry, elija **Preferencias** y, a continuación, elija **Configuración de Raspberry Pi**.
1. En la pestaña **Interfaces**, en **I2C**, elija **Habilitar**.
1. Seleccione **Aceptar**.
Las bibliotecas del sensor de humedad STEMMA de Adafruit están diseñadas para ello. CircuitPython Para ejecutarlas en un dispositivo Raspberry Pi, debe instalar la última versión de Python 3.
1. Ejecute los siguientes comandos desde un símbolo del sistema para actualizar el software del dispositivo Raspberry Pi:
`sudo apt-get update`
`sudo apt-get upgrade`
1. Ejecute el siguiente comando para actualizar la instalación de Python 3:
`sudo pip3 install --upgrade setuptools`
1. Ejecute el siguiente comando para instalar las bibliotecas de GPIO de Raspberry Pi:
`pip3 install RPI.GPIO`
1. Ejecute el siguiente comando para instalar las bibliotecas de Adafruit Blinka:
`pip3 install adafruit-blinka`
Para obtener más información, consulte [Instalación de CircuitPython bibliotecas en](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi) Raspberry Pi.
1. Ejecute el siguiente comando para instalar las bibliotecas de Adafruit Seesaw:
`sudo pip3 install adafruit-circuitpython-seesaw`
1. Ejecute el siguiente comando para instalar el SDK de AWS IoT dispositivos para Python:
`pip3 install AWSIoTPythonSDK`
El dispositivo Raspberry Pi ahora tiene todas las bibliotecas necesarias. Cree un archivo denominado **moistureSensor.py** y copie el siguiente código Python en el archivo:
```
from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA
import logging
import time
import json
import argparse
import busio
# Shadow JSON schema:
#
# {
# "state": {
# "desired":{
# "moisture":,
# "temp":
# }
# }
# }
# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):
# Display status and data from update request
if responseStatus == "timeout":
print("Update request " + token + " time out!")
if responseStatus == "accepted":
payloadDict = json.loads(payload)
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Update request with token: " + token + " accepted!")
print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Update request " + token + " rejected!")
# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):
# Display status and data from delete request
if responseStatus == "timeout":
print("Delete request " + token + " time out!")
if responseStatus == "accepted":
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Delete request with token: " + token + " accepted!")
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Delete request " + token + " rejected!")
# Read in command-line parameters
def parseArgs():
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")
args = parser.parse_args()
return args
# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Parse command line arguments
args = parseArgs()
if not args.certificatePath or not args.privateKeyPath:
parser.error("Missing credentials for authentication.")
exit(2)
# If no --port argument is passed, default to 8883
if not args.port:
args.port = 8883
# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)
# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec
# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)
# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)
# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()
# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)
# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)
# Read data from moisture sensor and update shadow
while True:
# read moisture level through capacitive touch pad
moistureLevel = ss.moisture_read()
# read temperature from the temperature sensor
temp = ss.get_temp()
# Display moisture and temp readings
print("Moisture Level: {}".format(moistureLevel))
print("Temperature: {}".format(temp))
# Create message payload
payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}
# Update shadow
deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
time.sleep(1)
```
Guarde el archivo en un lugar donde pueda encontrarlo. Ejecute `moistureSensor.py` desde la línea de comandos con los siguientes parámetros:
punto de conexión
Tu AWS IoT punto final personalizado. Para obtener más información, consulte [API REST de sombra de dispositivo](device-shadow-rest-api.md).
rootCA
La ruta completa a su certificado de CA AWS IoT raíz.
cert
La ruta completa al certificado de su AWS IoT dispositivo.
clave
La ruta completa a la clave privada AWS IoT del certificado de su dispositivo.
thingName
El nombre de la cosa (en este caso, `RaspberryPi`).
clientId
El ID de cliente de MQTT. Utilice `RaspberryPi`.
La línea de comandos debería tener este aspecto:
`python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi`
Pruebe a tocar el sensor, colocarlo en una maceta o ponerlo en un vaso de agua para ver cómo responde a distintos niveles de humedad. Si es necesario, puede cambiar el valor del umbral en la opción `MoistureSensorRule`. Cuando la lectura del sensor de humedad es inferior al valor especificado en la declaración de consulta SQL de la regla, AWS IoT publica un mensaje en el tema Amazon SNS. Debería recibir un mensaje de correo electrónico que incluya los datos de humedad y temperatura.
Una vez que haya verificado la recepción de los mensajes de correo electrónico de Amazon SNS, pulse **CTRL\$1C** para detener el programa Python. Es poco probable que el programa Python envíe suficientes mensajes para incurrir en gastos, pero se recomienda detener el programa cuando haya terminado.