

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.

# Preparación de Raspberry Pi para demostrar la comunicación de mensajes de MQTT
<a name="iot-dc-testconn-provision"></a>

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
<a name="iot-dc-testconn-provision-certs"></a>

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
<a name="iot-dc-testconn-provision-aws"></a>

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
<a name="iot-dc-testconn-provision-dc-config"></a>

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).