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