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.
# Configuración del dispositivo
En esta sección se describe cómo configurar el dispositivo para conectarse a AWS IoT Core. Si quiere empezar con un dispositivo AWS IoT Core pero aún no lo tiene, puede crear un dispositivo virtual mediante Amazon EC2 o puede utilizar su PC con Windows o Mac como dispositivo de IoT.
Seleccione la mejor opción de dispositivo para AWS IoT Core probarla. Por supuesto, puede probarlos todos, pero siempre de uno en uno. Si no sabe con certeza cuál es la mejor opción de dispositivo para usted, consulte cómo elegir [la mejor opción de dispositivo](iot-gs-first-thing.md#choosing-a-gs-system) y, después, vuelva a esta página.
**Opciones de dispositivos**
+ [Crear un dispositivo virtual con Amazon EC2](creating-a-virtual-thing.md)
+ [Utilice su PC o Mac con Windows o Linux como dispositivo AWS IoT](using-laptop-as-device.md)
+ [Conexión de una Raspberry Pi u otro dispositivo](connecting-to-existing-device.md)
# Crear un dispositivo virtual con Amazon EC2
En este tutorial, creará una instancia de Amazon EC2 para que sirva como dispositivo virtual en la nube.
Para completar este tutorial, necesitas 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.
**Topics**
+ [Configurar una instancia de Amazon EC2](#set-up-ec2)
+ [Instale Git, Node.js y configure AWS CLI](#install-git-node)
+ [Cree AWS IoT recursos para su dispositivo virtual](#ec2-create-certificate)
+ [Instale el SDK del AWS IoT dispositivo para JavaScript](#ec2-sdk)
+ [Ejecutar la aplicación de ejemplo](#ec2-run-app)
+ [Ve los mensajes de la aplicación de ejemplo en la AWS IoT consola](#ec2-view-msg)
## Configurar una instancia de Amazon EC2
Los siguientes pasos le muestran cómo crear una instancia de Amazon EC2 que actuará como su dispositivo virtual en lugar de un dispositivo físico.
Si es la primera vez que crea una instancia de Amazon EC2, puede que las instrucciones de Introducción [a las instancias de Amazon EC2 Linux](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/EC2_GetStarted.html) le resulten más útiles.
**Lanzamiento de una instancia de**
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el menú de la consola de la izquierda, expanda la sección **Instancias** y elija **Instancias**. En el panel **Instancias**, seleccione **Lanzar instancias** a la derecha para ver una lista de configuraciones básicas.
1. En la sección **Nombre y etiquetas**, introduzca un nombre para la instancia y, si lo desea, agregue etiquetas.
1. En la sección **Imágenes de aplicaciones y sistema operativo (Imagen de máquina de Amazon)**, elija una plantilla de AMI para la instancia, como la de *Amazon Linux 2 AMI (HVM)*. Observe que estas AMI están marcadas como "Free tier eligible" (Apta para el nivel gratuito).
1. En la sección **Tipo de instancia**, puede seleccionar la configuración de hardware de su instancia. Seleccione el tipo `t2.micro`, que es la opción predeterminada. Observe que este tipo de instancia es apta para la capa gratuita.
1. En la sección **Par de claves (inicio de sesión)**, elija un nombre de par de claves de la lista desplegable o elija **Crear un nuevo par de claves** para crear uno nuevo. Al crear un nuevo par de claves, asegúrese de descargar el archivo de clave privada y guardarlo en un lugar seguro, ya que es la única forma de descargarlo y guardarlo. Deberá proporcionar el nombre de su par de claves al lanzar una instancia, y la clave privada correspondiente cada vez que se conecte a dicha instancia.
**aviso**
No seleccione la opción **Continuar sin un par de claves**. Si lanza la instancia sin un par de claves, no podrá conectarse a ella.
1. En la sección **Configuración de redes** y en la sección **Configurar el almacenamiento**, puede conservar la configuración predeterminada. Cuando todo esté preparado, elija **Lanzar instancias**.
1. Verá una página de confirmación que indicará que la instancia se está lanzando. Elija **View instances** para cerrar la página de confirmación y volver a la consola.
1. Puede ver el estado del lanzamiento en la pantalla **Instancias**. La instancia tarda poco tiempo en lanzarse. Al lanzar una instancia, su estado inicial es `pending`. Una vez iniciada la instancia, el estado cambia a `running` y recibe un nombre del DNS público. (Si la columna **DNS público (IPv4)** está oculta, seleccione **Mostrar u ocultar columnas** (el icono con forma de engranaje) en la esquina superior derecha de la página y, a continuación, seleccione DNS **público** (). IPv4
1. Puede que transcurran unos minutos hasta que la instancia esté lista para conectarse a ella. Compruebe que la instancia haya superado las comprobaciones de estado; puede ver esta información en la columna **Status Checks**.
Cuando la nueva instancia haya superado las comprobaciones de estado, continúe con el siguiente procedimiento y conéctese a ella.
**Para conectarse a la instancia**
Puede conectarse a una instancia mediante el cliente basado en navegador seleccionando la instancia en la consola de Amazon EC2 y eligiendo conectarse mediante Amazon EC2 Instance Connect. Instance Connect gestiona los permisos y proporciona una conexión exitosa.
1. Abra la consola de Amazon EC2 en [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).
1. En el menú de la izquierda, seleccione **Instancias**.
1. Seleccione la instancia y elija **Connect (Conectar)**.
1. Elija **Amazon EC2 Instance Connect **, **Conectar**.
Ahora debería ver una ventana **Amazon EC2 Instance Connect** conectada a su nueva instancia de Amazon EC2.
## Instale Git, Node.js y configure AWS CLI
En esta sección, instalará Git y Node.js en su instancia de Linux.
**Para instalar Git**
1. En la ventana **Amazon EC2 Instance Connect**, actualice la instancia mediante el siguiente comando.
```
sudo yum update -y
```
1. En la ventana **Amazon EC2 Instance Connect**, instale Git mediante el siguiente comando.
```
sudo yum install git -y
```
1. Para comprobar si Git está instalado y cuál es su versión actual, ejecute el siguiente comando:
```
git --version
```
**Para instalar Node.js**
1. En la ventana **Amazon EC2 Instance Connect**, instale el administrador de versiones de nodos (nvm) mediante el siguiente comando.
```
curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash
```
Utilizaremos nvm para instalar Node.js, ya que nvm puede instalar varias versiones de Node.js y permitirle alternar entre ellas.
1. En la ventana **Amazon EC2 Instance Connect**, active nvm mediante este comando.
```
. ~/.nvm/nvm.sh
```
1. En la ventana **Amazon EC2 Instance Connect**, utilice nvm para instalar la última versión de Node.js mediante este comando.
```
nvm install 16
```
**nota**
Esto instala la versión de LTS más reciente de Node.js.
Si instala Node.js también instalará el administrador de paquetes de nodos (npm) para poder instalar módulos adicionales según sea necesario.
1. En la ventana **Amazon EC2 Instance Connect**, compruebe que Node.js está instalado y se ejecuta correctamente mediante este comando.
```
node -e "console.log('Running Node.js ' + process.version)"
```
Este tutorial requiere la versión Node v10.0 o posterior. Para obtener más información, consulte [Tutorial: Configuración de Node.js en una instancia de Amazon EC2](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html).
**Para configurar AWS CLI**
La instancia de Amazon EC2 viene precargada con la AWS CLI. Sin embargo, debe completar su AWS CLI perfil. Para obtener más información acerca de cómo configurar la CLI, consulte [Configuración de la AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).
1. En el ejemplo siguiente se muestran los valores de ejemplo. Reemplácelos con valores propios. Puede encontrar estos valores en la [consola de AWS , en la información de su cuenta, en la sección **Credenciales de seguridad**](https://console.aws.amazon.com//iam/home#/security_credentials).
En la ventana **Amazon EC2 Instance Connect**, escriba este comando:
```
aws configure
```
A continuación, introduzca los valores de su cuenta en las instrucciones que se muestran.
```
AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
Default region name [None]: us-west-2
Default output format [None]: json
```
1. Puede probar la AWS CLI configuración con este comando:
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Si AWS CLI está configurada correctamente, el comando debería devolver una dirección de punto final suya Cuenta de AWS.
## Cree AWS IoT recursos para su dispositivo virtual
En esta sección se describe cómo usarlo AWS CLI para crear el objeto objeto y sus archivos de certificado directamente en el dispositivo virtual. Esto se hace directamente en el dispositivo para evitar las posibles complicaciones que podrían surgir al copiarlos al dispositivo desde otro ordenador. En esta sección, creará los siguientes recursos para su dispositivo virtual:
+ Un objeto objeto en el que representar su dispositivo virtual AWS IoT.
+ Un certificado para autenticar su dispositivo virtual.
+ Un documento de política para autorizar al dispositivo virtual a conectarse a AWS IoT, y para publicar, recibir y suscribirse a mensajes.
**Para crear un objeto « AWS IoT cosa» en tu instancia de Linux**
Los dispositivos a los que AWS IoT se conecta se representan mediante *objetos tipo cosa* en el AWS IoT registro. Una *cosa* representa un dispositivo específico o una entidad lógica. En este caso, el *objeto* representará su dispositivo virtual, esta instancia de Amazon EC2.
1. En la ventana **Amazon EC2 Instance Connect**, ejecute el comando que se incluye a continuación para crear su objeto.
```
aws iot create-thing --thing-name "MyIotThing"
```
1. El resultado JSON debe tener el siguiente aspecto:
```
{
"thingArn": "arn:aws:iot:your-region:your-aws-account:thing/MyIotThing",
"thingName": "MyIotThing",
"thingId": "6cf922a8-d8ea-4136-f3401EXAMPLE"
}
```
**Para crear y adjuntar AWS IoT claves y certificados en su instancia de Linux**
El comando **[create-keys-and-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-keys-and-certificate.html)** proporciona certificados de cliente firmado por la entidad emisora de certificados de Amazon Root. Este certificado se utiliza para autenticar la identidad del dispositivo virtual.
1. En la ventana **Amazon EC2 Instance Connect**, cree un directorio para almacenar los archivos de certificados y claves.
```
mkdir ~/certs
```
1. En la ventana **Amazon EC2 Instance Connect**, descargue una copia del certificado de la autoridad de certificación (CA) de Amazon mediante este comando.
```
curl -o ~/certs/Amazon-root-CA-1.pem \
https://www.amazontrust.com/repository/AmazonRootCA1.pem
```
1. En la ventana **Amazon EC2 Instance Connect**, ejecute el siguiente comando para crear los archivos de clave privada, clave pública y certificado X.509. Este comando también registra y activa el certificado con AWS IoT.
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/device.pem.crt" \
--public-key-outfile "~/certs/public.pem.key" \
--private-key-outfile "~/certs/private.pem.key"
```
La respuesta tiene este aspecto: Guarde `certificateArn` para poder utilizarlo en los comandos posteriores. Lo necesitará para asociar el certificado a su objeto y para asociar la política al certificado más adelante.
```
{
"certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
"certificateId": "9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
"certificatePem": "
-----BEGIN CERTIFICATE-----
MIICiTCCEXAMPLE6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
VVMxCzAJBgNVBAgEXAMPLEAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
b24xFDASBgNVBAsTC0lBTSEXAMPLE2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
BgkqhkiG9w0BCQEWEG5vb25lQGFtYEXAMPLEb20wHhcNMTEwNDI1MjA0NTIxWhcN
MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCEXAMPLEJBgNVBAgTAldBMRAwDgYD
VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDAEXAMPLEsTC0lBTSBDb25z
b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEXAMPLE25lQGFt
YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+aEXAMPLE
EXAMPLEfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
rDHudUZEXAMPLELG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
Ibb3OhjZnzcvQAEXAMPLEWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
nUhVVxYUntneD9+h8Mg9qEXAMPLEyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
FFBjvSfpJIlJ00zbhNYS5f6GuoEDEXAMPLEBHjJnyp378OD8uTs7fLvjx79LjSTb
NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\nMMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\n59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\nhJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\nFQIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nkey omitted for security reasons\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. En la ventana **Amazon EC2 Instance Connect**, adjunte su objeto al certificado que acaba de crear mediante el siguiente comando y *certificateArn* en la respuesta del comando anterior.
```
aws iot attach-thing-principal \
--thing-name "MyIotThing" \
--principal "certificateArn"
```
Este comando no devuelve ningún resultado si se realiza correctamente.
**Para crear y asociar una política a un usuario**
1. En la ventana **Amazon EC2 Instance Connect**, cree el archivo de política copiando y pegando este documento de política en un archivo denominado **\$1/policy.json**.
Si no tiene un editor favorito de Linux, puede abrir **nano** con este comando.
```
nano ~/policy.json
```
Pegue el documento de política de `policy.json` en él. Pulse Ctrl-X para salir del editor de **nano** y guardar el archivo.
Contenido del documento de política de `policy.json`.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect"
],
"Resource": [
"*"
]
}
]
}
```
1. En la ventana **Amazon EC2 Instance Connect**, cree su política utilizando el siguiente comando.
```
aws iot create-policy \
--policy-name "MyIotThingPolicy" \
--policy-document "file://~/policy.json"
```
Salida:
****
```
{
"policyName": "MyIotThingPolicy",
"policyArn": "arn:aws:iot:us-east-1:your-aws-account:policy/MyIotThingPolicy",
"policyDocument": "{
\"Version\": \"2012-10-17\",
\"Statement\": [
{
\"Effect\": \"Allow\",
\"Action\": [
\"iot:Publish\",
\"iot:Receive\",
\"iot:Subscribe\",
\"iot:Connect\"
],
\"Resource\": [
\"*\"
]
}
]
}",
"policyVersionId": "1"
}
```
1. En la ventana **Amazon EC2 Instance Connect**, asocie la política al certificado de su dispositivo virtual mediante el siguiente comando.
```
aws iot attach-policy \
--policy-name "MyIotThingPolicy" \
--target "certificateArn"
```
Este comando no devuelve ningún resultado si se realiza correctamente.
## Instale el SDK del AWS IoT dispositivo para JavaScript
En esta sección, instalará el SDK para AWS IoT dispositivos JavaScript, que contiene el código que las aplicaciones pueden usar para comunicarse, así AWS IoT como los programas de muestra. Para obtener más información, consulta el [ JavaScript GitHub repositorio del SDK de AWS IoT dispositivos](https://github.com/aws/aws-iot-device-sdk-js-v2).
**Para instalar el AWS IoT Device SDK for JavaScript en tu instancia de Linux**
1. En la ventana **Amazon EC2 Instance Connect**, clone el AWS IoT Device SDK para el JavaScript repositorio en el `aws-iot-device-sdk-js-v2` directorio de su directorio principal mediante este comando.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Vaya al directorio `aws-iot-device-sdk-js-v2` que creó en el paso anterior.
```
cd aws-iot-device-sdk-js-v2
```
1. Utilice npm para instalar el SDK.
```
npm install
```
## Ejecutar la aplicación de ejemplo
Los comandos de las siguientes secciones suponen que los archivos de clave y certificado se almacenan en el dispositivo virtual, tal y como se muestra en esta tabla.
**Nombres de archivo de certificado**
| Archivos | Ruta de archivo |
| --- | --- |
| Clave privada | `~/certs/private.pem.key` |
| Certificado de dispositivo | `~/certs/device.pem.crt` |
| Certificado de entidad de certificación raíz | `~/certs/Amazon-root-CA-1.pem` |
En esta sección, instalará y ejecutará la aplicación de `pub-sub.js` muestra que se encuentra en el `aws-iot-device-sdk-js-v2/samples/node` directorio del AWS IoT Device SDK for JavaScript. Esta aplicación muestra cómo un dispositivo, su instancia de Amazon EC2, utiliza la biblioteca de MQTT para publicar mensajes MQTT y suscribirse a ellos. La aplicación de `pub-sub.js` de ejemplo se suscribe a un tema,`topic_1`, publica 10 mensajes sobre ese tema y muestra los mensajes tal como los recibe del agente de mensajes.
**Para instalar y ejecutar la aplicación de ejemplo**
1. En la ventana **Amazon EC2 Instance Connect**, navegue hasta el directorio `aws-iot-device-sdk-js-v2/samples/node/pub_sub` que creó el SDK e instale la aplicación de ejemplo con estos comandos.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. En la ventana **Amazon EC2 Instance Connect**, vaya *your-iot-endpoint* desde AWS IoT mediante este comando.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
1. En la ventana **Amazon EC2 Instance Connect**, insértelo *your-iot-endpoint* como se indica y ejecute este comando.
```
node dist/index.js --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
```
La aplicación de ejemplo:
1. Se conecta a AWS IoT Core para su cuenta.
1. Se suscribe al tema de mensaje, **topic\$11**, y muestra los mensajes que recibe sobre ese tema.
1. Publica 10 mensajes sobre el tema, **topic\$11**.
1. Muestra una salida similar a la siguiente:
```
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":1}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":2}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":3}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":4}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":5}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":6}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":7}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":8}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":9}
Publish received. topic:"topic_1" dup:false qos:1 retain:false
{"message":"Hello world!","sequence":10}
```
Si tiene problemas para ejecutar la aplicación de ejemplo, revise [Solución de problemas con la aplicación de ejemplo](gs-device-troubleshoot.md).
También puede agregar el parámetro `--verbosity debug` a la línea de comandos para que la aplicación de ejemplo muestre mensajes detallados sobre lo que está haciendo. Esa información podría proporcionarle la ayuda que necesita para corregir el problema.
## Ve los mensajes de la aplicación de ejemplo en la AWS IoT consola
Puede ver los mensajes de la aplicación de ejemplo a medida que pasan por el agente de mensajes mediante el **cliente de prueba de MQTT** de la **consola de AWS IoT **.
**Para ver los mensajes MQTT publicados por la aplicación de ejemplo**
1. Consulte [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 la opción **Cliente de prueba de MQTT** en la **consola de AWS IoT **.
1. En **Suscribirse a un tema**, suscríbase al tema **topic\$11**.
1. En la ventana **Amazon EC2 Instance Connect**, vuelva a ejecutar la aplicación de ejemplo y observe los mensajes del **cliente de prueba de MQTT** de la **consola de AWS IoT **.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
node dist/index.js --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
```
Para obtener más información sobre MQTT y cómo AWS IoT Core es compatible con el protocolo, consulte [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).
# Utilice su PC o Mac con Windows o Linux como dispositivo AWS IoT
En este tutorial, configurará un ordenador personal para usarlo con AWS IoT. Estas instrucciones son compatibles con Windows, Linux PCs y Mac. Para lograr esto, necesita instalar cierto software en el ordenador. Si no quiere instalar software en su ordenador, puede consultar la sección [Crear un dispositivo virtual con Amazon EC2](creating-a-virtual-thing.md) para saber cómo instalar todo el software en una máquina virtual.
**Topics**
+ [Configurar su ordenador personal](#gs-pc-prereqs)
+ [Instalar Git, Python y el SDK de AWS IoT dispositivos para Python](#gs-pc-sdk-node)
+ [Configurar la política y ejecutar la aplicación de ejemplo](#gs-pc-python-app-run)
+ [Ve los mensajes de la aplicación de ejemplo en la AWS IoT consola](#gs-pc-view-msg)
+ [Ejecutar el ejemplo de suscripción compartida en Python](#gs-pc-shared-subscription-example)
## Configurar su ordenador personal
Para completar este tutorial, necesita un PC con Windows o Linux o un Mac con conexión a internet.
Antes de continuar con el siguiente paso, confirme que puede abrir una ventana de la línea de comandos en el ordenador. Utilice **cmd.exe** en un PC con Windows. En un PC con Linux o un Mac, utilice **Terminal**.
## Instalar Git, Python y el SDK de AWS IoT dispositivos para Python
En esta sección, instalará Python y el SDK de AWS IoT dispositivo para Python en su ordenador.
### Instalar la versión más reciente de Git y Python
Este procedimiento explica cómo instalar la versión más reciente de Git y Python en su ordenador personal.
**Para descargar e instalar Git y Python en su ordenador**
1. Compruebe si tiene Git instalado en el equipo. Introduzca este comando en la línea de comandos.
```
git --version
```
Si el comando muestra la versión de Git, significa que Git está instalado y puede continuar con el paso siguiente.
Si el comando muestra un error, abra [https://git-scm.com/download](https://git-scm.com/download) e instale Git en el ordenador.
1. Compruebe si Python ya está instalado. Introduzca el comando en la línea de comandos.
```
python -V
```
**nota**
Si este comando produce un error, `Python was not found`, puede deberse a que el sistema operativo llama al ejecutable de Python v3.x como `Python3`. En ese caso, sustituya todas las instancias de `python` por `python3` y continúe con el resto de este tutorial.
Si el comando muestra la versión de Python, significa que Python ya está instalado. Este tutorial requiere Python v3.7 o versiones posteriores.
1. Si Python está instalado, puede omitir el resto de los pasos de esta sección. Si no es así, continúe.
1. Abre [https://www.python.org/downloads/](https://www.python.org/downloads/) y descarga el instalador para tu ordenador.
1. Si la descarga no se inició automáticamente, ejecute el programa descargado para instalar Python.
1. Compruebe la instalación de Python.
```
python -V
```
Confirme que el comando muestra la versión de Python. Si no se muestra la versión de Python, pruebe a descargar e instalar Python de nuevo.
### Instalar el SDK AWS IoT del dispositivo para Python
**Para instalar el SDK de AWS IoT dispositivo para Python en su ordenador**
1. Instale la versión 2 del SDK de AWS IoT dispositivos para Python.
```
python3 -m pip install awsiotsdk
```
1. Clona el repositorio AWS IoT Device SDK para Python en el directorio aws-iot-device-sdk -python-v2 de tu directorio principal. Este procedimiento hace referencia al directorio base de los archivos en los que estás instalando. *home*
La ubicación real del *home* directorio depende del sistema operativo.
------
#### [ Linux/macOS ]
En macOS y Linux, el *home* directorio es`~`.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ Windows ]
En Windows, puede encontrar la ruta del *home* directorio ejecutando este comando en la `cmd` ventana.
```
echo %USERPROFILE%
cd %USERPROFILE%
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
**nota**
Si utilizas Windows PowerShell en lugar de hacerlo**cmd.exe**, utiliza el siguiente comando.
```
echo $home
```
Para obtener más información, consulte el [ GitHub repositorio AWS IoT Device SDK para Python](https://github.com/aws/aws-iot-device-sdk-python-v2).
### Preparación antes de ejecutar las aplicaciones de ejemplo
**Para prepararse antes de ejecutar las aplicaciones de ejemplo**
+ Cree el directorio `certs`. En el directorio `certs`, copie los archivos de clave privada, certificado de dispositivo y certificado de entidad de certificación raíz que guardó al crear y registrar el objeto en [Crea AWS IoT recursos](create-iot-resources.md). Los nombres de cada archivo del directorio de destino deben coincidir con los de la tabla.
Los comandos de la siguiente sección suponen que los archivos de clave y certificado se almacenan en el dispositivo como se muestra en esta tabla.
------
#### [ Linux/macOS ]
Ejecute este comando para crear el subdirectorio `certs` que utilizará al ejecutar las aplicaciones de ejemplo.
```
mkdir ~/certs
```
En el nuevo subdirectorio, copie los archivos a las rutas de archivo de destino que se muestran 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/using-laptop-as-device.html)
Ejecute este comando para enumerar los archivos del directorio `certs` y compararlos con los que aparecen en la tabla.
```
ls -l ~/certs
```
------
#### [ Windows ]
Ejecute este comando para crear el subdirectorio `certs` que utilizará al ejecutar las aplicaciones de ejemplo.
```
mkdir %USERPROFILE%\certs
```
En el nuevo subdirectorio, copie los archivos a las rutas de archivo de destino que se muestran 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/using-laptop-as-device.html)
Ejecute este comando para enumerar los archivos del directorio `certs` y compararlos con los que aparecen en la tabla.
```
dir %USERPROFILE%\certs
```
------
## Configurar la política y ejecutar la aplicación de ejemplo
En esta sección, configurará su política y ejecutará el script de ejemplo de `pubsub.py` que se encuentra en el directorio `aws-iot-device-sdk-python-v2/samples` del AWS IoT Device SDK para Python. Este script muestra cómo su dispositivo utiliza la biblioteca de MQTT para publicar y suscribirse a mensajes MQTT.
La aplicación de `pubsub.py` de ejemplo se suscribe a un tema,`test/topic`, publica 10 mensajes sobre ese tema y muestra los mensajes tal como los recibe del agente de mensajes.
Para ejecutar el script de ejemplo de `pubsub.py`, necesita la siguiente información:
**Valores de los parámetros de la aplicación**
| Parámetro | Dónde encontrar el valor |
| --- | --- |
| your-iot-endpoint | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/using-laptop-as-device.html) |
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`.
Antes de ejecutar el script, asegúrese de que la política del objeto proporciona permisos para que el script de ejemplo pueda conectarse, suscribirse, publicar y recibir.
**Para buscar y revisar el documento de política de un recurso de objeto**
1. En la [consola de AWS IoT](https://console.aws.amazon.com//iot/home#/thinghub), en la lista **Objetos**, busque el recurso de objeto que represente a su dispositivo.
1. Seleccione el enlace **Nombre** del recurso de objeto que representa a su dispositivo para abrir la página **Detalles del objeto**.
1. En la página **Detalles del objeto**, en la pestaña **Certificados**, elija el certificado asociado al recurso de objeto. Solo debe haber un certificado en la lista. Si hay más de uno, elija el certificado cuyos archivos estén instalados en el dispositivo y con el que se vaya a conectar a AWS IoT Core.
En la página **Detalles del certificado**, en la pestaña **Políticas**, elija la política asociada al certificado. Solo debe haber una. Si hay más de una, repita el paso siguiente para cada una de ellas con el fin de garantizar que al menos una política conceda el acceso requerido.
1. En la página de descripción general de la **política**, busque el editor de JSON y seleccione **Editar el documento de política** para revisar y editar el documento de política según sea necesario.
1. El JSON de la política se muestra en el siguiente ejemplo. En el `"Resource"` elemento, `region:account` sustitúyalo por el suyo Región de AWS y Cuenta de AWS en cada uno de los `Resource` valores.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/test-*"
]
}
]
}
```
------
#### [ Linux/macOS ]
**Para ejecutar el script de ejemplo en Linux/macOS**
1. En la ventana de la línea de comandos, navegue hasta el directorio `~/aws-iot-device-sdk-python-v2/samples/node/pub_sub` que el SDK creó con estos comandos.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. En la ventana de la línea de comandos, reemplace *your-iot-endpoint* como se indica y ejecute este comando.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key
```
------
#### [ Windows ]
**Para ejecutar la aplicación de ejemplo en un PC con Windows**
1. En la ventana de la línea de comandos, navegue hasta el directorio `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` que el SDK creó e instale la aplicación de ejemplo con estos comandos.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. En la ventana de la línea de comandos, *your-iot-endpoint* sustituya como se indica y ejecute este comando.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key
```
------
El script de ejemplo:
1. Se conecta a la AWS IoT Core de su cuenta.
1. Se suscribe al tema de mensaje, **test/topic**, y muestra los mensajes que recibe sobre ese tema.
1. Publica 10 mensajes sobre el tema **test/topic**.
1. Muestra una salida similar a la siguiente:
```
Connected!
Subscribing to topic 'test/topic'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'test/topic': Hello World! [1]
Received message from topic 'test/topic': b'"Hello World! [1]"'
Publishing message to topic 'test/topic': Hello World! [2]
Received message from topic 'test/topic': b'"Hello World! [2]"'
Publishing message to topic 'test/topic': Hello World! [3]
Received message from topic 'test/topic': b'"Hello World! [3]"'
Publishing message to topic 'test/topic': Hello World! [4]
Received message from topic 'test/topic': b'"Hello World! [4]"'
Publishing message to topic 'test/topic': Hello World! [5]
Received message from topic 'test/topic': b'"Hello World! [5]"'
Publishing message to topic 'test/topic': Hello World! [6]
Received message from topic 'test/topic': b'"Hello World! [6]"'
Publishing message to topic 'test/topic': Hello World! [7]
Received message from topic 'test/topic': b'"Hello World! [7]"'
Publishing message to topic 'test/topic': Hello World! [8]
Received message from topic 'test/topic': b'"Hello World! [8]"'
Publishing message to topic 'test/topic': Hello World! [9]
Received message from topic 'test/topic': b'"Hello World! [9]"'
Publishing message to topic 'test/topic': Hello World! [10]
Received message from topic 'test/topic': b'"Hello World! [10]"'
10 message(s) received.
Disconnecting...
Disconnected!
```
Si tiene problemas para ejecutar la aplicación de ejemplo, revise [Solución de problemas con la aplicación de ejemplo](gs-device-troubleshoot.md).
También puede agregar el parámetro `--verbosity Debug` a la línea de comandos para que la aplicación de ejemplo muestre mensajes detallados sobre lo que está haciendo. Esa información puede ayudarle a corregir el problema.
## Ve los mensajes de la aplicación de ejemplo en la AWS IoT consola
Puede ver los mensajes de la aplicación de ejemplo a medida que pasan por el agente de mensajes mediante el **cliente de prueba de MQTT** de la **consola de AWS IoT **.
**Para ver los mensajes MQTT publicados por la aplicación de ejemplo**
1. Consulte [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 la opción **Cliente de prueba de MQTT** en la **consola de AWS IoT **.
1. En **Suscribirse a un tema**, suscríbase al tema **test/topic**.
1. En su ventana de línea de comandos, ejecute de nuevo la aplicación de ejemplo y observe los mensajes del **cliente MQTT** en la **consola de AWS IoT **.
------
#### [ Linux/macOS ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic test/topic --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
#### [ Windows ]
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
python3 pubsub.py --topic test/topic --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --endpoint your-iot-endpoint
```
------
Para obtener más información sobre MQTT y cómo AWS IoT Core es compatible con el protocolo, consulte [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).
## Ejecutar el ejemplo de suscripción compartida en Python
AWS IoT Core admite [suscripciones compartidas](mqtt.md#mqtt5-shared-subscription) para MQTT 3 y MQTT 5. Las suscripciones compartidas permiten que varios clientes compartan una suscripción a un tema y solo un cliente recibirá los mensajes publicados sobre ese tema mediante una distribución aleatoria. Para usar las suscripciones compartidas, los clientes se suscriben al [filtro de temas](https://docs.aws.amazon.com//iot/latest/developerguide/topics.html#topicfilters) de una suscripción compartida: `$share/{ShareName}/{TopicFilter}`.
**Para configurar la política y ejecutar el ejemplo de suscripción compartida**
1. Para ejecutar el ejemplo de suscripción compartida, debe configurar la política de su empresa tal y como se describe en la [Suscripción compartida de MQTT 5](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription).
1. Para ejecutar el ejemplo de suscripción compartida, ejecute los siguientes comandos.
------
#### [ Linux/macOS ]
**Para ejecutar el script de ejemplo en Linux/macOS**
1. En la ventana de la línea de comandos, navegue hasta el directorio `~/aws-iot-device-sdk-python-v2/samples` que el SDK creó con estos comandos.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. En la ventana de la línea de comandos, *your-iot-endpoint* sustituya como se indica y ejecute este comando.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --group_identifier consumer
```
------
#### [ Windows ]
**Para ejecutar la aplicación de ejemplo en un PC con Windows**
1. En la ventana de la línea de comandos, navegue hasta el directorio `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples` que el SDK creó e instale la aplicación de ejemplo con estos comandos.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. En la ventana de la línea de comandos, *your-iot-endpoint* sustituya como se indica y ejecute este comando.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --group_identifier consumer
```
------
**nota**
Si lo desea, puede especificar un identificador de grupo en función de sus necesidades al ejecutar la muestra (por ejemplo, `--group_identifier consumer`). Si no especifica uno, `python-sample` es el identificador de grupo predeterminado.
1. El resultado de la línea de comandos puede ser similar al siguiente:
```
Publisher]: Lifecycle Connection Success
[Publisher]: Connected
Subscriber One]: Lifecycle Connection Success
[Subscriber One]: Connected
Subscriber Two]: Lifecycle Connection Success
[Subscriber Two]: Connected
[Subscriber One]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Subscriber Two]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [1]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [2]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [3]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [4]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [5]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [6]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [7]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [8]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [9]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [10]"'
[Subscriber One]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code: []
[Subscriber Two]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code []
Publisher]: Lifecycle Disconnected
[Publisher]: Lifecycle Stopped
[Publisher]: Fully stopped
Subscriber One]: Lifecycle Disconnected
[Subscriber One]: Lifecycle Stopped
[Subscriber One]: Fully stopped
Subscriber Two]: Lifecycle Disconnected
[Subscriber Two]: Lifecycle Stopped
[Subscriber Two]: Fully stopped
Complete!
```
1. Abra el **cliente de prueba de MQTT** en la **consola de AWS IoT **. En **Suscribirse a un tema**, suscríbase al tema de la suscripción compartida: `$share/consumer/test/topic`. Puede especificar un identificador de grupo en función de sus necesidades al ejecutar la muestra (por ejemplo, `--group_identifier consumer`). Si no especifica uno, el valor predeterminado es `python-sample`. Para obtener más información, consulte el [Ejemplo de Python de suscripción compartida de MQTT 5](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription) y [Suscripciones compartidas](mqtt.md#mqtt5-shared-subscription) en la *Guía de AWS IoT Core para desarrolladores*.
En la ventana de la línea de comandos, ejecute de nuevo la aplicación de ejemplo y observe la distribución de mensajes en el **cliente de prueba de MQTT** de la **consola de AWS IoT ** y de la línea de comandos.
![\[Página de resultados de las suscripciones compartidas.\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/images/shared-subscription-output.png)
# Conexión de una Raspberry Pi u otro dispositivo
En esta sección, configuraremos una Raspberry Pi para usarla con AWS IoT. Si tiene otro dispositivo que gustaría conectar, las instrucciones de la Raspberry Pi incluyen referencias que pueden ayudarlo a adaptar estas instrucciones a otros dispositivos.
Normalmente se tarda unos 20 minutos, pero puede tardar más si tiene que instalar muchas actualizaciones del software del sistema.
**Topics**
+ [Configuración del dispositivo](#gs-device-prereqs)
+ [Instale las herramientas y bibliotecas necesarias para el SDK del AWS IoT dispositivo](#gs-device-sdk-tools)
+ [Instala AWS IoT el SDK del dispositivo](#gs-device-install-sdk)
+ [Instalar y ejecutar la aplicación de ejemplo](#gs-device-node-app-run)
+ [Vea los mensajes de la aplicación de ejemplo en la AWS IoT consola](#gs-device-view-msg)
**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 tienes dificultades al configurar tu dispositivo AWS IoT, puedes probar una de las otras opciones del dispositivo como alternativa, como [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).
## Configuración del dispositivo
El objetivo de este paso es recopilar todo lo necesario para configurar su dispositivo 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.
Necesitará lo siguiente para completar este tutorial:
+ Y Cuenta de AWS. Si no la tiene, complete los pasos que se describen en [Configurar Cuenta de AWS](setting-up.md) antes de continuar.
+ Una [Raspberry Pi 3 Modelo B](https://www.raspberrypi.com/products/) o un modelo más reciente. Esto podría funcionar en versiones anteriores de Raspberry Pi, pero no se han 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. Esto podría funcionar en versiones anteriores de Raspberry Pi, pero no se han probado.
Para ejecutar este ejemplo, no necesita instalar el escritorio con la interfaz gráfica de usuario (GUI); sin embargo, si es la primera vez que utiliza Raspberry Pi y su hardware de Raspberry Pi lo admite, utilizar el escritorio con la GUI puede resultar más fácil.
+ Una WiFi conexión Ethernet o.
+ Teclado, ratón, monitor, cables, fuentes de alimentación y demás hardware que necesite el dispositivo.
**importante**
Antes de continuar con el siguiente paso, el sistema operativo del dispositivo debe estar instalado, configurado y en funcionamiento. El dispositivo debe estar conectado a internet y deberá poder acceder al dispositivo mediante su interfaz de línea de comandos. El acceso a través de la línea de comandos se puede realizar mediante un teclado, un ratón y un monitor conectados directamente, o mediante una interfaz remota de terminal SSH.
Si utiliza un sistema operativo en la Raspberry Pi que tiene una interfaz gráfica de usuario (GUI), abra una ventana del terminal en el dispositivo y siga estas instrucciones en la ventana. De lo contrario, si se conecta al dispositivo mediante un terminal remoto, como PuTTY, abra un terminal remoto en el dispositivo y úselo.
## Instale las herramientas y bibliotecas necesarias para el SDK del AWS IoT dispositivo
Antes de instalar el SDK del AWS IoT dispositivo y el código de muestra, asegúrese de que el sistema esté actualizado y de que disponga de las herramientas y bibliotecas necesarias para instalarlo SDKs.
1.
**Actualizar el sistema operativo e instalar las bibliotecas necesarias**
Antes de instalar un SDK para AWS IoT dispositivos, ejecuta estos comandos en una ventana de terminal del dispositivo para actualizar el sistema operativo e instalar las bibliotecas necesarias.
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install cmake
```
```
sudo apt-get install libssl-dev
```
1.
**Instalar Git**
Si el sistema operativo de tu dispositivo no incluye Git instalado, debes instalarlo para instalar el SDK del AWS IoT dispositivo JavaScript.
1. Ejecute este comando para comprobar si Git ya está instalado.
```
git --version
```
1. Si el comando anterior devuelve la versión de Git, significa que Git ya está instalado y puede ir directamente al paso 3.
1. Si aparece un error al ejecutar el comando **git**, instale Git ejecutando este comando.
```
sudo apt-get install git
```
1. Ejecute este comando para volver a comprobar si Git está instalado.
```
git --version
```
1. Si Git está instalado, vaya a la siguiente sección. Si no es así, solucione el problema y corrija el error antes de continuar. Necesitas Git para instalar el SDK del AWS IoT dispositivo JavaScript.
## Instala AWS IoT el SDK del dispositivo
Instale el SDK AWS IoT del dispositivo.
------
#### [ Python ]
En esta sección, instalará Python, sus herramientas de desarrollo y el SDK de AWS IoT dispositivos para Python en su dispositivo. Estas instrucciones son para una Raspberry Pi que ejecute la versión más reciente del sistema operativo Raspberry Pi. Si tiene otro dispositivo o utiliza otro sistema operativo, es posible que tenga que adaptar estas instrucciones a su dispositivo.
1.
**Instalar Python y sus herramientas de desarrollo**
El SDK de AWS IoT dispositivo para Python requiere que Python v3.5 o posterior esté instalado en tu Raspberry Pi.
En una ventana del terminal de su dispositivo, ejecute estos comandos.
1. Ejecute este comando para determinar la versión de Python instalada en el dispositivo.
```
python3 --version
```
Si Python está instalado, mostrará su versión.
1. Si la versión que se muestra es `Python 3.5` o superior, puede ir directamente al paso 2.
1. Si la versión que se muestra es inferior a `Python 3.5`, puede instalar la versión correcta ejecutando este comando.
```
sudo apt install python3
```
1. Ejecute este comando para confirmar que ahora está instalada la versión correcta de Python.
```
python3 --version
```
1.
**Prueba de pip3**
En una ventana del terminal de su dispositivo, ejecute estos comandos.
1. Ejecute este comando para comprobar si **pip3** está instalado.
```
pip3 --version
```
1. Si el comando devuelve un número de versión, significa que **pip3** está instalado y puede ir al paso 3.
1. Si el comando anterior devuelve un error, ejecute este comando para instalar **pip3**.
```
sudo apt install python3-pip
```
1. Ejecute este comando para comprobar si **pip3** está instalado.
```
pip3 --version
```
1.
**Instalar el SDK de AWS IoT dispositivo actual para Python**
Instala el SDK de AWS IoT dispositivos para Python y descarga las aplicaciones de muestra en tu dispositivo.
En el dispositivo, ejecute estos comandos.
```
cd ~
python3 -m pip install awsiotsdk
```
```
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ JavaScript ]
En esta sección, instalarás Node.js, el administrador de paquetes npm y el SDK para AWS IoT dispositivos JavaScript en tu dispositivo. Estas instrucciones son para una Raspberry Pi que ejecute el sistema operativo Raspberry Pi. Si tiene otro dispositivo o utiliza otro sistema operativo, es posible que tenga que adaptar estas instrucciones a su dispositivo.
1.
**Instale la versión más reciente de Node.js.**
El SDK del AWS IoT dispositivo JavaScript requiere que Node.js y el administrador de paquetes npm estén instalados en tu Raspberry Pi.
1. Descargue la última versión del repositorio de Node mediante el siguiente comando.
```
cd ~
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
```
1. Instale Node y npm.
```
sudo apt-get install -y nodejs
```
1. Verifique la instalación de Node.
```
node -v
```
Confirme que el comando muestra la versión de Node. Este tutorial requiere la versión Node v10.0 o posterior. Si no se muestra la versión de Node, pruebe a descargar de nuevo el repositorio de Node.
1. Verifique la instalación de npm.
```
npm -v
```
Confirme que el comando muestra la versión de npm. Si no se muestra la versión de npm, pruebe a instalar Node y npm de nuevo.
1. Reinicie el dispositivo.
```
sudo shutdown -r 0
```
Continúe después de que se reinicie el dispositivo.
1.
**Instale el SDK del AWS IoT dispositivo para JavaScript**
Instala el SDK del AWS IoT dispositivo JavaScript en tu Raspberry Pi.
1. Clona el SDK del AWS IoT dispositivo para el JavaScript repositorio en el `aws-iot-device-sdk-js-v2` directorio de tu *home* directorio. En la Raspberry Pi`~/`, el *home* directorio es el que se utiliza como *home* directorio en los siguientes comandos. Si su dispositivo usa una ruta diferente para el *home* directorio, debe `~/` reemplazarla por la ruta correcta para su dispositivo en los siguientes comandos.
Estos comandos crean el directorio `~/aws-iot-device-sdk-js-v2` y copian el código del SDK en él.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Cambie al directorio `aws-iot-device-sdk-js-v2` que creó en el paso anterior y ejecute `npm install` para instalar el SDK. El comando `npm install` invocará la creación de la biblioteca `aws-crt`, que puede tardar algunos minutos en completarse.
```
cd ~/aws-iot-device-sdk-js-v2
npm install
```
------
## Instalar y ejecutar la aplicación de ejemplo
En esta sección, instalarás y ejecutarás la aplicación de `pubsub` muestra que se encuentra en el SDK del AWS IoT dispositivo. Esta aplicación muestra cómo su dispositivo utiliza la biblioteca de MQTT para publicar y suscribirse a mensajes MQTT. La aplicación de ejemplo se suscribe a un tema, `topic_1`, publica 10 mensajes sobre ese tema y muestra los mensajes tal como los recibe del agente de mensajes.
**Instalar los archivos de certificado**
La aplicación de ejemplo requiere que los archivos de certificado que autentican el dispositivo estén instalados en el dispositivo.
**Para instalar los archivos de certificado del dispositivo para la aplicación de ejemplo**
1. Crea un `certs` subdirectorio en tu *home* directorio ejecutando estos comandos.
```
cd ~
mkdir certs
```
1. En el directorio `~/certs`, copie la clave privada, el certificado de entidad de certificación del dispositivo y el certificado de entidad de certificación raíz que creó anteriormente en [Crea AWS IoT recursos](create-iot-resources.md).
La forma de copiar los archivos de certificado en el dispositivo depende del dispositivo y del sistema operativo, y no se describe aquí. Sin embargo, si el dispositivo admite una interfaz gráfica de usuario (GUI) y tiene un navegador web, puede realizar el procedimiento descrito en [Crea AWS IoT recursos](create-iot-resources.md) en el navegador web del dispositivo para descargar los archivos resultantes directamente al dispositivo.
Los comandos de la siguiente sección suponen que los archivos de clave y certificado se almacenan en el dispositivo como se muestra en esta tabla.
**Nombres de archivo de certificado**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/iot/latest/developerguide/connecting-to-existing-device.html)
Para ejecutar la aplicación de ejemplo, necesita la siguiente información:
**Valores de los parámetros de la aplicación**
| Parámetro | Dónde encontrar el valor |
| --- | --- |
| your-iot-endpoint | En la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), seleccione **Todos los dispositivos** y, a continuación, **Objetos**. En la página **Configuración** del menú de AWS IoT . Su punto de conexión aparece en la sección **Punto de enlace de datos de dispositivo**. |
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`.
------
#### [ Python ]
**Para 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
```
1. En la ventana de la línea de comandos, *your-iot-endpoint* sustituya como se indica y ejecute este comando.
```
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
```
1. Observe que la aplicación de ejemplo:
1. Se conecta al AWS IoT servicio de su cuenta.
1. Se suscribe al tema de mensaje, **topic\$11**, y muestra los mensajes que recibe sobre ese tema.
1. Publica 10 mensajes sobre el tema, **topic\$11**.
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 topic 'topic_1'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'topic_1': Hello World! [1]
Received message from topic 'topic_1': b'Hello World! [1]'
Publishing message to topic 'topic_1': Hello World! [2]
Received message from topic 'topic_1': b'Hello World! [2]'
Publishing message to topic 'topic_1': Hello World! [3]
Received message from topic 'topic_1': b'Hello World! [3]'
Publishing message to topic 'topic_1': Hello World! [4]
Received message from topic 'topic_1': b'Hello World! [4]'
Publishing message to topic 'topic_1': Hello World! [5]
Received message from topic 'topic_1': b'Hello World! [5]'
Publishing message to topic 'topic_1': Hello World! [6]
Received message from topic 'topic_1': b'Hello World! [6]'
Publishing message to topic 'topic_1': Hello World! [7]
Received message from topic 'topic_1': b'Hello World! [7]'
Publishing message to topic 'topic_1': Hello World! [8]
Received message from topic 'topic_1': b'Hello World! [8]'
Publishing message to topic 'topic_1': Hello World! [9]
Received message from topic 'topic_1': b'Hello World! [9]'
Publishing message to topic 'topic_1': Hello World! [10]
Received message from topic 'topic_1': b'Hello World! [10]'
10 message(s) received.
Disconnecting...
Disconnected!
```
Si tiene problemas para ejecutar la aplicación de ejemplo, revise [Solución de problemas con la aplicación de ejemplo](gs-device-troubleshoot.md).
También puede agregar el parámetro `--verbosity Debug` a la línea de comandos para que la aplicación de ejemplo muestre mensajes detallados sobre lo que está haciendo. Esa información podría proporcionarle la ayuda que necesita para corregir el problema.
------
#### [ JavaScript ]
**Para instalar y ejecutar la aplicación de ejemplo**
1. En la ventana de la línea de comandos, navegue hasta el directorio `~/aws-iot-device-sdk-js-v2/samples/node/pub_sub` que el SDK creó e instale la aplicación de ejemplo con estos comandos. El comando `npm install` invocará la creación de la biblioteca `aws-crt`, que puede tardar algunos minutos en completarse.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. En la ventana de la línea de comandos, reemplace *your-iot-endpoint* como se indica y ejecute este comando.
```
node dist/index.js --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
```
1. Observe que la aplicación de ejemplo:
1. Se conecta al AWS IoT servicio de su cuenta.
1. Se suscribe al tema de mensaje, **topic\$11**, y muestra los mensajes que recibe sobre ese tema.
1. Publica 10 mensajes sobre el tema, **topic\$11**.
1. Muestra una salida similar a la siguiente:
```
Publish received on topic topic_1
{"message":"Hello world!","sequence":1}
Publish received on topic topic_1
{"message":"Hello world!","sequence":2}
Publish received on topic topic_1
{"message":"Hello world!","sequence":3}
Publish received on topic topic_1
{"message":"Hello world!","sequence":4}
Publish received on topic topic_1
{"message":"Hello world!","sequence":5}
Publish received on topic topic_1
{"message":"Hello world!","sequence":6}
Publish received on topic topic_1
{"message":"Hello world!","sequence":7}
Publish received on topic topic_1
{"message":"Hello world!","sequence":8}
Publish received on topic topic_1
{"message":"Hello world!","sequence":9}
Publish received on topic topic_1
{"message":"Hello world!","sequence":10}
```
Si tiene problemas para ejecutar la aplicación de ejemplo, revise [Solución de problemas con la aplicación de ejemplo](gs-device-troubleshoot.md).
También puede agregar el parámetro `--verbosity Debug` a la línea de comandos para que la aplicación de ejemplo muestre mensajes detallados sobre lo que está haciendo. Esa información podría proporcionarle la ayuda que necesita para corregir el problema.
------
## Vea los mensajes de la aplicación de ejemplo en la AWS IoT consola
Puede ver los mensajes de la aplicación de ejemplo a medida que pasan por el agente de mensajes mediante el **cliente de prueba de MQTT** de la **consola de AWS IoT **.
**Para ver los mensajes MQTT publicados por la aplicación de ejemplo**
1. Consulte [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 la opción **Cliente de prueba de MQTT** en la **consola de AWS IoT **.
1. Para suscribirse al tema **topic\$11**.
1. En su ventana de línea de comandos, ejecute de nuevo la aplicación de ejemplo y observe los mensajes del **cliente MQTT** en la **consola de AWS IoT **.
------
#### [ Python ]
```
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
```
------
#### [ JavaScript ]
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
node dist/index.js --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
```
------
# Solución de problemas con la aplicación de ejemplo
Si se produce un error al intentar ejecutar la aplicación de ejemplo, compruebe lo siguiente.
## Compruebe el certificado
Si el certificado no está activo, AWS IoT no aceptará ningún intento de conexión que lo utilice para la autorización. Al crear el certificado, es fácil pasar por alto el botón **Activar**. Afortunadamente, es posible activar el certificado desde la [consola de AWS IoT](https://console.aws.amazon.com/iot/home).
**Para comprobar la activación del certificado**
1. En la [consola de AWS IoT](https://console.aws.amazon.com/iot/home), en el menú de la izquierda, seleccione **Seguridad** y, a continuación, **Certificados**.
1. En la lista de certificados, busque el certificado que creó para el ejercicio y compruebe su estado en la columna **Estado**.
Si no recuerda el nombre del certificado, compruebe si hay alguno que esté **inactivo** para ver si es el que está utilizando.
Seleccione el certificado de la lista para abrir su página de detalles. En la página de detalles, puede ver su **fecha de creación** para ayudarle a identificar el certificado.
1. **Para activar un certificado inactivo**, en la página de detalles del certificado, elija **Acciones** y, a continuación, seleccione **Activar**.
Si ha encontrado el certificado correcto y está activo, pero sigue teniendo problemas para ejecutar la aplicación de ejemplo, consulte su política, tal y como se describe en el siguiente paso.
También puede intentar crear un objeto y un certificado nuevo siguiendo los pasos que se indican en [Crear un objeto](create-iot-resources.md#create-aws-thing). Si crea un nuevo objeto, tendrá que asignarle un nombre nuevo y descargar los nuevos archivos de certificado en su dispositivo.
## Comprobación de la política asociada al certificado
Las políticas autorizan las acciones en AWS IoT. Si el certificado utilizado para conectarse a AWS IoT no tiene una política o no tiene una política que le permita conectarse, se rechazará la conexión, incluso si el certificado está activo.
**Para comprobar las políticas asociadas al certificado**
1. Busque el certificado tal y como se describe en el punto anterior y abra su página de detalles.
1. En el menú de la izquierda de la página de detalles del certificado, seleccione **Políticas** para ver las políticas asociadas al certificado.
1. Si no hay políticas asociadas al certificado, agregue una seleccionando el menú **Acciones** y, a continuación, **Asociar política**.
Elija la política que creó anteriormente en [Crea AWS IoT recursos](create-iot-resources.md).
1. Si hay una política asociada, elija el mosaico de la política para abrir su página de detalles.
En la página de detalles, revise el **documento de política** para asegurarse de que contiene la misma información que la que creó en [Cree una AWS IoT política](create-iot-resources.md#create-iot-policy).
## Comprobación de la línea de comandos
Asegúrese de haber utilizado la línea de comandos correcta para su sistema. Los comandos que se utilizan en los sistemas Linux y macOS suelen ser diferentes de los que se utilizan en los sistemas Windows.
## Comprobación de la dirección del punto de conexión
Revise el comando introducido y compruebe que la dirección del punto de conexión del comando coincide con la de la [consola de AWS IoT](https://console.aws.amazon.com/iot/home).
## Comprobación de los nombres de los archivos de certificado
Compare los nombres de los archivos del comando que introdujo con los nombres de los archivos de certificado del directorio `certs`.
Es posible que algunos sistemas requieran que los nombres de los archivos estén entre comillas para que funcionen correctamente.
## Comprobación de la instalación del SDK
Asegúrese de que la instalación del SDK haya finalizado correctamente.
En caso de duda, vuelva a instalar el SDK en el dispositivo. En la mayoría de los casos, basta con encontrar la sección del tutorial titulada **Instalar el SDK del AWS IoT dispositivo **SDK language**** y volver a seguir el procedimiento.
Si utilizas el **SDK para AWS IoT dispositivos JavaScript**, recuerda instalar las aplicaciones de muestra antes de intentar ejecutarlas. Al instalar el SDK no se instalan automáticamente las aplicaciones de ejemplo. Las aplicaciones de ejemplo se deben instalar manualmente después de instalar el SDK.