Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Tutorial: Demuestre la comunicación de mensajes MQTT con el cliente del AWS IoT dispositivo
En este tutorial, se muestra cómo el cliente del AWS IoT dispositivo puede suscribirse y publicar mensajes MQTT, que se utilizan habitualmente en las soluciones de IoT.
**Para comenzar este tutorial:**
+ Configure su ordenador host local y una Raspberry Pi, tal como se utilizó en [la sección anterior](iot-dc-install-dc.md).
Si guardaste la imagen de la tarjeta microSD después de instalar el AWS IoT Device Client, puedes usar una tarjeta microSD con esa imagen con tu Raspberry Pi.
+ Si ya has realizado esta demostración anteriormente, procura [Paso 2: Limpiar las demostraciones Cuenta de AWS después de crear con el cliente del AWS IoT dispositivo](iot-dc-cleanup.md#iot-dc-cleanup-cloud) eliminar todos los AWS IoT recursos que creaste en ejecuciones anteriores para evitar errores de recursos duplicados.
Para completar este tutorial se necesitan aproximadamente 45 minutos.
**Cuando haya terminado con este tema:**
+ Habrás demostrado diferentes maneras en las que tu dispositivo IoT puede suscribirse a los mensajes MQTT AWS IoT y publicarlos en ellos. AWS IoT
**Equipo necesario:**
+ Su entorno local de desarrollo y pruebas de [la sección anterior](iot-dc-install-dc.md)
+ La Raspberry Pi que utilizó en [la sección anterior](iot-dc-install-dc.md)
+ La tarjeta de memoria microSD de la Raspberry Pi que utilizó [en la sección anterior](iot-dc-install-dc.md)
**Topics**
+ [Preparación de Raspberry Pi para demostrar la comunicación de mensajes de MQTT](iot-dc-testconn-provision.md)
+ [Demuestre la publicación de mensajes con el cliente AWS IoT del dispositivo](iot-dc-testconn-publish.md)
+ [Demuestre la suscripción a los mensajes con el cliente del dispositivo AWS IoT](iot-dc-testconn-subscribe.md)
# Preparación de Raspberry Pi para demostrar la comunicación de mensajes de MQTT
Este procedimiento crea los recursos en AWS IoT y dentro de la Raspberry Pi para demostrar la comunicación de los mensajes MQTT mediante el AWS IoT Device Client.
**Topics**
+ [Crear los archivos de certificado para demostrar la comunicación MQTT](#iot-dc-testconn-provision-certs)
+ [Aprovisionar su dispositivo para demostrar la comunicación MQTT](#iot-dc-testconn-provision-aws)
+ [Configure el archivo de configuración del cliente del AWS IoT dispositivo y el cliente de prueba de MQTT para demostrar la comunicación con MQTT](#iot-dc-testconn-provision-dc-config)
## Crear los archivos de certificado para demostrar la comunicación MQTT
Este procedimiento crea los archivos de certificado del dispositivo para esta demostración.
**Para crear y descargar los archivos de certificado del dispositivo para la Raspberry Pi**
1. En la ventana del terminal de su ordenador host local, introduzca el siguiente comando para crear los archivos de certificado para su dispositivo.
```
mkdir ~/certs/pubsub
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/pubsub/device.pem.crt" \
--public-key-outfile "~/certs/pubsub/public.pem.key" \
--private-key-outfile "~/certs/pubsub/private.pem.key"
```
El comando devuelve una respuesta similar a la siguiente. Guarde el valor de `certificateArn` para utilizarlo más tarde.
```
{
"certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. Introduzca los siguientes comandos para configurar los permisos en el directorio de certificados y sus archivos.
```
chmod 700 ~/certs/pubsub
chmod 644 ~/certs/pubsub/*
chmod 600 ~/certs/pubsub/private.pem.key
```
1. Ejecute este comando para revisar los permisos de sus directorios y archivos de certificados.
```
ls -l ~/certs/pubsub
```
El resultado del comando debe ser el mismo que el que se muestra aquí, excepto que las fechas y horas de los archivos serán diferentes.
```
-rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
-rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
-rw-r--r-- 1 pi pi 451 Oct 28 13:02 public.pem.key
```
1. Introduzca estos comandos para crear los directorios de los archivos de registro.
```
mkdir ~/.aws-iot-device-client
mkdir ~/.aws-iot-device-client/log
chmod 745 ~/.aws-iot-device-client/log
echo " " > ~/.aws-iot-device-client/log/aws-iot-device-client.log
echo " " > ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
chmod 600 ~/.aws-iot-device-client/log/*
```
## Aprovisionar su dispositivo para demostrar la comunicación MQTT
Esta sección crea los AWS IoT recursos que aprovisionan tu Raspberry Pi. AWS IoT
**Para aprovisionar el dispositivo en AWS IoT:**
1. En la ventana del terminal de su ordenador host local, introduzca el siguiente comando para obtener la dirección del punto de conexión de datos de dispositivo correspondiente a su Cuenta de AWS.
```
aws iot describe-endpoint --endpoint-type IoT:Data-ATS
```
El valor del punto de conexión no ha cambiado desde el momento en que ejecutó este comando para el tutorial anterior. Al volver a ejecutar el comando aquí, será más fácil buscar y pegar el valor del punto de conexión de datos en el archivo de configuración utilizado en este tutorial.
El comando de los pasos anteriores devuelve una respuesta similar a la siguiente. Anote el valor `endpointAddress`: lo necesitará más adelante.
```
{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}
```
1. Ingresa este comando para crear un nuevo recurso AWS IoT para tu Raspberry Pi.
```
aws iot create-thing --thing-name "PubSubTestThing"
```
Como un AWS IoT recurso es una representación *virtual* de su dispositivo en la nube, podemos crear varios recursos AWS IoT para usarlos con diferentes propósitos. Todos pueden ser utilizados por el mismo dispositivo físico IoT para representar diferentes aspectos del dispositivo.
Estos tutoriales solo utilizarán un recurso a la vez para representar la Raspberry Pi. De esta forma, en estos tutoriales, se representan las diferentes demostraciones para que, después de crear los AWS IoT recursos para una demostración, pueda volver atrás y repetir la demostración utilizando los recursos que ha creado específicamente para cada una de ellas.
Si AWS IoT se ha creado el recurso deseado, el comando devuelve una respuesta como esta.
```
{
"thingName": "PubSubTestThing",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}
```
1. En la ventana del terminal:
1. Abra un editor de texto, como `nano`.
1. Copie este documento JSON y péguelo en el editor de texto abierto.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:client/PubSubTestThing"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic"
]
}
]
}
```
1. En el editor, en cada `Resource` sección del documento de política, *us-west-2:57EXAMPLE833* sustitúyalo por el tuyo Región de AWS, dos puntos (:)) y tu Cuenta de AWS número de 12 dígitos.
1. Guarde el archivo en el editor de texto como **\$1/policies/pubsub\$1test\$1thing\$1policy.json**.
1. Ejecute este comando para usar el documento de política de los pasos anteriores para crear una AWS IoT política.
```
aws iot create-policy \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_test_thing_policy.json"
```
Si se crea la política, el comando devuelve una respuesta como esta.
```
{
"policyName": "PubSubTestThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n\"Version\": \"2012-10-17\", \n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
"policyVersionId": "1"
}
```
1. Ejecute este comando para asociar la política al certificado del dispositivo. Reemplace `certificateArn` por el valor `certificateArn` que guardó anteriormente en esta sección.
```
aws iot attach-policy \
--policy-name "PubSubTestThingPolicy" \
--target "certificateArn"
```
Si se ejecuta correctamente, este comando no devuelve nada.
1. Ejecute este comando para asociar el certificado del dispositivo al recurso de objeto de AWS IoT . Reemplace `certificateArn` por el valor `certificateArn` que guardó anteriormente en esta sección.
```
aws iot attach-thing-principal \
--thing-name "PubSubTestThing" \
--principal "certificateArn"
```
Si se ejecuta correctamente, este comando no devuelve nada.
Una vez que hayas aprovisionado correctamente el dispositivo AWS IoT, estarás listo para continuar con él[Configure el archivo de configuración del cliente del AWS IoT dispositivo y el cliente de prueba de MQTT para demostrar la comunicación con MQTT](#iot-dc-testconn-provision-dc-config).
## Configure el archivo de configuración del cliente del AWS IoT dispositivo y el cliente de prueba de MQTT para demostrar la comunicación con MQTT
Este procedimiento crea un archivo de configuración para probar el AWS IoT Device Client.
**Para crear el archivo de configuración para probar el AWS IoT Device Client**
1. En la ventana del terminal de su ordenador host local que esté conectado a la Raspberry Pi:
1. Abra un editor de texto, como `nano`.
1. Copie este documento JSON y péguelo en el editor de texto abierto.
```
{
"endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
"cert": "~/certs/pubsub/device.pem.crt",
"key": "~/certs/pubsub/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "PubSubTestThing",
"logging": {
"enable-sdk-logging": true,
"level": "DEBUG",
"type": "STDOUT",
"file": ""
},
"jobs": {
"enabled": false,
"handler-directory": ""
},
"tunneling": {
"enabled": false
},
"device-defender": {
"enabled": false,
"interval": 300
},
"fleet-provisioning": {
"enabled": false,
"template-name": "",
"template-parameters": "",
"csr-file": "",
"device-key": ""
},
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}
```
1. Sustituya el *endpoint* valor por el punto final de datos del dispositivo Cuenta de AWS que encontró en[Aprovisione su dispositivo en AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).
1. Guarde el archivo en el editor de texto como **\$1/dc-configs/dc-pubsub-config.json**.
1. Ejecute este comando para establecer los permisos en el nuevo archivo de configuración.
```
chmod 644 ~/dc-configs/dc-pubsub-config.json
```
1. Para preparar el **cliente de prueba de MQTT** para que se suscriba a todos los mensajes de MQTT:
1. En el ordenador host local, en la [consola de AWS IoT](https://console.aws.amazon.com//iot/home#/test), elija **Cliente de prueba de MQTT**.
1. En la pestaña **Suscribirse a un tema**, en **Filtro de temas**, introduzca **\$1** (un solo signo de almohadilla) y elija **Suscribirse**.
1. Debajo de la etiqueta **Suscripciones**, confirme que aparece **\$1** (un solo signo de almohadilla).
Deje abierta la ventana con el **cliente de prueba de MQTT** mientras continúa con este tutorial.
Después de guardar el archivo y configurar el **cliente de prueba de MQTT**, estará listo para continuar con [Demuestre la publicación de mensajes con el cliente AWS IoT del dispositivo](iot-dc-testconn-publish.md).
# Demuestre la publicación de mensajes con el cliente AWS IoT del dispositivo
Los procedimientos de esta sección muestran cómo el cliente del AWS IoT dispositivo puede enviar mensajes MQTT predeterminados y personalizados.
Estas declaraciones en la política que ha creado en el paso anterior para estos ejercicios dan permiso a la Raspberry Pi para realizar estas acciones:
+
**`iot:Connect`**
Proporciona el nombre del cliente`PubSubTestThing`, su Raspberry Pi que ejecuta el AWS IoT Device Client, para conectarse.
```
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing"
]
}
```
+
**`iot:Publish`**
Dar permiso a la Raspberry Pi para publicar mensajes con un tema de MQTT de `test/dc/pubtopic`.
```
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
]
}
```
La acción `iot:Publish` da permiso para publicar en los temas de MQTT que figuran en la matriz de recursos. El *contenido* de esos mensajes no está controlado por la declaración de política.
## Publica el mensaje predeterminado mediante el AWS IoT Device Client
Este procedimiento ejecuta el cliente del AWS IoT dispositivo para publicar un único mensaje MQTT predeterminado que el **cliente de prueba MQTT** recibe y muestra.
**Para enviar el mensaje MQTT predeterminado desde el cliente del dispositivo AWS IoT**
1. Asegúrese de que tanto la ventana del terminal de su ordenador host local conectada a su Raspberry Pi como la ventana con el **cliente de prueba de MQTT** estén visibles mientras realiza este procedimiento.
1. En la ventana del terminal, introduzca estos comandos para ejecutar el AWS IoT Device Client mediante el archivo de configuración creado en[Crear el archivo de configuración](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json
```
En la ventana del terminal, el cliente del AWS IoT dispositivo muestra los mensajes de información y cualquier error que se produzca durante su ejecución.
Si no se muestra ningún error en la ventana del terminal, revise el **cliente de prueba de MQTT**.
1. En la opción **Cliente de prueba de MQTT**, en la ventana **Suscripciones**, consulte el mensaje *Hello World\$1* enviado al tema del mensaje `test/dc/pubtopic`.
1. Si el cliente del AWS IoT dispositivo no muestra ningún error y aparece *Hello World\$1* enviado al `test/dc/pubtopic` mensaje en el **cliente de prueba de MQTT**, ha demostrado que la conexión se ha realizado correctamente.
1. En la ventana del terminal, introduzca **^C** (Ctrl-C) para detener el cliente del AWS IoT dispositivo.
Una vez que haya demostrado que el cliente del AWS IoT dispositivo publicó el mensaje MQTT predeterminado, puede continuar con el. [Publique un mensaje personalizado mediante el AWS IoT Device Client](#iot-dc-testconn-publish-custom)
## Publique un mensaje personalizado mediante el AWS IoT Device Client
Los procedimientos de esta sección crean un mensaje de MQTT personalizado y, a continuación, ejecutan AWS IoT Device Client para publicar el mensaje de MQTT personalizado una vez para que el **cliente de prueba de MQTT** lo reciba y lo muestre.
### Cree un mensaje MQTT personalizado para el cliente del AWS IoT dispositivo
Realice estos pasos en la ventana del terminal del ordenador host local que está conectado a su Raspberry Pi.
**Para crear un mensaje personalizado para que el cliente del AWS IoT dispositivo lo publique**
1. En la ventana del terminal, abra un editor de texto, por ejemplo, `nano`.
1. En el editor de texto, copie y pegue el siguiente documento JSON. Esta será la carga útil de mensajes MQTT que publique el cliente del AWS IoT dispositivo.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Guarde el contenido del editor de texto como **\$1/messages/sample-ws-message.json**.
1. Introduzca el siguiente comando para configurar los permisos del archivo de mensaje que acaba de crear.
```
chmod 600 ~/messages/*
```
**Crear un archivo de configuración para que el cliente del AWS IoT dispositivo lo utilice para enviar el mensaje personalizado**
1. En la ventana del terminal, en un editor de texto como`nano`, por ejemplo, abra el archivo de configuración de AWS IoT Device Client existente:**\$1/dc-configs/dc-pubsub-config.json**.
1. Edita el objeto de `samples` para que tenga este aspecto. No es necesario cambiar ninguna otra parte de este archivo.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
1. Guarde el contenido del editor de texto como **\$1/dc-configs/dc-pubsub-custom-config.json**.
1. Ejecute este comando para establecer los permisos en el nuevo archivo de configuración.
```
chmod 644 ~/dc-configs/dc-pubsub-custom-config.json
```
### Publique el mensaje MQTT personalizado mediante el AWS IoT Device Client
Este cambio afecta únicamente al *contenido* de la carga del mensaje de MQTT, por lo que la política actual seguirá funcionando. Sin embargo, si se cambiara el *tema de MQTT* (tal como lo define el valor `publish-topic` en `~/dc-configs/dc-pubsub-custom-config.json`), también habría que modificar la declaración de política de `iot::Publish` para permitir que la Raspberry Pi publique en el nuevo tema de MQTT.
**Para enviar el mensaje MQTT desde el cliente del dispositivo AWS IoT**
1. Asegúrese de que tanto la ventana del terminal como la ventana con el **cliente de prueba de MQTT** estén visibles mientras realiza este procedimiento. Además, verifique que su **cliente de prueba de MQTT** siga suscrito al filtro de temas **\$1**. Si no lo está, vuelva a suscribirse al filtro de temas **\$1**.
1. En la ventana del terminal, introduzca estos comandos para ejecutar AWS IoT Device Client mediante el archivo de configuración creado en [Crear el archivo de configuración](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
En la ventana del terminal, el cliente del AWS IoT dispositivo muestra los mensajes de información y cualquier error que se produzca durante su ejecución.
Si no se muestra ningún error en la ventana del terminal, revise el cliente de prueba de MQTT.
1. En el **cliente de prueba de MQTT**, en la ventana **Suscripciones**, observe la carga del mensaje personalizado enviado al tema del mensaje `test/dc/pubtopic`.
1. Si el cliente del AWS IoT dispositivo no muestra ningún error y usted ve la carga útil del mensaje personalizado que publicó en el `test/dc/pubtopic` mensaje en el **cliente de prueba de MQTT**, significa que ha publicado el mensaje personalizado correctamente.
1. En la ventana del terminal, introduzca **^C** (Ctrl-C) para detener el cliente del dispositivo. AWS IoT
Una vez que hayas demostrado que el cliente del AWS IoT dispositivo publicó una carga de mensajes personalizada, puedes continuar haciéndolo. [Demuestre la suscripción a los mensajes con el cliente del dispositivo AWS IoT](iot-dc-testconn-subscribe.md)
# Demuestre la suscripción a los mensajes con el cliente del dispositivo AWS IoT
En esta sección, mostrará dos tipos de suscripciones de mensajes:
+ Suscripción a un solo tema
+ Suscripción a un tema comodín
Estas declaraciones en la política creadas para estos ejercicios dan permiso a la Raspberry Pi para realizar estas acciones:
+
**`iot:Receive`**
Otorga al cliente del AWS IoT dispositivo permiso para recibir temas de MQTT que coincidan con los nombrados en el `Resource` objeto.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
]
}
```
+
**`iot:Subscribe`**
Otorga al cliente del AWS IoT dispositivo permiso para suscribirse a los filtros de temas de MQTT que coincidan con los nombres del `Resource` objeto.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
]
}
```
## Suscripción a un solo tema de mensaje de MQTT
Este procedimiento demuestra cómo el cliente del AWS IoT dispositivo puede suscribirse a los mensajes MQTT y registrarlos.
En la ventana del terminal de un ordenador host local que esté conectado a su Raspberry Pi, enumere el contenido de **\$1/dc-configs/dc-pubsub-custom-config.json** o abra el archivo en un editor de texto para revisarlo. Localice el objeto `samples`. Debería tener este aspecto.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
Observe que el valor `subscribe-topic` es el tema de MQTT al que AWS IoT Device Client se suscribirá cuando se ejecute. El cliente del AWS IoT dispositivo escribe las cargas útiles de mensajes que recibe de esta suscripción en el archivo mencionado en el `subscribe-file` valor.
**Para suscribirse a un tema de mensajes MQTT desde el AWS IoT Device Client**
1. Asegúrese de que tanto la ventana del terminal como la ventana con el cliente de prueba de MQTT estén visibles mientras realiza este procedimiento. Además, verifique que su **cliente de prueba de MQTT** siga suscrito al filtro de temas **\$1**. Si no lo está, vuelva a suscribirse al filtro de temas **\$1**.
1. En la ventana del terminal, introduzca estos comandos para ejecutar el AWS IoT Device Client mediante el archivo de configuración creado en[Crear el archivo de configuración](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1).
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
En la ventana del terminal, el cliente del AWS IoT dispositivo muestra los mensajes de información y cualquier error que se produzca durante su ejecución.
Si no se muestra ningún error en la ventana del terminal, continúe en la consola de AWS IoT .
1. En la AWS IoT consola, en el **cliente de pruebas de MQTT**, seleccione la pestaña **Publicar en un tema**.
1. En **Nombre del tema**, introduzca **test/dc/subtopic**
1. En **Carga útil del mensaje**, revise el contenido del mensaje.
1. Elija **Publicar** para publicar el mensaje de MQTT.
1. En la ventana del terminal, busque la entrada de *mensaje recibida* del cliente del AWS IoT dispositivo que tiene este aspecto.
```
2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 45 bytes
```
1. Cuando veas la entrada del *mensaje recibido* que indica que se ha recibido el mensaje, ingresa **^C** (Ctrl-C) para detener el cliente del AWS IoT dispositivo.
1. Introduzca este comando para ver el final del archivo de registro de mensajes y ver el mensaje que publicó desde el **cliente de prueba de MQTT**.
```
tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
Al ver el mensaje en el archivo de registro, ha demostrado que AWS IoT Device Client recibió el mensaje que usted publicó desde el cliente de prueba de MQTT.
## Suscribirse a varios temas de mensajes de MQTT utilizando caracteres comodín
Estos procedimientos demuestran cómo el cliente del AWS IoT dispositivo puede suscribirse a los mensajes MQTT y registrarlos mediante caracteres comodín. Para ello, deberá:
1. Actualice el filtro de temas que el cliente del AWS IoT dispositivo utiliza para suscribirse a los temas de MQTT.
1. Actualizar la política utilizada por el dispositivo para permitir las nuevas suscripciones.
1. Ejecute el cliente del AWS IoT dispositivo y publique los mensajes desde la consola de pruebas de MQTT.
**Para crear un archivo de configuración y suscribirse a varios temas de mensajes de MQTT mediante un filtro de temas de MQTT con caracteres comodín**
1. En la ventana del terminal de su ordenador host local conectado a la Raspberry Pi, abra para **\$1/dc-configs/dc-pubsub-custom-config.json** para editar y localice el objeto `samples`.
1. En el editor de texto, localice el objeto `samples` y actualice el valor `subscribe-topic` para que tenga este aspecto.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/#",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
El nuevo valor `subscribe-topic` es un [filtro de temas de MQTT](topics.md#topicfilters) con un carácter comodín de MQTT al final. Esto describe una suscripción a todos los temas de MQTT que comiencen con `test/dc/`. El cliente del AWS IoT dispositivo escribe las cargas útiles de mensajes que recibe de esta suscripción en el archivo mencionado. `subscribe-file`
1. Guarde el archivo de configuración modificado como **\$1/dc-configs/dc-pubsub-wild-config.json** y salga del editor de texto.
**Para modificar la política utilizada por su Raspberry Pi y permitir la suscripción y la recepción de varios temas de mensajes de MQTT**
1. En la ventana del terminal de su ordenador host local que esté conectado a la Raspberry Pi, en el editor de texto que prefiera, abra **\$1/policies/pubsub\$1test\$1thing\$1policy.json** para su edición y luego busque las declaraciones de política de `iot::Subscribe` y `iot::Receive` en el archivo.
1. En la declaración de política `iot::Subscribe`, actualice la cadena del objeto Resource para reemplazar `subtopic` por `*`, de forma que tenga el siguiente aspecto.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*"
]
}
```
**nota**
Los [caracteres comodín del filtro de temas de MQTT](topics.md#topicfilters) son `+` (signo más) y `#` (signo de almohadilla). Una solicitud de suscripción con un símbolo `#` al final suscribe todos los temas que comiencen por la cadena que precede al carácter `#` (por ejemplo, `test/dc/` en este caso).
Sin embargo, el valor del recurso de la declaración de política que autoriza esta suscripción debe usar `*` (un asterisco) en lugar de `#` (signo de almohadilla) en el ARN del filtro de temas. Esto se debe a que el procesador de políticas utiliza un carácter comodín diferente al que utiliza MQTT.
Para obtener más información sobre el uso de caracteres comodín en los temas y los filtros de temas en las políticas, consulte [Uso de caracteres comodín en MQTT y en las políticas AWS IoT Core](pub-sub-policy.md#pub-sub-policy-cert).
1. En la declaración de política `iot::Receive`, actualice la cadena del objeto Resource para reemplazar `subtopic` por `*`, de forma que tenga el siguiente aspecto.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*"
]
}
```
1. Guarde el documento de política actualizado como **\$1/policies/pubsub\$1wild\$1test\$1thing\$1policy.json** y salga del editor.
1. Introduzca este comando para actualizar la política de este tutorial con el fin de utilizar las nuevas definiciones de recursos.
```
aws iot create-policy-version \
--set-as-default \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_wild_test_thing_policy.json"
```
Si el comando se ejecuta correctamente, devuelve una respuesta como esta. Observe que `policyVersionId` ahora es `2`, lo que indica que esta es la segunda versión de esta política.
Si ha actualizado correctamente la política, puede continuar con el siguiente procedimiento.
```
{
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n \"Version\": \"2012-10-17\", \n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Connect\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Publish\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Subscribe\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Receive\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n ]\n }\n ]\n}\n",
"policyVersionId": "2",
"isDefaultVersion": true
}
```
Si aparece un error que indica que hay demasiadas versiones de la política como para guardar una nueva, introduzca este comando para ver una lista de las versiones actuales de la política. Revise la lista que devuelve este comando para buscar una versión de la política que pueda eliminar.
```
aws iot list-policy-versions --policy-name "PubSubTestThingPolicy"
```
Introduzca este comando para eliminar una versión que ya no necesite. Tenga en cuenta que no puede eliminar la versión de política predeterminada. La versión de política predeterminada es la que tiene un valor `isDefaultVersion` de `true`.
```
aws iot delete-policy-version \
--policy-name "PubSubTestThingPolicy" \
--policy-version-id policyId
```
Tras eliminar una versión de la política, vuelva a intentar este paso.
Con el archivo de configuración y la política actualizados, estará listo para hacer una demostración de las suscripciones estándar con el AWS IoT Device Client.
**Para demostrar cómo el cliente del AWS IoT dispositivo se suscribe y recibe varios temas de mensajes de MQTT**
1. En el **cliente de prueba de MQTT**, compruebe las suscripciones. Si el **cliente de pruebas de MQTT** está suscrito al filtro incluido en el tema **\$1**, continúe con el siguiente paso. De lo contrario, en la opción **Cliente de prueba de MQTT**, en la pestaña **Suscribirse a un tema**, en **Filtro de temas**, introduzca **\$1** (un carácter de almohadilla) y, a continuación, seleccione **Suscribirse** para suscribirse.
1. En la ventana del terminal de su ordenador host local conectado a su Raspberry Pi, introduzca estos comandos para iniciar AWS IoT Device Client.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json
```
1. Mientras observa el resultado del AWS IoT Device Client en la ventana del terminal del ordenador host local, vuelva al cliente de prueba de **MQTT**. En la pestaña **Publicar en un tema**, en **Nombre del tema**, introduzca **test/dc/subtopic** y, a continuación, seleccione **Publicar**.
1. En la ventana del terminal, confirme que el mensaje se ha recibido buscando un mensaje como:
```
2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 76 bytes
```
1. Mientras observa el resultado del AWS IoT Device Client en la ventana del terminal del ordenador host local, vuelva al cliente de **prueba de MQTT**. En la pestaña **Publicar en un tema**, en **Nombre del tema**, introduzca **test/dc/subtopic2** y, a continuación, seleccione **Publicar**.
1. En la ventana del terminal, confirme que el mensaje se ha recibido buscando un mensaje como:
```
2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 77 bytes
```
1. Cuando vea los mensajes que confirman la recepción de ambos mensajes, introduzca **^C** (Ctrl-C) para detener el AWS IoT Device Client.
1. Introduzca este comando para ver el final del archivo de registro de mensajes y ver el mensaje que publicó desde el **cliente de prueba de MQTT**.
```
tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
**nota**
El archivo de registro contiene solo cargas de mensajes. Los temas de los mensajes no se registran en el archivo de registro de mensajes recibidos.
Es posible que también vea el mensaje publicado por el cliente del AWS IoT dispositivo en el registro recibido. Esto se debe a que el filtro de temas comodín incluye ese tema del mensaje y, en ocasiones, el agente de mensajes puede procesar la solicitud de suscripción antes de enviar el mensaje publicado a los suscriptores.
Las entradas del archivo de registro demuestran que se recibieron los mensajes. Puede repetir este procedimiento utilizando otros nombres de temas. Se deben recibir y registrar todos los mensajes que tengan un nombre de tema que comience por `test/dc/`. Se ignoran los mensajes con nombres de temas que comiencen por cualquier otro texto.
Tras demostrar cómo el cliente del AWS IoT dispositivo puede publicar y suscribirse a los mensajes MQTT, continúe [Tutorial: Demuestre acciones remotas (trabajos) con el cliente del AWS IoT dispositivo](iot-dc-runjobs.md) haciéndolo.