AWS IoT Core

Guía para desarrolladores

 AWS IoT Core Guía para desarrolladores

AWS IoT Core: Guía para desarrolladores

Copyright © 2023 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Las marcas comerciales y la imagen comercial de Amazon no se pueden utilizar en relación con ningún producto o
servicio que no sea de Amazon de ninguna manera que pueda causar confusión entre los clientes y que menosprecie
o desacredite a Amazon. Todas las demás marcas comerciales que no sean propiedad de Amazon son propiedad de
sus respectivos propietarios, que pueden o no estar afiliados, conectados o patrocinados por Amazon.
 AWS IoT Core Guía para desarrolladores

Table of Contents
¿Qué es AWS IoT? ............................................................................................................................ 1
Cómo acceden tus dispositivos y aplicacionesAWS IoT .................................................................... 1
QuéAWS IoTpuede hacer ............................................................................................................ 2
IoT en la industria .............................................................................................................. 2
IoT en la automatización del hogar ....................................................................................... 3
Cómo funciona AWS IoT ............................................................................................................. 3
El universo IoT ................................................................................................................... 3
AWS IoTdescripción general de los servicios .......................................................................... 6
Servicios de AWS IoT Core ................................................................................................. 9
Obtener más información sobre AWS IoT ..................................................................................... 12
Recursos de formación paraAWS IoT .................................................................................. 12
AWS IoTrecursos y guías .................................................................................................. 12
AWS IoTen las redes sociales ............................................................................................ 13
AWSservicios utilizados porAWS IoT Coremotor de reglas ...................................................... 13
Protocolos de comunicación compatibles conAWS IoT Core .................................................... 14
Novedades de laAWS IoT consola de de de de de de la de de ........................................................ 14
Leyenda .......................................................................................................................... 16
Introducción a AWS IoT Core ............................................................................................................. 18
Conecta tu primer dispositivo aAWS IoT Core ............................................................................... 18
Configura tuCuenta de AWS ...................................................................................................... 19
Registro en una Cuenta de AWS ........................................................................................ 19
Crear un usuario administrativo ........................................................................................... 20
Abra elAWS IoTconsola ..................................................................................................... 20
Pruebe elAWS IoT Coretutorial interactivo .................................................................................... 21
Conexión de dispositivos de IoT ......................................................................................... 21
Guardar el estado del dispositivo sin conexión ...................................................................... 22
Enrutamiento de los datos del dispositivo a los servicios ......................................................... 23
Pruebe elAWS IoTconexión rápida .............................................................................................. 23
Paso 1. Iniciar el tutorial .................................................................................................... 24
Paso 2. Crea una cosa (objeto) .......................................................................................... 24
Paso 3. Descarga archivos a tu dispositivo ........................................................................... 27
Paso 4. Ejecute la muestra ................................................................................................ 29
Paso 5. Explore más ......................................................................................................... 33
Probar la conectividad con el terminal de datos de su dispositivo ............................................. 33
ExploreAWS IoT Coreservicios en un tutorial práctico ..................................................................... 37
¿Qué opción de dispositivo es la mejor para ti? .................................................................... 38
CrearAWS IoTrecursos ...................................................................................................... 39
Configuración del dispositivo .............................................................................................. 42
Ver los mensajes MQTT con el cliente MQTT de AWS IoT .............................................................. 69
Visualización de mensajes MQTT en el cliente MQTT ............................................................ 69
Publicación de mensajes MQTT desde el cliente MQTT .......................................................... 71
Prueba de suscripciones compartidas en el cliente MQTT ....................................................... 72
Conexión a AWS IoT Core ................................................................................................................. 74
AWS IoT Core- puntos finales del plano de control ........................................................................ 74
AWS IoTpuntos finales del dispositivo .......................................................................................... 75
AWS IoT CoreporLoRaPuertas de enlace y dispositivos WAN .......................................................... 76
Conectarse aAWS IoT Corepuntos finales de servicio .................................................................... 77
AWS CLI para AWS IoT Core ............................................................................................ 77
SDK de AWS ................................................................................................................... 78
AWS Mobile SDK ............................................................................................................. 82
API REST delAWS IoT Coreservicios .................................................................................. 82
Conexión de dispositivos aAWS IoT ............................................................................................ 83
AWS IoTpuntos finales de servicio y datos del dispositivo ....................................................... 83
SDK de dispositivos de AWS IoT ........................................................................................ 85

iii
 AWS IoT Core Guía para desarrolladores

Protocolos de comunicación de dispositivos .......................................................................... 87

Temas de MQTT ............................................................................................................. 112
Terminales configurables .................................................................................................. 128
Conectarse aAWS IoTTerminales FIPS ...................................................................................... 136
AWS IoT Core- puntos finales del plano de control ............................................................... 137
AWS IoT Core- puntos finales del plano de datos ................................................................ 137
AWS IoT Device Management- puntos finales de datos de trabajos ......................................... 137
AWS IoT Device Management- Terminales Fleet Hub ........................................................... 138
AWS IoT Device Management- puntos finales de tunelización seguros .................................... 138
Tutoriales de AWS IoT ..................................................................................................................... 139
Creación de demostraciones con elAWS IoTCliente del dispositivo ................................................. 139
Requisitos previos para crear demostraciones con elAWS IoTCliente del dispositivo ................... 140
Preparación de los dispositivos para elAWS IoTCliente del dispositivo ..................................... 141
Instalar y configurar elAWS IoTCliente del dispositivo ........................................................... 151
Demostrar la comunicación de mensajes MQTT con elAWS IoTCliente del dispositivo ................ 160
Demuestre acciones remotas (trabajos) con elAWS IoTDispositivo de cliente ............................ 174
Limpieza ........................................................................................................................ 184
Creación de soluciones con elAWS IoTSDKs de dispositivos ......................................................... 191
Comience a crear soluciones con elAWS IoTSDKs de dispositivos .......................................... 191
Conectar un dispositivo aAWS IoT Core mediante el SDK deAWS IoT dispositivos .................... 191
CreandoAWS IoTreglas para enrutar los datos del dispositivo a otros servicios ......................... 208
Conservación del estado del dispositivo mientras el dispositivo está desconectado con Device
Shadows ........................................................................................................................ 238
Crear un autorizador personalizado para AWS IoT Core ........................................................ 259
Monitorización de la humedad del suelo con unaAWS IoT Raspberry Pi ................................... 271
Administración de dispositivos con AWS IoT ....................................................................................... 281
Cómo administrar objetos con el registro .................................................................................... 281
Creación de un objeto ..................................................................................................... 282
Lista de objetos .............................................................................................................. 282
Describe las cosas .......................................................................................................... 283
Actualización de un objeto ................................................................................................ 284
Eliminación de un objeto .................................................................................................. 284
Asociar un principal a un objeto ........................................................................................ 284
Desvincular un principal de un objeto ................................................................................. 285
Tipos de objeto ....................................................................................................................... 285
Creación de un tipo de objeto ........................................................................................... 285
Lista de los tipos de objeto ............................................................................................... 286
Descripción de un tipo de objeto ....................................................................................... 286
Asociación de un tipo de objeto a un objeto ........................................................................ 286
Descartar un tipo de objeto .............................................................................................. 287
Eliminación de un tipo de objeto ........................................................................................ 288
Grupos de objetos estáticos ..................................................................................................... 288
Crear un grupo de objetos estático .................................................................................... 289
Descripción de un grupo de objetos ................................................................................... 290
Agregar un objeto a un grupo de objetos estático ................................................................ 291
Eliminar un objeto de un grupo de objetos estático ............................................................... 291
Enumerar los objetos en un grupo de objetos ...................................................................... 291
Enumeración de grupos de objetos .................................................................................... 292
Enumerar grupos para un objeto ....................................................................................... 293
Actualizar un grupo de objetos estático .............................................................................. 294
Eliminación de un grupo de objetos ................................................................................... 294
Asociar una política a un grupo de objetos estático .............................................................. 294
Desconectar una política de un grupo de objetos estático ...................................................... 295
Mostrar las políticas asociadas a un grupo de objetos estático ............................................... 295
Enumeración de los grupos para una política ...................................................................... 296
Obtención de políticas en vigor para un objeto .................................................................... 296
Prueba de autorización para acciones de MQTT .................................................................. 297

iv
 AWS IoT Core Guía para desarrolladores

Grupos de objetos dinámicos .................................................................................................... 298

Crear un grupo de objetos dinámico .................................................................................. 299
Describir un grupo de objetos dinámico .............................................................................. 299
Actualizar un grupo de objetos dinámico ............................................................................. 300
Eliminar un grupo de objetos dinámico ............................................................................... 300
Limitaciones y conflictos ................................................................................................... 301
Etiquetado de los recursos de AWS IoT ............................................................................................. 304
Conceptos básicos de etiquetas ................................................................................................ 304
Restricciones y limitaciones en las etiquetas ....................................................................... 305
Uso de etiquetas con políticas de IAM ....................................................................................... 305
Grupos de facturación .............................................................................................................. 307
Visualización de datos de uso y asignación de costos .......................................................... 308
Seguridad ...................................................................................................................................... 309
Seguridad en AWS IoT ............................................................................................................ 309
Autenticación .......................................................................................................................... 310
AWS Training and Certification .......................................................................................... 310
Información general del certificado X.509 ............................................................................ 311
Autenticación del servidor ................................................................................................. 311
Autenticación del cliente ................................................................................................... 313
Autenticación y autorización a la medida ............................................................................ 337
Autorización ............................................................................................................................ 349
AWS Training and Certification .......................................................................................... 351
Políticas de AWS IoT Core ............................................................................................... 351
Autorizar llamadas directas aAWSservicios de uso deAWS IoT Coreproveedor de credenciales .... 395
Acceso cruzado a cuentas con IAM ................................................................................... 400
Protección de los datos ............................................................................................................ 401
Cifrado de datos en AWS IoT ........................................................................................... 402
Seguridad de transporte en AWS IoT Core ......................................................................... 402
Cifrado de datos ............................................................................................................. 406
Administración de identidades y accesos .................................................................................... 407
Público .......................................................................................................................... 407
Autenticar a través de las identidades de IAM ..................................................................... 407
Administración de acceso mediante políticas ....................................................................... 410
Cómo AWS IoT funciona con IAM ..................................................................................... 411
Ejemplos de políticas basadas en identidad ........................................................................ 429
Políticas administradas de AWS ........................................................................................ 432
Solución de problemas ..................................................................................................... 442
Registro y monitorización ......................................................................................................... 444
Herramientas de monitorización ......................................................................................... 444
Validación de conformidad ........................................................................................................ 445
Resiliencia .............................................................................................................................. 446
Uso de AWS IoT Core con puntos de enlace de la VPC ............................................................... 446
Creación de puntos de enlace de la VPC para AWS IoT Core ................................................ 447
Control de acceso aAWS IoT Corea través de puntos de conexión de VPC .............................. 449
Limitaciones de los terminales de VPC ............................................................................... 450
Escalar los puntos finales de VPC con IoT Core .................................................................. 450
Uso de dominios personalizados con puntos de enlace de VPC ............................................. 450
Disponibilidad de los puntos de conexión de la VPC a través deAWS IoT Core ......................... 450
Seguridad de infraestructuras .................................................................................................... 450
Supervisión de la seguridad ...................................................................................................... 451
Prácticas recomendadas de seguridad ....................................................................................... 451
Protección de conexiones MQTT en AWS IoT ..................................................................... 451
Mantener sincronizado el reloj del dispositivo ...................................................................... 453
Validar el certificado de servidor ........................................................................................ 454
Usar una identidad única por dispositivo ............................................................................. 454
Utilice un segundoRegión de AWScomo respaldo ................................................................ 454
Usar aprovisionamiento justo a tiempo ............................................................................... 455

v
 AWS IoT Core Guía para desarrolladores

Permisos para ejecutarAWS IoTPruebas de Device Advisor ................................................... 455

La prevención para Device Advisor para Device Advisor ....................................................... 456
AWS Training and Certification .................................................................................................. 457
Monitorización de AWS IoT .............................................................................................................. 458
Configuración de registros de AWS IoT ...................................................................................... 459
Configuración del rol y la política de registro ....................................................................... 459
Configure el registro predeterminado en AWS IoT (consola) ................................................... 461
Configurar el registro predeterminado en AWS IoT (CLI) ....................................................... 462
Configurar el inicio de sesión específico de recursos en AWS IoT (CLI) ................................... 464
Niveles de registro .......................................................................................................... 465
MonitorAWS IoTalarmas y métricas con Amazon CloudWatch ........................................................ 466
Uso de las métricas de AWS IoT ...................................................................................... 466
Creando CloudWatch alarmas enAWS IoT .......................................................................... 467
Métricas y dimensiones de AWS IoT .................................................................................. 470
SupervisarAWS IoTusando CloudWatch Registros ....................................................................... 482
VisualizaciónAWS IoTinicia sesión en CloudWatch consola ................................................... 482
CloudWatch RegistrosAWS IoTregistro de entrada ............................................................... 483
Sube los registros del dispositivo a Amazon CloudWatch .............................................................. 505
Cómo funciona ............................................................................................................... 505
Cargar registros del lado del dispositivo medianteAWS IoTreglas ............................................ 506
Registro de llamadas a la API de AWS IoT mediante AWS CloudTrail ............................................. 513
AWS IoTinformación en CloudTrail .................................................................................... 513
Descripción de las entradas de los archivos de registro de AWS IoT ....................................... 514
Reglas ........................................................................................................................................... 516
Otorgar unAWS IoTreglamentar el acceso que requiere ................................................................ 517
Transmisión de los permisos de rol ........................................................................................... 518
Creación de una regla de AWS IoT ........................................................................................... 519
My custom ..................................................................................................................... 523
Visualización de las reglas ....................................................................................................... 523
Eliminar una regla ................................................................................................................... 524
Acciones de reglas de AWS IoT ................................................................................................ 524
Apache Kafka ................................................................................................................. 526
CloudWatch alarmas ........................................................................................................ 534
CloudWatch Registros ...................................................................................................... 535
CloudWatch métricas ....................................................................................................... 536
DynamoDB ..................................................................................................................... 538
DynamoDBv2 ................................................................................................................. 540
Elasticsearch .................................................................................................................. 542
HTTP ............................................................................................................................ 544
IoT Analytics .................................................................................................................. 571
AWS IoT Events ............................................................................................................. 573
AWS IoT SiteWise ........................................................................................................... 574
Kinesis Data Firehose ...................................................................................................... 578
Kinesis Data Streams ...................................................................................................... 580
Lambda ......................................................................................................................... 581
Location ......................................................................................................................... 583
OpenSearch ................................................................................................................... 586
Republish ....................................................................................................................... 588
S3 ................................................................................................................................. 590
IoT de Salesforce ............................................................................................................ 591
SNS .............................................................................................................................. 592
SQS .............................................................................................................................. 594
Step Functions ................................................................................................................ 595
Timestream .................................................................................................................... 596
Solución de problemas de las reglas .......................................................................................... 601
Acceda a los recursos de varias cuentasAWS IoTreglas ............................................................... 601
Requisitos previos ........................................................................................................... 602

vi
 AWS IoT Core Guía para desarrolladores

Configuración de varias cuentas para Amazon SQS ............................................................. 602

Configuración de varias cuentas para Amazon SNS ............................................................. 603
Configuración de varias cuentas para Amazon S3 ................................................................ 604
Configuración de varias cuentas paraAWS Lambda .............................................................. 606
Control de errores (acción de error) ........................................................................................... 607
Formato de mensaje de acción de error ............................................................................. 608
Ejemplo de acción de error ............................................................................................... 609
Reducir los costos de mensajería con Basic Ingest ...................................................................... 609
Uso de Basic Ingest ........................................................................................................ 610
Referencia de la SQL de AWS IoT ............................................................................................ 610
Cláusula SELECT ........................................................................................................... 611
Cláusula FROM .............................................................................................................. 613
Cláusula WHERE ............................................................................................................ 614
Tipos de datos ................................................................................................................ 614
Operadores .................................................................................................................... 618
Funciones ...................................................................................................................... 624
Literales ......................................................................................................................... 671
Instrucciones case ........................................................................................................... 671
Extensiones JSON .......................................................................................................... 672
Plantillas de sustitución .................................................................................................... 674
Consultas de objetos anidados .......................................................................................... 675
Cargas binarias ............................................................................................................... 676
Versiones de SQL ........................................................................................................... 681
Servicio Device Shadow ................................................................................................................... 683
Uso de sombras ..................................................................................................................... 683
Elegir utilizar sombras con nombre o sin nombre ................................................................. 683
Acceso a sombras .......................................................................................................... 684
Uso de sombras en dispositivos, aplicaciones y otros servicios en la nube ............................... 684
Orden de los mensajes .................................................................................................... 685
Recorte de mensajes de sombra ....................................................................................... 686
Uso de sombras en dispositivos ................................................................................................ 687
Inicialización del dispositivo en la primera conexión a AWS IoT .............................................. 688
Procesamiento de mensajes mientras el dispositivo está conectado a AWS IoT ......................... 689
Procesamiento de mensajes cuando el dispositivo se vuelve a conectar a AWS IoT ................... 690
Uso de sombras en aplicaciones y servicios ............................................................................... 690
Inicialización de la aplicación o el servicio al conectarse a AWS IoT ........................................ 691
Procesamiento de cambios de estado mientras la aplicación o el servicio está conectado a AWS
IoT ................................................................................................................................ 691
Detección de un dispositivo conectado ............................................................................... 691
Simulación de comunicaciones del servicio Device Shadow ........................................................... 692
Configuración de la simulación .......................................................................................... 693
Inicializar el dispositivo ..................................................................................................... 693
Enviar una actualización desde la aplicación ....................................................................... 696
Responder a la actualización en el dispositivo ..................................................................... 697
Observe la actualización en la aplicación ............................................................................ 701
Más allá de la simulación ................................................................................................. 702
Interacción con sombras .......................................................................................................... 702
Compatibilidad del protocolo ............................................................................................. 703
Estado de solicitud y notificación ....................................................................................... 703
Actualización de la sombra ............................................................................................... 703
Recuperación de un documento de sombra ........................................................................ 706
Eliminación de datos de sombra ........................................................................................ 707
API REST de sombra de dispositivo .......................................................................................... 709
GetThingShadow ............................................................................................................. 710
UpdateThingShadow ........................................................................................................ 711
DeleteThingShadow ......................................................................................................... 711
ListNamedShadowsForThing ............................................................................................. 712

vii
 AWS IoT Core Guía para desarrolladores

Temas MQTT de sombra de dispositivo ..................................................................................... 713

/get ............................................................................................................................... 714
/get/accepted .................................................................................................................. 714
/get/rejected .................................................................................................................... 715
/update .......................................................................................................................... 716
/update/delta ................................................................................................................... 717
/update/accepted ............................................................................................................. 717
/update/documents .......................................................................................................... 718
/update/rejected .............................................................................................................. 719
/delete ........................................................................................................................... 719
/delete/accepted .............................................................................................................. 720
/delete/rejected ............................................................................................................... 721
Documentos del servicio Device Shadow .................................................................................... 721
Ejemplos de documento de sombra ................................................................................... 721
Propiedades del documento .............................................................................................. 726
Estado delta ................................................................................................................... 727
Control de versiones de documentos de sombra .................................................................. 728
Tokens de cliente en documentos de sombra ...................................................................... 728
Propiedades de documento de sombra vacío ...................................................................... 728
Valores de matriz en documentos sombra .......................................................................... 729
Mensajes de error de Device Shadow ........................................................................................ 730
Trabajos ........................................................................................................................................ 731
Acceder a AWS IoT los trabajos ............................................................................................... 731
AWS IoTTrabajos, regiones y puntos de conexión ........................................................................ 731
¿Qué es AWS IoT Jobs? ......................................................................................................... 731
Conceptos clave de trabajos ............................................................................................. 732
Trabajos y estados de ejecución de trabajos ....................................................................... 735
Administrar trabajos ................................................................................................................. 739
Firma de código para trabajos .......................................................................................... 739
Documento de trabajo ...................................................................................................... 739
URL prefirmadas ............................................................................................................. 739
Cree y administre trabajos mediante la consola ................................................................... 741
Cree y administre trabajos mediante la CLI ......................................................................... 742
Plantillas de trabajo ................................................................................................................. 751
Plantillas personalizadas y AWS gestionadas ...................................................................... 751
Usa plantillas AWS gestionadas ........................................................................................ 751
Crear plantillas de trabajo personalizadas ........................................................................... 765
Trabajoconfiguraciones ............................................................................................................. 771
Cómo funcionan las configuraciones de trabajo ................................................................... 771
Especificar configuraciones adicionales .............................................................................. 781
Dispositivos y trabajos ............................................................................................................. 788
Programación de dispositivos para trabajar con trabajos ........................................................ 790
Flujo de trabajo del dispositivo .......................................................................................... 790
Flujo de trabajo ............................................................................................................... 791
Notificaciones de trabajos ................................................................................................. 794
AWS IoTtrabajos y operaciones de API ...................................................................................... 800
API de gestión y control de trabajos y tipos de datos ............................................................ 802
Operaciones y tipos de datos de las API MQTT y HTTPS del dispositivo Jobs ........................... 816
Proteger usuarios y dispositivos para trabajos ............................................................................. 826
Tipo de política requerida para AWS IoT trabajos ................................................................. 826
Autorizar a los usuarios y los servicios en la nube de Jobs .................................................... 827
Autorizar a los dispositivos a utilizar tareas ......................................................................... 835
Límites de los trabajos ............................................................................................................. 838
Límites de trabajos activos y simultáneos ........................................................................... 838
Tunelización segura de AWS IoT ...................................................................................................... 841
¿Qué es la tunelización segura? ............................................................................................... 841
Conceptos de tunelización segura ..................................................................................... 841

viii
 AWS IoT Core Guía para desarrolladores

Cómo funciona la tunelización segura ................................................................................ 842

Ciclo de vida del túnel seguro ........................................................................................... 843
AWS IoTtutoriales de tunelización segura ................................................................................... 843
Tutoriales de esta sección de esta sección de ..................................................................... 844
Abra un túnel e inicie la sesión SSH en el dispositivo remoto ................................................. 844
Abra un túnel para un dispositivo remoto y utilice SSH basado en un navegador ....................... 857
Proxy local ............................................................................................................................. 861
Cómo utilizar el proxy local ............................................................................................... 861
Configurar el proxy local para los dispositivos que utilizan un proxy web .................................. 865
Conexiones TCP simultáneas y multiplexadas ............................................................................. 870
Multiplexación de múltiples flujos de datos .......................................................................... 871
Uso de conexiones TCP simultáneas ................................................................................. 873
Configuración de un dispositivo remoto y uso de un agente de IoT ................................................. 875
Fragmento de agente de IoT ............................................................................................ 875
Control del acceso a los túneles ............................................................................................... 877
Requisitos previos de acceso al túnel ................................................................................ 877
Políticas de acceso a túneles ............................................................................................ 877
Resolver problemas de conectividad de túneles seguros ............................................................... 882
Error de token de acceso al cliente no válido ...................................................................... 883
Error de incompatibilidad del token del cliente ..................................................................... 883
Problemas de conectividad de dispositivos remotos .............................................................. 884
Aprovisionamiento de dispositivos ...................................................................................................... 886
Dispositivos de aprovisionamiento en AWS IoT ............................................................................ 887
API de aprovisionamiento de flotas ............................................................................................ 887
Aprovisionamiento de dispositivos que no tienen certificados de dispositivo mediante el
aprovisionamiento de flotas ...................................................................................................... 888
Aprovisionamiento por reclamación .................................................................................... 888
Aprovisionamiento por usuario de confianza ........................................................................ 890
Uso de enlaces de preaprovisionamiento con la CLI de AWS ................................................. 892
Aprovisionamiento de dispositivos que tienen certificados de dispositivo .......................................... 894
Aprovisionamiento de un solo objeto .................................................................................. 895
ust-in-timeAprovisionamiento de J ...................................................................................... 895
Registro masivo .............................................................................................................. 899
Aprovisionamiento de plantillas .................................................................................................. 900
Sección de parámetros .................................................................................................... 900
Sección de recursos ........................................................................................................ 901
Ejemplo de plantilla para registro masivo ............................................................................ 905
Ejemplo de plantilla para just-in-time aprovisionamiento (JITP) ............................................... 905
Aprovisionamiento de flotas .............................................................................................. 907
Enlaces de preaprovisionamiento .............................................................................................. 909
Preaprovisionamiento de entrada de enlace ........................................................................ 910
Valor de retorno del enlace previo a la provisión .................................................................. 910
Ejemplo de gancho de preaprovisionamiento Lambda ........................................................... 910
Creación de políticas y roles de IAM para un usuario que instala un dispositivo ................................. 912
Crear una política de IAM para el usuario que instalará un dispositivo ..................................... 912
Crear un rol de IAM para el usuario que instalará un dispositivo ............................................. 913
Actualizar una política existente para autorizar una plantilla nueva .......................................... 914
API de MQTT de aprovisionamiento de dispositivos ..................................................................... 915
CreateCertificateFromCsr ................................................................................................. 915
CreateKeysAndCertificate ................................................................................................. 917
RegisterThing ................................................................................................................. 918
Indexación de flotas ........................................................................................................................ 921
Administrar actualizaciones de indexación. .................................................................................. 921
Búsqueda de fuentes de datos. ................................................................................................. 921
Consulta de datos agregados ................................................................................................... 921
Monitorear los datos agregados y crear alarmas mediante el uso de métricas de flota ........................ 921
Administrar indexación de flotas. ............................................................................................... 922

ix
 AWS IoT Core Guía para desarrolladores

Indexación de cosas ........................................................................................................ 922

Indexación de grupos de cosas ......................................................................................... 923
Campos gestionados. ...................................................................................................... 923
Campos personalizados ................................................................................................... 924
Gestiona la indexación de cosas ....................................................................................... 925
Gestione la indexación de grupos de cosas ........................................................................ 935
Consulta de datos agregados ................................................................................................... 936
GetStatistics ................................................................................................................... 936
GetCardinality ................................................................................................................. 939
GetPercentiles ................................................................................................................ 939
GetBucketsAggregation .................................................................................................... 941
Autorización .................................................................................................................... 942
Sintaxis de la consulta ............................................................................................................. 942
Características admitidas .................................................................................................. 942
Características de no admitidas ......................................................................................... 942
Notas ............................................................................................................................ 943
Ejemplo de consultas de objetos ............................................................................................... 943
Ejemplo de consultas de grupo de objetos .................................................................................. 945
Métricas de flota ..................................................................................................................... 947
Explicación introductoria ................................................................................................... 947
Gestión de las métricas de la flota ..................................................................................... 952
Entrega de archivos basada en MQTT ............................................................................................... 956
¿Qué es una transmisión? ....................................................................................................... 956
Administrar una transmisión en elAWSNube ................................................................................ 957
Concede permisos a tus dispositivos .................................................................................. 957
Conecta tus dispositivos aAWS IoT ................................................................................... 958
UsandoAWS IoTEntrega de archivos en dispositivos basada en MQTT ............................................ 958
Utilice DescribeStream para obtener datos de transmisión ..................................................... 958
Obtenga bloques de datos de un archivo de flujo ................................................................. 960
Manejo de errores deAWS IoTEntrega de archivos basada en MQTT ...................................... 964
Un ejemplo de caso de uso en Freertos OTA .............................................................................. 965
AWS IoT Device Defender ............................................................................................................... 966
AWS Training and Certification .................................................................................................. 966
Introducción a AWS IoT Device Defender ................................................................................... 966
Configuración ................................................................................................................. 966
Guía de auditoría ............................................................................................................ 967
Guía ML Detect .............................................................................................................. 971
Personaliza cuándo y cómo lo vesAWS IoT Device Defenderresultados de auditoría .................. 994
Auditoría .............................................................................................................................. 1005
Gravedad del problema .................................................................................................. 1006
Pasos siguientes ........................................................................................................... 1006
Comprobaciones de auditoría .......................................................................................... 1006
Comandos de auditoría .................................................................................................. 1037
Supresiones de hallazgos de auditoría .............................................................................. 1064
Detect .................................................................................................................................. 1073
Monitorización del comportamiento de dispositivos no registrados ......................................... 1075
Casos de uso de seguridad ............................................................................................ 1075
Conceptos .................................................................................................................... 1080
Comportamientos .......................................................................................................... 1081
Detección de ML ........................................................................................................... 1083
Métricas personalizadas ................................................................................................. 1088
Métricas del lado del dispositivo ...................................................................................... 1094
Métricas del lado de la nube ........................................................................................... 1109
Establecer el ámbito de las métricas en los perfiles de seguridad utilizando dimensiones ........... 1117
Permisos ...................................................................................................................... 1121
Comandos de detección ................................................................................................. 1122
Cómo utilizar AWS IoT Device Defender Detect ................................................................. 1124

x
 AWS IoT Core Guía para desarrolladores

Acciones de mitigación ........................................................................................................... 1125

Acciones de mitigación de auditorías ................................................................................ 1125
Detectar acciones de mitigación ...................................................................................... 1128
Cómo definir y administrar las acciones de mitigación ......................................................... 1128
Aplicación de acciones de mitigación ................................................................................ 1130
Permisos ...................................................................................................................... 1134
Comandos de las acciones de mitigación .......................................................................... 1137
Uso de AWS IoT Device Defender con otros servicios de AWS. ................................................... 1138
UsoAWS IoT Device Defendercon dispositivos en ejecuciónAWS IoT Greengrass .................... 1138
UsoAWS IoT Device Defendercon FreeRTOS y dispositivos integrados .................................. 1138
Uso de AWS IoT Device Defender con AWS IoT Device Management ................................... 1139
Integración de Security Hub ............................................................................................ 1139
Prevención del suplente confuso entre servicios ......................................................................... 1145
Prácticas recomendadas de seguridad para agentes de dispositivos ............................................. 1146
Asesor de dispositivos .................................................................................................................... 1148
Configuración ........................................................................................................................ 1149
Crea una cosa de IoT .................................................................................................... 1149
Cree un rol de IAM para usarlo como rol de dispositivo ....................................................... 1149
Cree una política gestionada a medida para que un usuario de IAM utilice Device Advisor ......... 1151
Crear un usuario de IAM para usar Device Advisor ............................................................. 1152
Configuración del dispositivo ........................................................................................... 1153
Introducción a Device Advisor en la consola .............................................................................. 1154
flujo de trabajo de Device Advisor ............................................................................................ 1161
Requisitos previos ......................................................................................................... 1161
Cree una definición de conjunto de pruebas ...................................................................... 1161
Obtenga una definición del conjunto de pruebas ................................................................ 1163
Obtenga un punto final de prueba .................................................................................... 1163
Iniciar la ejecución de un conjunto de pruebas ................................................................... 1163
Ejecute un conjunto de pruebas ...................................................................................... 1164
Detener la ejecución de un conjunto de pruebas ................................................................ 1164
Obtenga un informe de calificación para ejecutar satisfactoriamente el conjunto de pruebas de
calificación .................................................................................................................... 1165
Flujo de trabajo de consola detallado de Device Advisor .............................................................. 1165
Requisitos previos ......................................................................................................... 1165
Cree una definición de conjunto de pruebas ...................................................................... 1166
Iniciar la ejecución de un conjunto de pruebas ................................................................... 1171
Detener la ejecución de un conjunto de pruebas (opcional) .................................................. 1172
Ver detalles y registros de ejecución del conjunto de pruebas ............................................... 1174
Descarga unAWS IoTinforme de calificación ...................................................................... 1175
Flujo de trabajo de consola de pruebas de larga duración ............................................................ 1175
Terminales de VPC de Device Advisor (AWS PrivateLink) ........................................................... 1181
Consideraciones para los puntos de conexión de VPC de AWS IoT Core Device Advisor ........... 1182
Crear un punto de enlace de la VPC de la interfaz para AWS IoT Core Device Advisor .............. 1182
Controlar el acceso aAWS IoT Core Device Advisorsobre puntos finales de VPC ..................... 1183
Casos de prueba de Device Advisor ........................................................................................ 1184
Casos de prueba de Device Advisor para calificar para elAWSPrograma de calificación de
dispositivos. .................................................................................................................. 1184
TLS ............................................................................................................................. 1185
MQTT .......................................................................................................................... 1189
Sombra ........................................................................................................................ 1199
Ejecución del trabajo ...................................................................................................... 1200
Permisos y políticas ....................................................................................................... 1202
Pruebas de larga duración .............................................................................................. 1202
Catálogo de paquetes de software ................................................................................................... 1215
Preparación para el uso del catálogo de recursos de software Package Catalog .............................. 1215
................................................................................................................................... 1215
Ciclo de vida de la versión de paquete ............................................................................. 1216

xi
 AWS IoT Core Guía para desarrolladores

Convenciones de nomenclatura de versiones de paquetes ................................................... 1217

Versión predeterminada .................................................................................................. 1217
Los atributos de la versión .............................................................................................. 1218
HabilitarAWS IoTindexación flota ..................................................................................... 1218
Sombra con nombre reservado ........................................................................................ 1218
Registros de AWS CloudTrail .......................................................................................... 1219
Eliminar un paquete de software ...................................................................................... 1219
Preparar la seguridad ............................................................................................................. 1220
Autenticación basada en recursos .................................................................................... 1220
AWS IoTJob: derechos para implementar versiones de paquetes .......................................... 1221
AWS IoTJob: derechos para actualizar la sombra reservada con nombre ............................... 1222
AWS IoTPermisos de trabajo para descargar desde Amazon S3 ........................................... 1223
Se abrirá la página de la flota ................................................................................................. 1223
Establecer el$packagela sombra como fuente de datos ..................................................... 1224
Se abrirá la página de las métricas .................................................................................. 1224
Patrones Query ............................................................................................................. 1225
Recopilación de la distribución de las versiones del paquete
mediantegetBucketsAggregation ............................................................................... 1226
PreparándoseAWS IoTEmpleos ............................................................................................... 1227
Parámetros de sustitución paraAWS IoTtrabajos ................................................................ 1227
Preparar el documento de trabajo y la versión del paquete para su despliegue ........................ 1228
Asignar un nombre a los paquetes y las versiones al implementarlos ..................................... 1229
Segmentar los trabajos a través deAWS IoTgrupos de cosas dinámicos ................................. 1229
Versiones reservadas con nombre, sombra y paquete ......................................................... 1229
Introducción .......................................................................................................................... 1230
Crear un paquete y una versión ...................................................................................... 1230
Se abrirá la página de una versión del paquete ................................................................. 1231
Se abrirá la página de un paquete ................................................................................... 1233
AWS IoT CoreUbicación del dispositivo ............................................................................................ 1234
Tipos de medición y solucionadores ......................................................................................... 1234
¿Cómo?AWS IoT CoreLa ubicación del dispositivo funciona ........................................................ 1235
Cómo usarAWS IoT CoreUbicación del dispositivo ..................................................................... 1236
Resolver la ubicación de los dispositivos de IoT ......................................................................... 1237
Resolver la ubicación del dispositivo (consola) ................................................................... 1237
Resolver la ubicación del dispositivo (API) ........................................................................ 1239
Solución de errores al resolver la ubicación ....................................................................... 1240
Resolver la ubicación del dispositivo mediante temas de MQTT .................................................... 1241
Formato de ubicación del dispositivo (temas de MQTT) ....................................................... 1241
Política de ubicación de dispositivos (temas de MQTT) ....................................................... 1242
Temas de ubicación del dispositivo y carga útil .................................................................. 1243
Solucionadores de ubicación y carga útil del dispositivo .............................................................. 1246
Solucionador basado en Wi-Fi ......................................................................................... 1247
Solucionador basado en dispositivos móviles ..................................................................... 1247
Solucionador de búsqueda inversa de IP .......................................................................... 1251
solucionador GNSS ....................................................................................................... 1251
Mensajes de los eventos ................................................................................................................ 1253
Cómo se generan los mensajes de los eventos ......................................................................... 1253
Política de recepción de mensajes de eventos ................................................................... 1253
Habilitar eventos paraAWS IoT ................................................................................................ 1253
Eventos de registro ................................................................................................................ 1257
Eventos de cosas .......................................................................................................... 1257
Eventos de tipo cosa ..................................................................................................... 1258
Eventos de grupos de cosas ........................................................................................... 1260
Eventos de trabajos ............................................................................................................... 1264
Eventos del ciclo de vida ........................................................................................................ 1267
Eventos de conexión/desconexión .................................................................................... 1268
Eventos de suscripción/cancelación de suscripción ............................................................. 1270

xii
 AWS IoT Core Guía para desarrolladores

AWS IoT Corepara LoRa WAN ....................................................................................................... 1272

Introducción .......................................................................................................................... 1272
Cómo usarlo AWS IoT Core para LoRa WAN ............................................................................ 1272
AWS IoT Corepara regiones y puntos de conexión LoRa WAN ..................................................... 1273
AWS IoT Corepara precios de LoRa WAN ................................................................................ 1273
¿Qué es AWS IoT Core para LoRa WAN? ................................................................................ 1273
¿Qué es LoRa WAN? .................................................................................................... 1274
Cómo AWS IoT Core funciona la LoRa WAN ..................................................................... 1275
Conexión de puertas de enlace y dispositivos aAWS IoT Core para LoRaWAN ................................ 1276
Convenciones de nomenclatura para sus dispositivos, puertas de enlace, perfiles y destinos ...... 1276
Mapeo de los datos del dispositivo con los datos de servicio ................................................ 1276
Uso de la consola para integrar el dispositivo y la puerta de enlace aAWS IoT Core para
LoRaWAN .................................................................................................................... 1277
Describa suAWS IoT CoreporLoRaRecursos de WAN ......................................................... 1277
Incorpore sus puertas de enlace aAWS IoT Core para LoRaWAN ......................................... 1279
Integra tus dispositivos paraAWS IoT Core para LoRaWAN ................................................. 1288
Configure la información de posición para los dispositivos LoRa WAN y las puertas de enlace ............ 1299
Cómo funciona el posicionamiento para los dispositivos LoRa WAN ...................................... 1300
Descripción general del flujo de trabajo de posicionamiento ................................................. 1301
Configuración de la posición de los recursos ..................................................................... 1302
Configuración de la posición de las puertas de enlace LoRa WAN ........................................ 1302
Configuración de la posición de los dispositivos LoRa WAN ................................................. 1304
Conectarse aAWS IoT Core para LoRaWANa través de un punto final de interfaz VPC ..................... 1308
A bordoAWS IoT Core para LoRaWANpunto final de la API del plano de control ...................... 1310
A bordoAWS IoT Core para LoRaWANpuntos finales de la API del plano de datos ................... 1312
Administración de puertas de enlace conAWS IoT Core para LoRa WAN ....................................... 1318
LoRa Requisitos básicos del software de la estación .......................................................... 1318
Uso de pasarelas calificadas del catálogo de dispositivosAWS asociados ............................... 1319
Uso de los protocolos CUPS y LNS ................................................................................. 1319
Configure las capacidades de balizamiento y filtrado de sus puertas de enlace LoRa WAN ........ 1319
Actualice el firmware de la pasarela mediante el servicio CUPS conAWS IoT Core para
LoRaWAN .................................................................................................................... 1324
Elegir puertas de enlace para recibir el tráfico de datos de enlace descendente de la LoRa WAN 1334
Administración de dispositivos con AWS IoT Core para LoRaWAN ................................................ 1336
Consideraciones sobre el dispositivo ................................................................................ 1336
Uso de dispositivos con puertas de enlace calificadas paraAWS IoT Core para LoRaWAN ......... 1337
LoRaVersión WAN ......................................................................................................... 1337
Modos de activación ...................................................................................................... 1337
Clases de dispositivos .................................................................................................... 1337
Gestione la comunicación entre susLoRadispositivos WAN yAWS IoT .................................... 1337
Gestione el tráfico de roaming desdeLoRaDispositivos WAN fuera de la red doméstica ............. 1344
Cree grupos de multidifusión para enviar una carga de enlace descendente a varios dispositivos 1351
Actualizaciones de firmware inalámbricas (FUOTA) paraAWS IoT Core para
LoRaWANdispositivos .................................................................................................... 1362
Monitoree su flota de recursos inalámbricos en tiempo real mediante el analizador de redes .............. 1372
Agregue la función de IAM necesaria para el analizador de redes ......................................... 1374
Cree una configuración de analizador de red y añada recursos ............................................. 1375
Transmita mensajes de rastreo del analizador de redes con WebSockets ............................... 1381
Vea y supervise los registros de mensajes de rastreo del analizador de redes en tiempo real ..... 1390
Depure sus grupos de multidifusión y sus tareas de FUOTA con el analizador de red ................ 1393
Seguridad de datos con AWS IoT Core para LoRa WAN ............................................................. 1395
Cómo se protegen los datos en todo el sistema ................................................................. 1395
LoRaSeguridad de transporte de dispositivos WAN y puertas de enlace ................................. 1396
AWS IoT Core para Amazon Sidewalk ............................................................................................. 1397
Cómo utilizar lasAWS IoT Core para Amazon Sidewalk? ............................................................. 1397
AWS IoT Core para Amazon SidewalkRegiones y puntos de enlace .............................................. 1397
Precios de AWS IoT Core para Amazon Sidewalk ...................................................................... 1398

xiii
 AWS IoT Core Guía para desarrolladores

¿Qué es AWS IoT Core para Amazon Sidewalk? ....................................................................... 1398

Características de AWS IoT Core para Amazon Sidewalk .................................................... 1398
¿Qué es Amazon Sidewalk? ........................................................................................... 1398
Cómo funciona AWS IoT Core para Amazon Sidewalk ........................................................ 1399
Introducción a AWS IoT Core para Amazon Sidewalk ................................................................. 1401
Pruebe el tutorial de monitorización de sensores ................................................................ 1401
Configuración ................................................................................................................ 1402
Describir sus recursos de Sidewalk .................................................................................. 1403
Introducción a la incorporación de sus dispositivos Sidewalk ................................................ 1405
Conexión de dispositivos de acera aAWS IoT Core para Amazon Sidewalk .................................... 1408
Requisitos previos ......................................................................................................... 1408
Describe tus recursos de Sidewalk ................................................................................... 1408
Agrega tu dispositivo Sidewalk ........................................................................................ 1409
Agrega un destino para el dispositivo Sidewalk .................................................................. 1415
Conecta tu dispositivo Sidewalk ....................................................................................... 1420
Dispositivos de aprovisionamiento masivo con AWS IoT Core para Amazon Sidewalk ....................... 1422
Flujo de trabajo de aprovisionamiento masivo de Amazon Sidewalk ....................................... 1423
Creación de perfiles de dispositivos con soporte de fábrica .................................................. 1426
Aprovisionamiento de dispositivos Sidewalk mediante tareas de importación ........................... 1429
Operaciones de la API de AWS IoT Core para Amazon Sidewalk ................................................. 1438
Operaciones de API para perfiles de dispositivos de Sidewalk .............................................. 1438
Operaciones de API para dispositivos finales de Sidewalk ................................................... 1439
Operaciones de API para destinos para dispositivos Sidewalk .............................................. 1441
Operaciones de API para aprovisionamiento masivo ........................................................... 1443
Monitorización y eventos paraAWS IoT Core para Amazon Sidewalk ............................................. 1446
Eventos para dispositivos Sidewalk .................................................................................. 1446
Monitorización de dispositivos de acera ............................................................................ 1447
Monitorización y registro para elAWS IoT Wireless uso de Amazon CloudWatch ...................................... 1449
Configuración del registro para AWS IoT Wireless ...................................................................... 1450
Cree una función y una política de registro paraAWS IoT Wireless ........................................ 1450
Configurar el registro deAWS IoT Wireless recursos ........................................................... 1452
SupervisarAWS IoT Wireless mediante CloudWatch registros ....................................................... 1460
Ver entradas CloudWatch AWS IoT Wireless de registro ..................................................... 1461
Utilice CloudWatch Insights para filtrar los registros deAWS IoT Wireless ............................... 1466
Notificaciones de eventos paraAWS IoT Wireless ............................................................................... 1470
Cómo se pueden notificar los eventos a sus recursos ................................................................. 1470
Tipos de eventos y recursos ........................................................................................... 1470
Política para recibir notificaciones de eventos inalámbricos .................................................. 1471
Formato de temas de MQTT para eventos inalámbricos ...................................................... 1471
Precios para eventos inalámbricos ........................................................................................... 1473
Habilitar eventos para recursos inalámbricos ............................................................................. 1474
Configuraciones de eventos ............................................................................................ 1474
Requisitos previos ......................................................................................................... 1474
Habilite las notificaciones mediante elAWS Management Console ......................................... 1474
Habilite las notificaciones mediante elAWS CLI .................................................................. 1475
Notificaciones de eventos paraLoRaRecursos de WAN ............................................................... 1477
Tipos de eventos paraLoRaRecursos de WAN ................................................................... 1477
LoRaEventos de unión de WAN ...................................................................................... 1477
Eventos de estado de conexión ....................................................................................... 1480
Notificaciones de eventos para los recursos de Sidewalk ............................................................. 1481
Tipos de eventos para Sidewalk Resources ....................................................................... 1481
Eventos de estado de registro del dispositivo ..................................................................... 1482
Eventos de proximidad ................................................................................................... 1484
Eventos de estado de entrega de mensajes ...................................................................... 1486
AWS IoTSDK para dispositivos, SDK para dispositivos móviles yAWS IoTCliente de dispositivo ................. 1489
SDK de dispositivos de AWS IoT ............................................................................................. 1489
SDK de dispositivos de AWS IoT para Embedded C ........................................................... 1490

xiv
 AWS IoT Core Guía para desarrolladores

AnteriormenteAWS IoTVersiones de los SDK del dispositivo ................................................ 1491

AWS Mobile SDK .................................................................................................................. 1491
AWS IoTCliente de dispositivo ................................................................................................. 1492
Solución de problemas ................................................................................................................... 1493
Diagnóstico de problemas de conectividad ................................................................................ 1493
Conexión ...................................................................................................................... 1493
Autenticación ................................................................................................................ 1494
Autorización .................................................................................................................. 1495
Seguridad e identidad .................................................................................................... 1495
Diagnóstico de problemas de las reglas .................................................................................... 1496
Configuración de CloudWatch registros para la solución de problemas ................................... 1496
Diagnóstico de servicios externos .................................................................................... 1497
Diagnóstico de problemas de SQL ................................................................................... 1497
Diagnóstico de problemas relacionados con las sombras ............................................................. 1497
Diagnosticar problemas con acciones de Salesforce ................................................................... 1498
Registro de seguimiento de ejecución ............................................................................... 1499
Éxito y error de una acción ............................................................................................. 1499
Guía de solución de problemas de indexación de flotas ............................................................... 1499
Solución de problemas de consultas de agregación en el servicio de indexación de flotas .......... 1500
Solución de problemas de configuración de indexación de flotas ........................................... 1500
Solución de problemas de métricas de flota ....................................................................... 1501
Solución de problemas «Se ha superado el límite de transmisión de tu AWS cuenta» ....................... 1501
Guía para solucionar problemas de AWS IoT Device Defender ..................................................... 1502
AWS IoTGuía de solución de problemas de Device Advisor ......................................................... 1505
Solución de problemas de desconexiones de flotas de dispositivos ............................................... 1507
Errores de AWS IoT .............................................................................................................. 1508
AWS IoTCuotas de ........................................................................................................................ 1510
Precios de AWS IoT Core .............................................................................................................. 1511
.................................................................................................................................................. mdxii

xv
 AWS IoT Core Guía para desarrolladores
Cómo acceden tus dispositivos y aplicacionesAWS IoT

¿Qué es AWS IoT?

AWS IoT proporciona los servicios en la nube que conectan los dispositivos IoT a otros dispositivos y
servicios en la nube de AWS. AWS IoT proporciona software para dispositivos que puede ayudarlo a
integrar los dispositivos IoT en soluciones basadas en AWS IoT. Si los dispositivos se pueden conectar a
AWS IoT, AWS IoT puede conectarlos a los servicios en la nube que proporciona AWS.

Para una introducción práctica aAWS IoT, visitaIntroducción a AWS IoT Core (p. 18).

AWS IoTle permite seleccionar la más adecuada yup-to-datetecnologías para su solución. Para ayudarlo a
administrar y brindar soporte a sus dispositivos de IoT sobre el terreno,AWS IoT Coreadmite los siguientes
protocolos:

• MQTT (cola de mensajes y transporte por telemetría) (p. 90)

• MQTT sobre WSS (Websockets Secure) (p. 90)
• HTTPS (Protocolo de transferencia de hipertexto - Seguro) (p. 109)
• LoRaWAN (red de área amplia de largo alcance) (p. 1272)

ElAWS IoT CoreEl corredor de mensajes admite dispositivos y clientes que utilizan los protocolos MQTT
y MQTT a través de WSS para publicar mensajes y suscribirse a ellos. También es compatible con
dispositivos y clientes que utilizan el protocolo HTTPS para publicar mensajes.

AWS IoT CoreporLoRaLa WAN le ayuda a conectarse y administrar la conexión

inalámbricaLoRaDispositivos WAN (red de área amplia y largo alcance de bajo consumo).AWS IoT
CoreporLoRaLa WAN reemplaza la necesidad de desarrollar y operar unLoRaServidor de red WAN (LNS).

Si no necesitasAWS IoTfunciones como las comunicaciones del dispositivo,reglas (p. 516),

otrabajos (p. 731), consulteAWSMensajeríapara obtener información sobre otrosAWS IoTservicios de
mensajería que podrían adaptarse mejor a sus necesidades.

Cómo acceden tus dispositivos y aplicacionesAWS

IoT
AWS IoTproporciona las siguientes interfaces paraTutoriales de AWS IoT (p. 139):

1
 AWS IoT Core Guía para desarrolladores
QuéAWS IoTpuede hacer

• AWS IoTSDK de dispositivos—Cree aplicaciones en sus dispositivos que envíen mensajes y reciban
mensajes desdeAWS IoT. Para obtener más información, consulte AWS IoTSDK para dispositivos, SDK
para dispositivos móviles yAWS IoTCliente de dispositivo (p. 1489).
• AWS IoT CoreporLoRaMENDIGO—Conecte y administre su WAN de largo alcance (LoRadispositivos y
puertas de enlace (WAN) medianteAWS IoT CoreporLoRaMENDIGO (p. 1272).
• AWS Command Line Interface (AWS CLI): ejecuta comandos para AWS IoT en Windows, macOS X y
Linux. Estos comandos le permiten crear y administrar objetos, certificados, reglas, trabajos y políticas.
Para empezar, consulte la AWS Command Line Interface Guía de usuario de . Para obtener más
información acerca de los comandos deAWS IoT, consultemotínen elAWS CLIReferencia de comando.
• AWS IoT API - Cree sus aplicaciones IoT mediante solicitudes HTTP o HTTPS. Estas acciones de la
API le permiten crear y administrar objetos, certificados, reglas y políticas de manera programática. Para
obtener más información acerca de las acciones de la API para AWS IoT, consulte las acciones en las
referencias de API de AWS IoT.
• AWSSDK—Cree sus aplicaciones de IoT mediante API específicas para cada idioma. Estos SDK
integran las API de HTTP/HTTPS y le permiten programar en cualquiera de los lenguajes admitidos.
Para obtener más información, consulte SDK y herramientas de AWS.

También puedes accederAWS IoTa través delAWS IoTconsola, que proporciona una interfaz gráfica de
usuario (GUI) a través de la cual puede configurar y administrar los objetos, los certificados, las reglas, los
trabajos, las políticas y otros elementos de sus soluciones de IoT.

QuéAWS IoTpuede hacer

En este tema se describen algunas de las soluciones que podría necesitarAWS IoTsoportes.

IoT en la industria

Estos son algunos ejemplos deAWS IoTsoluciones paracasos de uso industrialque aplican tecnologías de
IoT para mejorar el rendimiento y la productividad de los procesos industriales.

Soluciones para casos de uso industrial

• UsaAWS IoTpara crear modelos predictivos de calidad en operaciones industriales

Vea cómoAWS IoTpuede recopilar y analizar datos de operaciones industriales para crear modelos
predictivos de calidad. Más información
• UsaAWS IoTpara respaldar el mantenimiento predictivo en las operaciones industriales

Vea cómoAWS IoTpuede ayudar a planificar el mantenimiento preventivo para reducir el tiempo de
inactividad no planificado. Más información

2
 AWS IoT Core Guía para desarrolladores
IoT en la automatización del hogar

IoT en la automatización del hogar

Estos son algunos ejemplos deAWS IoTsoluciones paracasos de uso de automatización del hogarque
aplican tecnologías de IoT para crear aplicaciones de IoT escalables que automaticen las actividades del
hogar mediante dispositivos domésticos conectados.

Soluciones para la automatización del hogar

• UsaAWS IoTen tu hogar conectado

Vea cómoAWS IoTpuede proporcionar soluciones integradas de automatización del hogar.

• UsaAWS IoTpara proporcionar seguridad y monitoreo en el hogar

Vea cómoAWS IoTpuede aplicar el aprendizaje automático y la computación periférica a su solución de

automatización del hogar.

Para obtener una lista de soluciones para casos de uso industrial, comercial y de consumo, consulteAWS
IoTRepositorio de soluciones.

Cómo funciona AWS IoT

AWS IoTproporciona servicios en la nube y soporte de dispositivos que puede utilizar para implementar
soluciones de IoT.AWSproporciona muchos servicios en la nube para dar soporte a las aplicaciones
basadas en IoT. Para ayudarlo a entender por dónde empezar, esta sección proporciona un diagrama y
una definición de conceptos esenciales para presentarle el universo de la IoT.

El universo IoT
En general, el Internet de las cosas (IoT) se compone de los componentes clave que se muestran en este
diagrama.

3
 AWS IoT Core Guía para desarrolladores
El universo IoT

móviles
Las aplicaciones permiten a los usuarios finales acceder a los dispositivos de IoT y a las funciones que
proporcionan los servicios en la nube a los que están conectados esos dispositivos.

Servicios en la nube
Los servicios en la nube son servicios de almacenamiento y procesamiento de datos distribuidos y a gran
escala que están conectados a Internet. Entre los ejemplos se incluyen:

• Servicios de conexión y gestión de IoT

AWS IoTes un ejemplo de un servicio de conexión y administración de IoT.

• Servicios informáticos, como Amazon Elastic Compute Cloud yAWS Lambda
• Servicios de bases de datos, como Amazon DynamoDB

Comunicaciones
Los dispositivos se comunican con los servicios en la nube mediante diversas tecnologías y protocolos.
Entre los ejemplos se incluyen:

• Wi-Fi/Internet de banda ancha

• Datos celulares de banda ancha
• Datos móviles de banda estrecha
• Red de área amplia de largo alcance (LoRaVARÓN)
• Comunicaciones RF patentadas

4
 AWS IoT Core Guía para desarrolladores
El universo IoT

Dispositivos
Un dispositivo es un tipo de hardware que administra las interfaces y las comunicaciones. Los dispositivos
suelen estar ubicados muy cerca de las interfaces del mundo real que supervisan y controlan. Los
dispositivos pueden incluir recursos informáticos y de almacenamiento, como microcontroladores, CPU y
memoria. Entre los ejemplos se incluyen:

• Raspberry Pi
• Arduino
• Asistentes de interfaz de voz
• LoRaWAN y dispositivos
• Dispositivos Amazon Sidewalk
• Dispositivos IoT personalizados

Interfaces
Una interfaz es un componente que conecta un dispositivo con el mundo físico.

• Interfaces de usuario

Componentes que permiten que los dispositivos y los usuarios se comuniquen entre sí.
• Interfaces de entrada

Permitir que un usuario se comunique con un dispositivo

Ejemplos: teclado, botón

• Interfaces de salida

Permitir que un dispositivo se comunique con un usuario

Ejemplos: pantalla alfanumérica, pantalla gráfica, luz indicadora, timbre de alarma

• Sensores

Componentes de entrada que miden o detectan algo en el mundo exterior de una manera que un
dispositivo entiende. Entre los ejemplos se incluyen:
• Sensor de temperatura (convierte la temperatura en una señal analógica o digital)
• Sensor de humedad (convierte la humedad relativa en una señal analógica o digital)
• Convertidor analógico a digital (convierte una tensión analógica en un valor numérico)
• Unidad de medición de distancia por ultrasonidos (convierte una distancia en un valor numérico)
• Sensor óptico (convierte un nivel de luz en un valor numérico)
• Cámara (convierte los datos de imagen en datos digitales)
• Actuadores

Componentes de salida que el dispositivo puede usar para controlar algo en el mundo exterior. Entre los
ejemplos se incluyen:
• Motores paso a paso (convierten las señales eléctricas en movimiento)
• Relés (controlan altas tensiones y corrientes eléctricas)

5
 AWS IoT Core Guía para desarrolladores
AWS IoTdescripción general de los servicios

AWS IoTdescripción general de los servicios

En el universo del IoT,AWS IoTproporciona los servicios que respaldan los dispositivos que interactúan
con el mundo y los datos que pasan entre ellos yAWS IoT.AWS IoTse compone de los servicios que se
muestran en esta ilustración para respaldar su solución de IoT.

AWS IoTsoftware del dispositivo

AWS IoTproporciona este software para brindar soporte a sus dispositivos de IoT.

SDK de dispositivos de AWS IoT

ElAWS IoTSDK para dispositivos y dispositivos móviles (p. 1489)le ayudan a conectar sus dispositivos
de manera eficiente aAWS IoT. Los de AWS IoT para dispositivos y móviles contienen bibliotecas de
código abierto, guías para desarrolladores con ejemplos y guías de portabilidad para que pueda crear
innovadores productos y soluciones de IoT en las plataformas de hardware que prefiera.
AWS IoT Device Tester

AWS IoT Device Testerpara FreeRTOS yAWS IoT Greengrasses una herramienta de automatización
de pruebas para microcontroladores.AWS IoT Device Testerprueba su dispositivo para determinar si
ejecutará FreeRTOS oAWS IoT Greengrasse interoperar conAWS IoTservicios.
AWS IoT ExpressLink

AWS IoT ExpressLinkalimenta una gama de módulos de hardware desarrollados y ofrecidos

porAWSSocios. Los módulos de conectividad incluyenAWS-software validado, que permite conectar
dispositivos a la nube de forma más rápida y sencilla de forma segura e integrarlos sin problemas
con una gama deAWSservicios. Para obtener más información, visiteAWS IoT ExpressLinkpágina de
información general o consulte laAWS IoT ExpressLinkGuía del programador.
AWS IoT Greengrass

AWS IoT Greengrassse extiendeAWS IoTa dispositivos periféricos para que puedan actuar localmente
en función de los datos que generan, ejecutar predicciones basadas en modelos de aprendizaje
automático y filtrar y agregar los datos de los dispositivos.AWS IoT Greengrasspermite que sus

6
 AWS IoT Core Guía para desarrolladores
AWS IoTdescripción general de los servicios

dispositivos recopilen y analicen datos más cerca de donde se generan esos datos, reaccionen de
forma autónoma ante los eventos locales y se comuniquen de forma segura con otros dispositivos de
la red local. Puedes usarAWS IoT Greengrasspara crear aplicaciones periféricas mediante módulos de
software prediseñados, denominados componentes, que pueden conectar sus dispositivos periféricos
aAWSservicios o servicios de terceros.
FreeRTOS

RTOS gratuitoses un sistema operativo de código abierto y en tiempo real para microcontroladores
que le permite incluir dispositivos periféricos pequeños y de bajo consumo en su solución de IoT.
FreeRTOS incluye un núcleo y un conjunto creciente de bibliotecas de software que admiten muchas
aplicaciones. Los sistemas FreeRTOS pueden conectar de forma segura sus dispositivos pequeños y
de bajo consumo aAWS IoTy admiten la ejecución de dispositivos periféricos más potentesAWS IoT
Greengrass.

AWS IoTservicios de control

Conéctese a lo siguienteAWS IoTservicios para administrar los dispositivos de su solución de IoT.

AWS IoT Core

AWS IoT Corees un servicio de nube gestionado que permite a los dispositivos conectados interactuar
de forma segura con las aplicaciones en la nube y otros dispositivos.AWS IoT Corepuede admitir
muchos dispositivos y mensajes, y puede procesar y enrutar esos mensajes aAWS IoTpuntos finales
y otros dispositivos. ConAWS IoT Core, tus aplicaciones pueden interactuar con todos tus dispositivos
incluso cuando no estén conectados.
AWS IoT Core Device Advisor

AWS IoT CoreAsesor de dispositivoses una capacidad de prueba totalmente gestionada y basada en
la nube para validar los dispositivos de IoT durante el desarrollo del software del dispositivo. Device
Advisor proporciona pruebas prediseñadas que puede utilizar para validar los dispositivos de IoT y
lograr una conectividad confiable y segura conAWS IoT Core, antes de implementar los dispositivos en
producción.
AWS IoT Device Defender

AWS IoTDefensor de dispositivosle ayuda a proteger su flota de dispositivos de IoT.AWS IoT Device
Defender audita continuamente sus configuraciones de IoT para asegurarse de que no se desvíen
de las mejores prácticas de seguridad.AWS IoT Device Defender envía una alerta cuando detecta
cualquier brecha en la configuración de IoT que pueda suponer un riesgo para la seguridad, como
certificados de identidad que se comparten en varios dispositivos o un dispositivo con un certificado de
identidad revocado que intenta conectarse aAWS IoT Core.
AWS IoTAdministración de dispositivos

AWS IoTAdministración de dispositivoslos servicios le ayudan a rastrear, monitorear y administrar

la gran cantidad de dispositivos conectados que componen sus flotas de dispositivos.AWS IoT
Los servicios de administración de dispositivos lo ayudan a garantizar que sus dispositivos de IoT
funcionen de manera adecuada y segura después de su implementación. También ofrecen túneles
seguros para acceder a sus dispositivos, supervisar su estado, detectar y solucionar problemas de
forma remota, así como servicios para gestionar las actualizaciones del software y el firmware de los
dispositivos.

Servicios de datos de AWS IoT

Analice los datos de los dispositivos de su solución de IoT y tome las medidas adecuadas mediante lo
siguiente:AWS IoTservicios.

7
 AWS IoT Core Guía para desarrolladores
AWS IoTdescripción general de los servicios

Amazon Kinesis Video Streams

Transmisiones de vídeo de Amazon Kinesisle permite transmitir vídeo en directo desde dispositivos
aAWSLa nube, donde se almacena, cifra e indexa de forma duradera, lo que le permite acceder a
sus datos a través deeasy-to-useAPIs. Puede utilizar Amazon Kinesis Video Streams para capturar
enormes cantidades de datos de vídeo en directo de millones de fuentes, incluidos teléfonos
inteligentes, cámaras de seguridad, cámaras web, cámaras integradas en automóviles, drones y otras
fuentes. Amazon Kinesis Video Streams le permite reproducir vídeos para verlos en directo y bajo
demanda, y crear rápidamente aplicaciones que aprovechen la visión artificial y el análisis de vídeo
mediante la integración con Amazon Rekognition Video y bibliotecas para marcos de aprendizaje
automático. También puede enviar datos serializados en el tiempo que no sean de vídeo, como, por
ejemplo, datos de audio, imágenes térmicas, datos de profundidad, datos de radar y mucho más.
Transmisiones de vídeo de Amazon Kinesis con WebRTC

Transmisiones de vídeo de Amazon Kinesis con WebRTCproporciona una implementación de

WebRTC que cumple con los estándares como una capacidad totalmente gestionada. Puede utilizar
Amazon Kinesis Video Streams con WebRTC para transmitir contenido multimedia en directo de forma
segura o realizar una interacción bidireccional de audio o vídeo entre cualquier cámara, dispositivo
IoT y reproductores móviles o web compatibles con WebRTC. Al tratarse de una capacidad totalmente
gestionada, no es necesario crear, operar ni escalar ninguna infraestructura en la nube relacionada
con WebrTC, como servidores de señalización o retransmisión multimedia, para transmitir contenido
multimedia de forma segura entre aplicaciones y dispositivos. Con Amazon Kinesis Video Streams
con WebRTC, puede crear fácilmente aplicaciones para Livepeer-to-peertransmisión multimedia o
interactividad de audio o vídeo en tiempo real entre cámaras, dispositivos IoT, navegadores web y
dispositivos móviles para una variedad de casos de uso.
AWS IoT Analytics

AWS IoTAnalíticale permite ejecutar y poner en funcionamiento de manera eficiente análisis

sofisticados en volúmenes masivos de datos de IoT no estructurados.AWS IoT La analítica automatiza
cada paso difícil que se requiere para analizar los datos de los dispositivos de IoT.AWS IoT La
analítica filtra, transforma y enriquece los datos de IoT antes de almacenarlos en un almacén de datos
de series temporales para su análisis. Puede analizar sus datos mediante la ejecución de consultas
únicas o programadas mediante el motor de consultas SQL integrado o el aprendizaje automático.
AWS IoT Events

AWS IoTEventosdetecta y responde a los eventos de los sensores y aplicaciones de IoT. Los eventos
son patrones de datos que identifican circunstancias más complicadas de lo esperado, como los
detectores de movimiento que utilizan señales de movimiento para activar las luces y las cámaras de
seguridad.AWS IoT Events monitorea continuamente los datos de múltiples sensores y aplicaciones
de IoT y se integra con otros servicios, comoAWS IoT Core, Internet de las cosasSiteWise, DynamoDB
y otros para permitir la detección temprana y obtener información única.
AWS IoT FleetWise

AWS IoT FleetWisees un servicio gestionado que puede utilizar para recopilar y transferir datos
de vehículos a la nube prácticamente en tiempo real. ConAWS IoT FleetWise, puede recopilar y
organizar fácilmente datos de vehículos que utilizan diferentes protocolos y formatos de datos.AWS
IoT FleetWiseayuda a transformar los mensajes de bajo nivel en valores legibles por humanos y
a estandarizar el formato de los datos en la nube para el análisis de datos. También puede definir
esquemas de recopilación de datos para controlar qué datos recopilar en los vehículos y cuándo
transferirlos a la nube.
AWS IoT SiteWise

AWS IoT SiteWiserecopila, almacena, organiza y monitorea los datos transmitidos desde los equipos
industriales mediante mensajes o API de MQTT a gran escala, proporcionando un software que se
ejecuta en una puerta de enlace en sus instalaciones. La pasarela se conecta de forma segura a los
servidores de datos locales y automatiza el proceso de recopilación y organización de los datos y su
envío alAWSNube.

8
 AWS IoT Core Guía para desarrolladores
Servicios de AWS IoT Core

AWS IoT TwinMaker

AWS IoT TwinMakerconstruye gemelos digitales operativos de sistemas físicos y digitales.AWS IoT
TwinMakercrea visualizaciones digitales mediante mediciones y análisis de una variedad de sensores,
cámaras y aplicaciones empresariales del mundo real para ayudarlo a realizar un seguimiento de
su fábrica física, edificio o planta industrial. Puede utilizar datos del mundo real para supervisar las
operaciones, diagnosticar y corregir errores y optimizar las operaciones.

Servicios de AWS IoT Core

AWS IoT Coreproporciona los servicios que conectan sus dispositivos de IoT aAWSNube para que otros
servicios y aplicaciones en la nube puedan interactuar con sus dispositivos conectados a Internet.

En la siguiente sección se describe cada uno de losAWS IoT Coreservicios que se muestran en la
ilustración.

AWS IoT Coreservicios de mensajería

ElAWS IoT Corelos servicios de conectividad proporcionan una comunicación segura con los dispositivos
de IoT y gestionan los mensajes que pasan entre ellos yAWS IoT.

Gateway de dispositivos

Permite a los dispositivos comunicarse de forma segura y eficaz con AWS IoT. La comunicación del
dispositivo está protegida por protocolos seguros que utilizan certificados X.509.
Agente de mensajes

Proporciona un mecanismo seguro para que los dispositivos y las aplicaciones de AWS IoT publiquen
y reciban mensajes entre sí. Puede utilizar el protocolo MQTT directamente o MQTT a través
deWebSocketpara publicar y suscribirse. Para obtener más información sobre los protocolos queAWS
IoTsoportes, consultethe section called “Protocolos de comunicación de dispositivos” (p. 87). Los
dispositivos y los clientes también pueden usar la interfaz HTTP REST para publicar datos en el
intermediario de mensajes.

El agente de mensajes distribuye los datos del dispositivo a los dispositivos que se han suscrito a él y
a otrosAWS IoT Coreservicios, como el servicio Device Shadow y el motor de reglas.

9
 AWS IoT Core Guía para desarrolladores
Servicios de AWS IoT Core

AWS IoT CoreporLoRaMENDIGO

AWS IoT CoreporLoRaLa WAN permite configurar una red privadaLoRaRed WAN mediante la
conexión de suLoRaDispositivos WAN y puertas de enlace aAWSsin la necesidad de desarrollar y
operar unLoRaServidor de red WAN (LNS). Mensajes recibidos deLoRaLos dispositivos WAN se
envían al motor de reglas, donde se pueden formatear y enviar a otrosAWS IoTservicios.
Motor de reglas

El motor de reglas conecta los datos del intermediario de mensajes con otrosAWS IoTservicios de
almacenamiento y procesamiento adicional. Por ejemplo, puede insertar, actualizar o consultar una
tabla de DynamoDB o invocar una función de Lambda en función de una expresión que haya definido
en el motor de reglas. Puede utilizar un lenguaje basado en SQL para seleccionar datos de las cargas
de mensajes y, a continuación, procesarlos y enviarlos a otros servicios, como Amazon Simple
Storage Service (Amazon S3), Amazon DynamoDB yAWS Lambda. También puede crear reglas que
vuelvan a publicar los mensajes en el intermediario de mensajes y en otros suscriptores. Para obtener
más información, consulte Reglas para AWS IoT (p. 516).

AWS IoT Coreservicios de control

ElAWS IoT Corelos servicios de control proporcionan funciones de seguridad, administración y registro del
dispositivo.

Servicio de autenticación personalizado

Puede definir autorizadores personalizados que le permitan administrar su propia estrategia de

autenticación y autorización mediante un servicio de autenticación personalizado y una función
Lambda. Los autorizadores personalizados permiten a AWS IoT autenticar sus dispositivos y autorizar
operaciones mediante estrategias de autorización y autenticación de tokens al portador.

Los autorizadores personalizados pueden implementar varias estrategias de autenticación, por

ejemplo, la verificación con JSON Web Token o la llamada al proveedor de OAuth. Deben devolver los
documentos de política que utiliza la pasarela del dispositivo para autorizar las operaciones de MQTT.
Para obtener más información, consulte Autenticación y autorización a la medida (p. 337).
Servicio de aprovisionamiento de dispositivos

Le permite aprovisionar dispositivos mediante una plantilla que describe los recursos necesarios para
su dispositivo: aobjeto objeto, un certificado y una o más políticas. Un objeto objeto es una entrada del
registro que contiene atributos que describen un dispositivo. Los dispositivos usan certificados para
realizar la autenticación con AWS IoT. Las políticas determinan qué operaciones pueden realizar los
dispositivos en AWS IoT.

Las plantillas contienen variables que se sustituirán por los valores en un diccionario (mapa).
Puede usar la misma plantilla para aprovisionar varios dispositivos tan solo pasando diferentes
valores para las variables de la plantilla en el diccionario. Para obtener más información, consulte
Aprovisionamiento de dispositivos (p. 886).
Registro de grupos

Los grupos permiten administrar varios dispositivos a la vez clasificándolos en grupos. Los grupos
también pueden contener grupos; puede crear una jerarquía de grupos. Cualquier acción que realice
en un grupo principal se aplicará a sus grupos secundarios. La misma acción también se aplica
a todos los dispositivos del grupo principal y a todos los dispositivos de los grupos secundarios.
Los permisos concedidos a un grupo se aplicarán a todos los dispositivos del grupo y a todos sus
grupos secundarios. Para obtener más información, consulte Administración de dispositivos con AWS
IoT (p. 281).
Servicio de Jobs

Permite definir un conjunto de operaciones remotas que se envían y se ejecutan en uno o más
dispositivos conectados aAWS IoT. Por ejemplo, puede definir un trabajo que indique a un conjunto de

10
 AWS IoT Core Guía para desarrolladores
Servicios de AWS IoT Core

dispositivos descargar e instalar actualizaciones de firmware y aplicaciones, reiniciar, rotar certificados

o realizar operaciones remotas de solución de problemas.

Para crear un trabajo, especifique una descripción de las operaciones remotas que se van a realizar y
una lista de destinos que deben realizarlas. Los destinos pueden ser dispositivos individuales, grupos
o ambos. Para obtener más información, consulte Trabajos (p. 731).
Registry (Registro)

Organiza los recursos asociados a cada dispositivo enAWSNube. Es necesario registrar los
dispositivos y asociar hasta tres atributos personalizados a cada uno. También es posible asociar
certificados e ID de cliente MQTT a cada dispositivo para poder administrarlos y solucionar los
problemas que presenten con mayor facilidad. Para obtener más información, consulte Administración
de dispositivos con AWS IoT (p. 281).
Servicio de seguridad e identidad

Proporciona una responsabilidad compartida en materia de seguridad enAWSNube. Sus dispositivos

deben mantener sus credenciales seguras para enviar datos de forma segura al intermediario de
mensajes. El agente de mensajes y el motor de reglas que utilizanAWSfunciones de seguridad para
enviar datos de forma segura a dispositivos u otrosAWSservicios. Para obtener más información,
consulte Autenticación (p. 310).

Servicios de datos de AWS IoT Core

ElAWS IoT Corelos servicios de datos ayudan a sus soluciones de IoT a ofrecer una experiencia de
aplicación confiable incluso con dispositivos que no siempre están conectados.

Sombra del dispositivo

Documento JSON utilizado para almacenar y recuperar información del estado actual de un
dispositivo.
Servicio Device Shadow

El servicio Device Shadow mantiene el estado del dispositivo para que las aplicaciones puedan
comunicarse con él, ya sea que el dispositivo esté en línea o no. Cuando un dispositivo está
desconectado, el servicio Device Shadow administra los datos de las aplicaciones conectadas.
Cuando el dispositivo se vuelve a conectar, sincroniza su estado con el de su sombra en el servicio
Device Shadow. Los dispositivos también pueden publicar su estado actual en una sombra para
que las aplicaciones u otros dispositivos que no estén conectados todo el tiempo. Para obtener más
información, consulte Servicio Device Shadow de AWS IoT (p. 683).

AWS IoT Coreservicio de soporte

Integración con Amazon Sidewalk paraAWS IoT Core

Amazon Sidewalkes una red compartida que mejora las opciones de conectividad para ayudar a que
los dispositivos funcionen mejor juntos. Amazon Sidewalk es compatible con una amplia gama de
dispositivos de los clientes, como los que localizan mascotas u objetos de valor, los que proporcionan
un control inteligente de la seguridad del hogar y la iluminación, y los que proporcionan diagnósticos
remotos para electrodomésticos y herramientas. Integración con Amazon Sidewalk paraAWS IoT
Corepermite a los fabricantes de dispositivos añadir su flota de dispositivos Sidewalk a laAWS
IoTNube.

Para obtener más información, consulte AWS IoT Core para Amazon Sidewalk (p. 1397)

11
 AWS IoT Core Guía para desarrolladores
Obtener más información sobre AWS IoT

Obtener más información sobre AWS IoT

Este tema le ayuda a familiarizarse con el mundo deAWS IoT. Puede obtener información general sobre
cómo se aplican las soluciones de IoT en varios casos de uso, recursos de capacitación y enlaces a
las redes sociales paraAWS IoTy todos los demásAWSservicios y una lista de servicios y protocolos de
comunicación queAWS IoTusos.

Recursos de formación paraAWS IoT

Ofrecemos estos cursos de capacitación para ayudarlo a aprender sobreAWS IoTy cómo aplicarlos al
diseño de su solución.

• Introducción a AWS IoT

Un resumen en vídeo deAWS IoTy sus servicios principales.

• Profundice enAWS IoTAutenticación y autorización

Un curso avanzado que explora los conceptos deAWS IoTautenticación y autorización. Aprenderá a
autenticar y autorizar a los clientes a acceder alAWS IoTAPI de plano de control y plano de datos.
• Serie básica de Internet de las cosas

Una ruta de aprendizaje de módulos de aprendizaje electrónico de IoT sobre diferentes tecnologías y
funciones de IoT.

AWS IoTrecursos y guías

Se trata de recursos técnicos detallados sobre aspectos específicos deAWS IoT.

• Lente de IoT —AWS IoTMarco bien diseñado

Un documento que describe las mejores prácticas para diseñar la arquitectura de sus aplicaciones de
IoT enAWS.
• Diseño de temas de MQTT paraAWS IoT Core

Un documento técnico que describe las mejores prácticas para diseñar temas de MQTT enAWS IoT
Corey apalancamientoAWS IoT Corefunciones con MQTT.
• Resumen e introducción

Un documento PDF que describe las diferentes formas en queAWS IoTpermite aprovisionar grandes
flotas de dispositivos.
• AWS IoT Core Device Advisor

AWS IoT CoreDevice Advisor proporciona pruebas prediseñadas que puede utilizar para validar los
dispositivos de IoT y obtener las mejores prácticas de conectividad confiable y segura conAWS IoT Core,
antes de implementar los dispositivos en producción.
• Recursos de AWS IoT

Los recursos específicos del IoT, como guías técnicas, arquitecturas de referencia, libros electrónicos y
publicaciones de blog seleccionadas, se presentan en un índice con capacidad de búsqueda.
• Atlas de IoT

Información general sobre cómo resolver problemas comunes de diseño de IoT. ElAtlas de
IoTproporciona un análisis detallado de los desafíos de diseño que probablemente encontrará al
desarrollar su solución de IoT.

12
 AWS IoT Core Guía para desarrolladores
AWS IoTen las redes sociales

• AWSDocumentos técnicos y guías

Nuestra colección actual de documentos técnicos y guías sobreAWS IoTy otrosAWStecnologías.

AWS IoTen las redes sociales

Estos canales de redes sociales proporcionan información sobreAWS IoTyAWStemas relacionados.

• El Internet de las cosas enAWS IoT— Blog oficial

• AWS IoTvídeos en el canal Amazon Web Services enYouTube

Estas cuentas de redes sociales cubren todosAWSservicios, que incluyenAWS IoT

• El canal de Amazon Web Services enYouTube

• Amazon Web Services en Twitter
• Amazon Web Services en Facebook
• Amazon Web Services en Instagram
• Amazon Web Services enLinkedIn

AWSservicios utilizados porAWS IoT Coremotor de

reglas
ElAWS IoT Coreel motor de reglas puede conectarse a estosAWSservicios.

• Amazon DynamoDB

Amazon DynamoDB es un servicio de base de datos NoSQL escalable que proporciona un rendimiento
de base de datos rápido y predecible.
• Amazon Kinesis

Amazon Kinesis facilita la recopilación, el procesamiento y el análisis de datos de streaming en tiempo

real para que pueda obtener información oportuna y reaccionar rápidamente ante la nueva información.
Amazon Kinesis puede recopilar datos en tiempo real, como vídeo, audio, registros de aplicaciones,
secuencias de clics de sitios web y datos de telemetría de IoT para el aprendizaje automático, el análisis
y otras aplicaciones.
• AWS Lambda

AWS Lambda le permite ejecutar código sin aprovisionar ni administrar servidores. Puedes configurar
tu código para que se active automáticamente desdeAWS IoTdatos y eventos o llámalo directamente
desde una aplicación web o móvil.
• Amazon Simple Storage Service

Amazon Simple Storage Service (Amazon S3) puede almacenar y recuperar cualquier cantidad de datos
en cualquier momento y desde cualquier lugar de la web.AWS IoTlas reglas pueden enviar datos a
Amazon S3 para su almacenamiento.
• Amazon Simple Notification Service

Amazon Simple Notification Service (Amazon SNS) es un servicio web que permite a las aplicaciones,
los usuarios finales y los dispositivos enviar y recibir notificaciones desde la nube.
• Amazon Simple Queue Service

13
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación compatibles conAWS IoT Core

Amazon Simple Queue Service (Amazon SQS) es un servicio de colas de mensajes que desacopla y
escala los microservicios, los sistemas distribuidos y las aplicaciones sin servidor.
• AmazonOpenSearchServicio

AmazonOpenSearchServicio (OpenSearchService) es un servicio gestionado que facilita la

implementación, el funcionamiento y la escalabilidadOpenSearch, un popular motor de búsqueda y
análisis de código abierto.
• Amazon SageMaker

AmazonSageMakerpuede crear modelos de aprendizaje automático (ML) mediante la búsqueda de

patrones en sus datos de IoT. El servicio utiliza estos modelos para procesar datos nuevos y generar
predicciones para su aplicación.
• Amazon CloudWatch

AmazonCloudWatchproporciona una solución de monitoreo confiable, escalable y flexible para ayudar a

configurar, administrar y escalar sus propios sistemas e infraestructura de monitoreo.

Protocolos de comunicación compatibles conAWS IoT

Core
En estos temas se proporciona más información sobre los protocolos de comunicación utilizados porAWS
IoT. Para obtener más información sobre los protocolos utilizados porAWS IoTy conectar dispositivos y
servicios aAWS IoT, consulteConexión a AWS IoT Core (p. 74).

• MQTT (transporte telemétrico en cola de mensajes)

La página principal del sitio MQTT.org donde puede encontrar las especificaciones del protocolo MQTT.
Para obtener más información sobre cómoAWS IoTadmite MQTT, consulteMQTT (p. 90).
• HTTPS (Protocolo de transferencia de hipertexto - Seguro)

Los dispositivos y las aplicaciones pueden accederAWS IoTservicios mediante HTTPS.

• LoRaWAN (red de área amplia de largo alcance)

LoRaLos dispositivos WAN y las puertas de enlace se pueden conectar aAWS IoT Coremediante el
usoAWS IoT CoreporLoRaMENDIGO.
• TLS (Transport Layer Security) v1.2

La especificación del TLS v1.2 (RFC 5246).AWS IoTusa TLS v1.2 para establecer conexiones seguras
entre dispositivos yAWS IoT.

Novedades de laAWS IoT consola de de de de de

de la de de
Estamos actualizando la interfaz de usuario de laAWS IoT consola para ofrecer una nueva experiencia.
Vamos a actualizar la interfaz de usuario por etapas, por lo que algunas páginas de la consola ofrecerán
una experiencia nueva, otras tendrán tanto la original como la nueva y otras solo la experiencia original.

Esta tabla muestra el estado de las áreas individuales de la interfaz de usuario de laAWS IoT consola al 27
de enero de 2022.

14
 AWS IoT Core Guía para desarrolladores
Novedades de laAWS IoT consola
de de de de de de la de de

AWS IoTestado de la interfaz de usuario de la consola

Página de consola experiencia de nueva experiencia Comentarios

experiencia de nueva experiencia de
experiencia

Monitorización No disponible Disponible

Actividad No disponible Disponible

A bordo: comience No disponible Disponible No disponible en las

regiones de CN

Onboard: plantillas de Disponible Disponible

aprovisionamiento de
flota

Administrar: cosas Disponible Disponible

Administrar: tipos Disponible Disponible

Administrar: grupos de Disponible Disponible

cosas

Administrar - Grupos de Disponible Disponible

facturación

Administrar - Trabajos Disponible Disponible

Administrar: plantillas de No disponible Disponible

Job

Administrar - Túneles No disponible Disponible

Fleet Hub: comience No disponible Disponible No está disponible en

todosRegiones de AWS

Fleet Hub - Aplicaciones No disponible Disponible No está disponible en

todosRegiones de AWS

Greengrass - Primeros No disponible Disponible No está disponible en

pasos todosRegiones de AWS

Greengrass - No disponible Disponible No está disponible en

Dispositivos principales todosRegiones de AWS

Greengrass - No disponible Disponible No está disponible en

Componentes todosRegiones de AWS

Greengrass - No disponible Disponible No está disponible en

Implementaciones todosRegiones de AWS

Greengrass - Clásico Disponible Disponible

(V1)

Conectividad No disponible Disponible No está disponible en

inalámbrica: todosRegiones de AWS
introducción

15
 AWS IoT Core Guía para desarrolladores
Leyenda

Página de consola experiencia de nueva experiencia Comentarios

experiencia de nueva experiencia de
experiencia

Conectividad No disponible Disponible No está disponible en

inalámbrica: puertas de todosRegiones de AWS
enlace

Conectividad No disponible Disponible No está disponible en

inalámbrica: dispositivos todosRegiones de AWS

Conectividad No disponible Disponible No está disponible en

inalámbrica: perfiles todosRegiones de AWS

Conectividad No disponible Disponible No está disponible en

inalámbrica: destinos todosRegiones de AWS

Seguro: certificados Disponible Disponible

Seguro: políticas Disponible Disponible

Seguro: CA Disponible Disponible

Secure - Alias de rol Disponible Disponible

Seguro: autorizadores Disponible Disponible

Defend - Introducción No disponible Disponible

Defender - Auditoría No disponible Disponible

Defender - Detectar No disponible Disponible

Defender: acciones de No disponible Disponible

mitigación

Defender - Ajustes No disponible Disponible

Ley - Reglamento Disponible Disponible

Ley - Destinos Disponible Disponible

Prueba - Device Advisor Disponible Disponible No está disponible en

todosRegiones de AWS

Prueba: cliente de Disponible Disponible

prueba MQTT

Software Disponible Disponible

Configuración No disponible Disponible

Aprende Disponible Aún no está disponible

Leyenda
Valores de estado

• Disponible

16
 AWS IoT Core Guía para desarrolladores
Leyenda

Se puede utilizar esta experiencia de interfaz de usuario.

• No disponible

No se puede utilizar esta experiencia de interfaz de usuario.

• Aún no está disponible

Se está trabajando en la nueva experiencia de interfaz de usuario, pero aún no está lista.
• En curso

La nueva experiencia de la nueva nueva experiencia de la nueva experiencia de la nueva experiencia de

la nueva experiencia de la nueva experiencia de la nueva Sin embargo, es posible que algunas páginas
sigan teniendo la experiencia de usuario original.

17
 AWS IoT Core Guía para desarrolladores
Conecta tu primer dispositivo aAWS IoT Core

Introducción a AWS IoT Core

Tanto si es nuevo en el mundo del IoT como si ya tiene años de experiencia, estos recursos presentan
laAWS IoTconceptos y términos que le ayudarán a empezar a usarAWS IoT.

• MirainternoAWS IoTy sus componentes enCómo funciona AWS IoT (p. 3).
• Aprendemás sobreAWS IoT (p. 12)de nuestra colección de materiales y vídeos de formación. Este tema
también incluye una lista de servicios queAWS IoTpuede conectarse a enlaces de redes sociales y
enlaces a las especificaciones del protocolo de comunicación.
• the section called “Conecta tu primer dispositivo aAWS IoT Core” (p. 18).
• Desarrollarsus soluciones de IoT medianteConexión a AWS IoT Core (p. 74)y explorando elTutoriales
de AWS IoT (p. 139).
• Probar y validarsus dispositivos de IoT para una comunicación segura y confiable mediante elAsesor de
dispositivos (p. 1148).
• Administrarsu solución mediante el uso deAWS IoT Coreservicios de administración comoIndexación de
flota (p. 921),Trabajos (p. 731), yAWS IoT Device Defender (p. 966).
• Analizalos datos de sus dispositivos mediante elServicios de datos de AWS IoT (p. 7).

Conecta tu primer dispositivo aAWS IoT Core

AWS IoT Corelos servicios conectan los dispositivos de IoT aAWS IoTservicios y otrosAWSservicios.AWS
IoT Coreincluye la puerta de enlace del dispositivo y el intermediario de mensajes, que conectan y
procesan los mensajes entre sus dispositivos de IoT y la nube.

A continuación, le indicamos cómo puede empezar conAWS IoT CoreyAWS IoT.

Esta sección presenta un recorrido por elAWS IoT Corepara presentar sus servicios clave y ofrece varios
ejemplos de cómo conectar un dispositivo aAWS IoT Corey pasar mensajes entre ellos. La transmisión de
mensajes entre los dispositivos y la nube es fundamental para todas las soluciones de IoT y es la forma en
que sus dispositivos pueden interactuar con otrasAWSservicios.

• Configura tuCuenta de AWS (p. 19)

Antes de poder usarAWS IoTservicios, debe configurar unCuenta de AWS. Si ya tienes unCuenta de
AWSy un usuario de IAM para usted, puede usarlos y omitir este paso.
• Prueba el tutorial interactivo (p. 21)

18
 AWS IoT Core Guía para desarrolladores
Configura tuCuenta de AWS

Esta demostración es la mejor si quieres ver qué es lo básicoAWS IoTla solución puede funcionar
sin conectar un dispositivo ni descargar ningún software. El tutorial interactivo presenta una solución
simulada basada enAWS IoT Coreservicios que ilustran cómo interactúan.
• Prueba el tutorial de conexión rápida (p. 23)

Este tutorial es el mejor si quieres empezar rápidamente conAWS IoTy vea cómo funciona en un
escenario limitado. En este tutorial, necesitarás un dispositivo e instalarás algunosAWS IoTsoftware
que contiene. Si no tienes un dispositivo de IoT, puedes usar tu ordenador personal Windows, Linux o
macOS como dispositivo para este tutorial. Si quieres probarAWS IoT, pero no tienes un dispositivo,
prueba la siguiente opción.
• ExploreAWS IoT Coreservicios con un tutorial práctico (p. 37)

Este tutorial es ideal para los desarrolladores que quieren empezar conAWS IoTpara que puedan seguir
explorando otrosAWS IoT Corefunciones como el motor de reglas y las sombras. Este tutorial sigue
un proceso similar al tutorial de conexión rápida, pero proporciona más detalles sobre cada paso para
permitir una transición más sencilla a los tutoriales más avanzados.
• Vea los mensajes MQTT conAWS IoTCliente MQTT (p. 69)

Aprenda a usar el cliente de prueba de MQTT para ver cómo su primer dispositivo publica mensajes
MQTT enAWS IoT. El cliente de prueba MQTT es una herramienta útil para monitorear y solucionar
problemas de conexiones de dispositivos.

Note

Si quieres probar más de uno de estos tutoriales de introducción o repetir el mismo tutorial, debes
eliminar el objeto thing que creaste de un tutorial anterior antes de empezar otro. Si no eliminas
el objeto objeto de un tutorial anterior, tendrás que usar un nombre diferente para los tutoriales
posteriores. Esto se debe a que el nombre de la cosa debe ser único en tu cuenta yRegión de
AWS.

Para obtener más información acerca de AWS IoT Core, consulte ¿Qué es AWS IoT Core? (p. 1).

Configura tuCuenta de AWS

Antes de usar AWS IoT Core por primera vez, realice las siguientes tareas:

Temas
• Registro en una Cuenta de AWS (p. 19)
• Crear un usuario administrativo (p. 20)
• Abra elAWS IoTconsola (p. 20)

Registro en una Cuenta de AWS

Si no dispone de una Cuenta de AWS, siga los pasos que figuran a continuación para crear una.

Para registrarse en Cuenta de AWS

1. Abra https://portal.aws.amazon.com/billing/signup.
2. Siga las instrucciones en línea.

Parte del procedimiento de inscripción consiste en recibir una llamada telefónica e indicar un código de
verificación en el teclado del teléfono.

19
 AWS IoT Core Guía para desarrolladores
Crear un usuario administrativo

Al registrase en una Cuenta de AWS, se crea un Usuario raíz de la cuenta de AWS. El usuario raíz
tiene acceso a todos los recursos y Servicios de AWS de esa cuenta. Como práctica recomendada de
seguridad, asigne acceso administrativo a un usuario administrativo y utilice únicamente el usuario raíz
para realizar la ejecución tareas que requieren acceso de usuario raíz.

AWS le enviará un email de confirmación luego de completar el proceso de registro. Puede ver la actividad
de la cuenta y administrar la cuenta en cualquier momento entrando en https://aws.amazon.com/ y
seleccionando My Account (Mi cuenta).

Crear un usuario administrativo

Después de registrarse para obtener una Cuenta de AWS, cree un usuario administrativo para que no
utilice el usuario raíz en las tareas cotidianas.

Proteger su Usuario raíz de la cuenta de AWS

1. Inicie sesión en AWS Management Console como propietario de cuenta eligiendo Usuario raíz e
ingrese el email de su Cuenta de AWS. En la siguiente página, escriba su contraseña.

Para obtener ayuda para iniciar sesión con el usuario raíz, consulte Signing in as the root user (Iniciar
sesión como usuario raíz) en la Guía del usuario de AWS Sign-In.
2. Active la autenticación multifactor (MFA) para el usuario raíz.

Para obtener instrucciones, consulte Habilitar un dispositivo MFA virtual para el usuario raíz Cuenta de
AWS (consola) en la Guía del usuario de IAM.

Crear un usuario administrativo

• Para las tareas administrativas diarias, conceda acceso administrativo a un usuario administrativo en
AWS IAM Identity Center.

Para obtener instrucciones, consulte Introducción en la Guía del usuario de AWS IAM Identity Center.

Iniciar sesión como usuario administrativo

• Para iniciar sesión con el usuario del Centro de identidades de IAM, utilice la URL de inicio de sesión
que se envió a la dirección de correo electrónico cuando creó el usuario del Centro de identidades de
IAM.

Para obtener ayuda para iniciar sesión con un usuario del Centro de identidades de IAM, consulte
Iniciar sesión en el portal de acceso de AWS en la Guía del usuario de AWS Sign-In.

• Abra elAWS IoTconsola (p. 20)

Si ya tienes unCuenta de AWSy un usuario para ti, puedes usarlos y pasar athe section called “Abra
elAWS IoTconsola” (p. 20).

Abra elAWS IoTconsola

La mayoría de los temas de esta sección orientados a la consola comienzan conAWS IoTconsola. Si aún
no has iniciado sesión en tuCuenta de AWS, inicia sesión y, a continuación, abre elAWS IoTconsolay
continúa con la siguiente sección para continuar conAWS IoT.

20
 AWS IoT Core Guía para desarrolladores
Pruebe elAWS IoT Coretutorial interactivo

Pruebe elAWS IoT Coretutorial interactivo

El tutorial interactivo muestra los componentes de una solución de IoT sencilla basada enAWS IoT. Las
animaciones del tutorial muestran cómo interactúan los dispositivos de IoT conAWS IoT Coreservicios. En
este tema se proporciona una vista previa deAWS IoT Coretutorial interactivo. Las imágenes de la consola
incluyen animaciones que no aparecen en las imágenes de este tutorial.

Para ejecutar la demostración, primero debethe section called “Configura tuCuenta de AWS” (p. 19). El
tutorial, sin embargo, no requiere ningunaAWS IoTrecursos, software adicional o cualquier código.

Espere dedicar aproximadamente de 5 a 10 minutos a esta demostración. Dedicarte 10 minutos te

permitirá tener más tiempo para comprender cada uno de los pasos.

Para ejecutar elAWS IoT Coretutorial interactivo

1. Abra elAWS IoTpágina principalen elAWS IoTconsola.

En elAWS IoTpágina principal, en elRecursos de aprendizajepanel de ventana, elijaIniciar tutorial.

2. En elAWS IoTTutorial de consolapágina, revise las secciones del tutorial y elijaSección de

iniciocuando esté listo para continuar.

En las siguientes secciones se describe cómoAWS IoTTutorial de consolapresenta estosAWS IoT

Corecaracterísticas:
• Conexión de dispositivos de IoT (p. 21)
• Guardar el estado del dispositivo sin conexión (p. 22)
• Enrutamiento de los datos del dispositivo a los servicios (p. 23)

Conexión de dispositivos de IoT

Descubra cómo se comunican los dispositivos de IoT conAWS IoT Core.

21
 AWS IoT Core Guía para desarrolladores
Guardar el estado del dispositivo sin conexión

La animación de este paso muestra cómo dos dispositivos, el dispositivo de control de la izquierda y una
lámpara inteligente de la casa a la derecha, se conectan y se comunican conAWS IoT Coreen la nube. La
animación muestra los dispositivos que se comunican conAWS IoT Corey reaccionando a los mensajes
que reciben.

Para obtener más información sobre la conexión de dispositivos aAWS IoT Core, consulteConexión a AWS
IoT Core (p. 74).

Guardar el estado del dispositivo sin conexión

Conozca cómoAWS IoT Coreguarda el estado del dispositivo mientras un dispositivo o una aplicación
están fuera de línea.

La animación de este paso muestra cómo el servicio Device Shadow enAWS IoT Coreguarda la
información del estado del dispositivo para el dispositivo de control y la lámpara inteligente. Mientras la
lámpara inteligente está desconectada, Device Shadow guarda los comandos del dispositivo de control.

22
 AWS IoT Core Guía para desarrolladores
Enrutamiento de los datos del dispositivo a los servicios

Cuando la lámpara inteligente se vuelva a conectar aAWS IoT Core, recupera esos comandos. Cuando el
dispositivo de control está desconectado, Device Shadow guarda la información de estado de la lámpara
inteligente. Cuando el dispositivo de control se vuelve a conectar, recupera el estado actual de la lámpara
inteligente para actualizar su pantalla.

Para obtener más información sobre Device Shadows, consulteServicio Device Shadow de AWS
IoT (p. 683).

Enrutamiento de los datos del dispositivo a los

servicios
Conozca cómoAWS IoT Coreenvía el estado del dispositivo a otrosAWSservicios.

La animación de este paso muestra cómoAWS IoT Coreenvía datos de los dispositivos a
otrosAWSservicios mediante el uso deAWS IoTreglas.AWS IoTlas reglas se suscriben a mensajes
específicos de los dispositivos, interpretan los datos de esos mensajes y enrutan los datos interpretados
a otros servicios. En este ejemplo, unAWS IoTLa regla interpreta los datos de un sensor de movimiento
y envía los comandos a un Device Shadow, que luego los envía a la bombilla inteligente. Como en el
ejemplo anterior, Device Shadow almacena la información del estado del dispositivo de control.

Para obtener más información acerca de las reglas del AWS IoT, consulte Reglas para AWS IoT (p. 516).

Pruebe elAWS IoTconexión rápida

En este tutorial, crearás tu primer objeto, conectarás un dispositivo a él y verás cómo envía mensajes
MQTT.

Puede esperar dedicar entre 15 y 20 minutos a este tutorial.

Este tutorial es el mejor para las personas que desean comenzar rápidamente conAWS IoTpara ver cómo
funciona en un escenario limitado. Si estás buscando un ejemplo que te ayude a empezar a explorar más
funciones y servicios, pruebaExploreAWS IoT Coreservicios en un tutorial práctico (p. 37).

En este tutorial, descargarás y ejecutarás el software en un dispositivo que se conecte a unrecurso

de cosasenAWS IoT Corecomo parte de una solución de IoT muy pequeña. El dispositivo puede

23
 AWS IoT Core Guía para desarrolladores
Paso 1. Iniciar el tutorial

ser un dispositivo de IoT, como una Raspberry Pi, o también puede ser un ordenador que ejecute
Linux, OS y OSX o Windows. Si desea conectar una WAN de largo alcance (LoRadispositivo
WAN (a) paraAWS IoT, consulte el tutorialConexión de dispositivos y puertas de enlace aAWS IoT
CoreporLoRaMENGUAR (p. 1272).

Si el dispositivo admite un navegador que pueda ejecutar elAWS IoTconsola, le recomendamos que
complete este tutorial en ese dispositivo.
Note

Si tu dispositivo no tiene un navegador compatible, sigue este tutorial en un ordenador. Cuando

el procedimiento le pida que descargue el archivo, descárguelo a su ordenador y, a continuación,
transfiera el archivo descargado al dispositivo mediante Secure Copy (SCP) o un proceso similar.

El tutorial requiere que su dispositivo de IoT se comunique con el puerto 8443 de suCuenta de AWSpunto
final de datos del dispositivo. Para comprobar si puede acceder a ese puerto, pruebe los procedimientos
deProbar la conectividad con el terminal de datos de su dispositivo (p. 33).

Paso 1. Iniciar el tutorial

Si es posible, complete este procedimiento en su dispositivo; de lo contrario, prepárese para transferir un
archivo a su dispositivo más adelante en este procedimiento.

Para iniciar el tutorial, inicie sesión enAWS IoTconsola. En elAWS IoTpágina principal de la consola, a la
izquierda, eligeConectary luego eligeConectar un dispositivo.

Paso 2. Crea una cosa (objeto)

1. En elPrepara tu dispositivosección, siga las instrucciones que aparecen en pantalla para preparar el
dispositivo para conectarse aAWS IoT.

24
 AWS IoT Core Guía para desarrolladores
Paso 2. Crea una cosa (objeto)

2. En elRegistra y protege tu dispositivosección, eligeCrea algo nuevooElige una cosa existente. En

elNombre de la cosacampo, introduce el nombre del objeto de tu cosa. El nombre de la cosa que se
usa en este ejemplo esTutorialTestThing
Important

Comprueba el nombre de tu cosa antes de continuar.

El nombre de una cosa no se puede cambiar después de crear el objeto de la cosa. Si desea
cambiar el nombre de una cosa, debe crear un objeto nuevo con el nombre de cosa correcto
y, a continuación, eliminar el que tenga el nombre incorrecto.

En elConfiguraciones adicionalessección, personalice aún más su recurso de cosas utilizando las

configuraciones opcionales enumeradas.

Después de darle un nombre a tu objeto de cosas y seleccionar cualquier configuración adicional,

eligeSiguiente.

25
 AWS IoT Core Guía para desarrolladores
Paso 2. Crea una cosa (objeto)

3. En elElija la plataforma y el SDKsección, elige la plataforma y el idioma delAWS IoTSDK del

dispositivo que quieres usar. En este ejemplo se utiliza la plataforma Linux/OSX y el SDK de Python.
Asegúrate de tener python3 y pip3 instalados en tu dispositivo de destino antes de continuar con el
siguiente paso.
Note

Asegúrese de consultar la lista del software necesario para el SDK que haya elegido en la
parte inferior de la página de la consola.
Debe tener el software necesario instalado en el equipo de destino antes de continuar con el
siguiente paso.

Después de elegir la plataforma y el idioma del SDK del dispositivo, eligeSiguiente.

26
 AWS IoT Core Guía para desarrolladores
Paso 3. Descarga archivos a tu dispositivo

Paso 3. Descarga archivos a tu dispositivo

Esta página aparece despuésAWS IoTha creado el kit de conexión, que incluye los siguientes archivos y
recursos que el dispositivo necesita:

• La cosa son archivos de certificados que se utilizan para autenticar el dispositivo.

• Un recurso de políticas para autorizar que tu objeto objeto interactúe con élAWS IoT
• El script para descargar elAWSDevice SDK y ejecute el programa de muestra en su dispositivo

1. Cuando esté listo para continuar, elijaDescargue el kit de conexión parabotón para descargar el kit de
conexión para la plataforma que eligió anteriormente.

27
 AWS IoT Core Guía para desarrolladores
Paso 3. Descarga archivos a tu dispositivo

2. Si ejecuta este procedimiento en el dispositivo, guarde el archivo del kit de conexión en un directorio
desde el que pueda ejecutar los comandos de línea de comandos.

Si no está ejecutando este procedimiento en el dispositivo, guarde el archivo del kit de conexión en un
directorio local y, a continuación, transfiera el archivo al dispositivo.
3. En elDescomprime el kit de conexión en tu dispositivosección, introduzcaunzip
connect_device_package.zipen el directorio donde se encuentran los archivos del kit de conexión.

Si usas un WindowsPowerShellventana de comandos yunzipel comando no funciona,

reemplazaunzipconexpand-archive, y vuelva a probar la línea de comandos.
4. Una vez que tenga el archivo del kit de conexión en el dispositivo, continúe con el tutorial
seleccionandoSiguiente.

28
 AWS IoT Core Guía para desarrolladores
Paso 4. Ejecute la muestra

Paso 4. Ejecute la muestra

Realice este procedimiento en una terminal o ventana de comandos del dispositivo mientras sigue las
instrucciones que aparecen en la consola. Los comandos que ves en la consola son para el sistema
operativo que has elegidothe section called “Paso 2. Crea una cosa (objeto)” (p. 24). Los que se
muestran aquí son para los sistemas operativos Linux/OSX.

1. En una terminal o ventana de comandos del dispositivo, en el directorio que contiene el archivo del kit
de conexión, siga los pasos que se muestran enAWS IoTconsola.

29
 AWS IoT Core Guía para desarrolladores
Paso 4. Ejecute la muestra

2. Después de introducir el comando desdePaso 2en la consola, deberías ver una salida en la terminal o
ventana de comandos del dispositivo similar a la siguiente. Esta salida proviene de los mensajes a los
que el programa envía y luego recibe de vuelta.AWS IoT Core.

Mientras se ejecuta el programa de ejemplo, el mensaje de pruebaHello World!aparecerá también.

El mensaje de prueba aparece en la terminal o en la ventana de comandos del dispositivo.
Note

Para obtener más información sobre la suscripción y la publicación de temas, consulta el

código de ejemplo del SDK que hayas elegido.

30
 AWS IoT Core Guía para desarrolladores
Paso 4. Ejecute la muestra

3. Para volver a ejecutar el programa de ejemplo, puede repetir los comandos dePaso 2en la consola de
este procedimiento.
4. (Opcional) Si desea ver los mensajes de su cliente de IoT en elAWS IoTconsola, abra elcliente de
prueba MQTTen elPruebapágina delAWS IoTconsola. Si eligió el SDK de Python, entonces encliente
de prueba MQTT, enFiltro de temas, introduzca el tema, comosdk/test/pythonpara suscribirse
a los mensajes de su dispositivo. Los filtros de temas distinguen entre mayúsculas y minúsculas y
dependen del lenguaje de programación del SDK que haya elegido enPaso 1. Para obtener más
información sobre la suscripción y la publicación de temas, consulta el ejemplo de código del SDK que
hayas elegido.
5. Después de suscribirse al tema de prueba, ejecute./start.shen tu dispositivo. Para obtener más
información, consulte the section called “Ver los mensajes MQTT con el cliente MQTT de AWS
IoT” (p. 69).

Después de correr./start.sh, aparecen mensajes en el cliente MQTT, similares a los siguientes:

{
"message": "Hello World!" [1]
}

Elsequencenúmero incluido en[]aumenta en uno cada vez que se crea un nuevoHello World!se
recibe el mensaje y se detiene al finalizar el programa.
6. Para finalizar el tutorial y ver un resumen, enAWS IoTconsola, eligeContinuar.

31
 AWS IoT Core Guía para desarrolladores
Paso 4. Ejecute la muestra

7. Un resumen de susAWS IoTAhora aparecerá el tutorial de conexión rápida.

32
 AWS IoT Core Guía para desarrolladores
Paso 5. Explore más

Paso 5. Explore más

Estas son algunas ideas para explorarAWS IoTmás adelante después de completar el inicio rápido.

• Ver los mensajes MQTT en el cliente de prueba MQTT

Desde elAWS IoTconsola, puede abrir elCliente MQTTen elPruebapágina delAWS IoTconsola. En
elcliente de prueba MQTT, suscríbete a#, y luego, en tu dispositivo, ejecuta el programa./start.shcomo
se describe en el paso anterior. Para obtener más información, consulte the section called “Ver los
mensajes MQTT con el cliente MQTT de AWS IoT” (p. 69).
• Realiza pruebas en tus dispositivos conAsesor de dispositivos

Utilice Device Advisor para comprobar si sus dispositivos pueden conectarse de forma segura y
confiable e interactuar con,AWS IoT.
• the section called “Pruebe elAWS IoT Coretutorial interactivo” (p. 21)

Para iniciar el tutorial interactivo, desdeAprendepágina delAWS IoTconsola, en elVea cómoAWS

IoTfuncionaazulejo, eligeIniciar el tutorial.
• Prepárate para explorar más tutoriales (p. 37)

Este inicio rápido le ofrece solo una muestra deAWS IoT. Si quieres explorarAWS IoTcontinúe y conozca
las características que la convierten en una poderosa plataforma de soluciones de IoT, comience a
preparar su plataforma de desarrollo de la siguiente manera:ExploreAWS IoT Coreservicios en un tutorial
práctico (p. 37).

Probar la conectividad con el terminal de datos de su

dispositivo
En este tema se describe cómo probar la conexión de un dispositivo con la de tu cuentapunto final de
datos del dispositivo, el punto final al que utilizan sus dispositivos de IoT para conectarseAWS IoT.

Realice estos procedimientos en el dispositivo que desee probar o mediante una sesión de terminal SSH
conectada al dispositivo que desee probar.

Para probar la conectividad de un dispositivo con el terminal de datos del dispositivo.

• Encuentra el punto final de datos de tu dispositivo (p. 33)
• Pruebe la conexión rápidamente (p. 34)
• Haz que la aplicación pruebe la conexión al puerto y al punto final de datos de tu dispositivo (p. 34)
• Pruebe la conexión al puerto y punto final de datos del dispositivo (p. 37)

Encuentra el punto final de datos de tu dispositivo

Para encontrar el punto final de datos de tu dispositivo

1. En elAWS IoTconsola, cerca de la parte inferior del panel de navegación, elijaAjustes.

2. En elAjustespágina, en elPunto final de datos del dispositivocontenedor, localice elPunto
finalvalórelo y cópielo. El valor de su punto final es único para suCuenta de AWSy es similar a este
ejemplo:a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com.
3.
Guarde el extremo de datos del dispositivo para usarlo en los siguientes procedimientos.

33
 AWS IoT Core Guía para desarrolladores
Probar la conectividad con el
terminal de datos de su dispositivo

Pruebe la conexión rápidamente

Este procedimiento prueba la conectividad general con el extremo de datos del dispositivo, pero no
comprueba el puerto específico que utilizarán los dispositivos. Esta prueba utiliza un programa común y
suele ser suficiente para averiguar si los dispositivos pueden conectarse aAWS IoT.

Si desea probar la conectividad con el puerto específico que utilizarán sus dispositivos, omita este
procedimiento y continúe conHaz que la aplicación pruebe la conexión al puerto y al punto final de datos
de tu dispositivo (p. 34).

Para probar rápidamente el extremo de datos del dispositivo

1. En una ventana de terminal o línea de comandos del dispositivo, sustituya el extremo de datos del
dispositivo de ejemplo (a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com) con el terminal
de datos del dispositivo de su cuenta y, a continuación, introduzca este comando.

Linux

ping -c 5 a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com

Windows

ping -n 5 a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com

2. Sipingmuestra un resultado similar al siguiente, si se ha conectado correctamente al extremo de

datos del dispositivo. Si bien no se comunicaba conAWS IoTdirectamente, encontró el servidor y es
probable queAWS IoTestá disponible a través de este punto de conexión.

PING a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com (xx.xx.xxx.xxx) 56(84) bytes of

data.
64 bytes from ec2-EXAMPLE-218.eu-west-1.compute.amazonaws.com (xx.xx.xxx.xxx):
icmp_seq=1 ttl=231 time=127 ms
64 bytes from ec2-EXAMPLE-218.eu-west-1.compute.amazonaws.com (xx.xx.xxx.xxx):
icmp_seq=2 ttl=231 time=127 ms
64 bytes from ec2-EXAMPLE-218.eu-west-1.compute.amazonaws.com (xx.xx.xxx.xxx):
icmp_seq=3 ttl=231 time=127 ms
64 bytes from ec2-EXAMPLE-218.eu-west-1.compute.amazonaws.com (xx.xx.xxx.xxx):
icmp_seq=4 ttl=231 time=127 ms
64 bytes from ec2-EXAMPLE-218.eu-west-1.compute.amazonaws.com (xx.xx.xxx.xxx):
icmp_seq=5 ttl=231 time=127 ms

Si está satisfecho con este resultado, puede detener la prueba aquí.

Si desea probar la conectividad con el puerto específico utilizado porAWS IoT, continúe conHaz que la
aplicación pruebe la conexión al puerto y al punto final de datos de tu dispositivo (p. 34).
3. Sipingno devolvió un resultado correcto, compruebe el valor del punto final para asegurarse de que
tiene el punto final correcto y compruebe la conexión del dispositivo a Internet.

Haz que la aplicación pruebe la conexión al puerto y al punto final

de datos de tu dispositivo
Se puede realizar una prueba de conectividad más exhaustiva utilizandonmap. Este procedimiento evalúa
para ver sinmapestá instalado en su dispositivo.

34
 AWS IoT Core Guía para desarrolladores
Probar la conectividad con el
terminal de datos de su dispositivo

Para comprobarnmapen el dispositivo

1. En una ventana de terminal o línea de comandos del dispositivo que desea probar, introduzca este
comando para comprobar sinmapestá instalado.

nmap --version

2. Si ve un resultado similar al siguiente,nmapestá instalado y puede continuarthe section called “Pruebe

la conexión al puerto y punto final de datos del dispositivo” (p. 37).

Nmap version 6.40 ( http://nmap.org )

Platform: x86_64-koji-linux-gnu
Compiled with: nmap-liblua-5.2.2 openssl-1.0.2k libpcre-8.32 libpcap-1.5.3 nmap-
libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select

3. Si no ve una respuesta similar a la que se muestra en el paso anterior, debe instalarnmapen el

dispositivo. Elija el procedimiento para el sistema operativo del dispositivo.

Linux

Este procedimiento requiere que tenga permiso para instalar el software en el equipo.

Para instalar nmap en su equipo Linux

1. En una ventana de terminal o línea de comandos del dispositivo, introduce el comando que
corresponda a la versión de Linux que esté ejecutando.

a. Debian o Ubuntu:

sudo apt install nmap

b. CentOS o RHEL:

sudo yum install nmap

2. Pruebe la instalación con este comando:

nmap --version

3. Si ve un resultado similar al siguiente,nmapestá instalado y puede continuarthe section called

“Pruebe la conexión al puerto y punto final de datos del dispositivo” (p. 37).

Nmap version 6.40 ( http://nmap.org )

Platform: x86_64-koji-linux-gnu
Compiled with: nmap-liblua-5.2.2 openssl-1.0.2k libpcre-8.32 libpcap-1.5.3 nmap-
libdnet-1.12 ipv6
Compiled without:
Available nsock engines: epoll poll select

macOS

Este procedimiento requiere que tenga permiso para instalar el software en el equipo.

Para instalar nmap en tu ordenador macOS

1. En un navegador, abrehttps://nmap.org/download#macosxy descarga elúltimo estableinstalador.

35
 AWS IoT Core Guía para desarrolladores
Probar la conectividad con el
terminal de datos de su dispositivo

Cuando se le solicite, seleccioneAbrir conDiskImageInstaller.

2. En la ventana de instalación, mueva el paquete aAplicacionescarpeta.
3. En elBuscador, localice elnmap-xxxx-mpkgpaquete en elAplicacionescarpeta.Ctrl-clickpulse en
el paquete y seleccioneAbrirpara abrir el paquete.
4. Revise el cuadro de diálogo de seguridad. Si está listo para instalarnmap, eligeAbririnstalarnmap.
5. EnTerminal, pruebe la instalación con este comando.

nmap --version

6. Si ve un resultado similar al siguiente,nmapestá instalado y puede continuarthe section called

“Pruebe la conexión al puerto y punto final de datos del dispositivo” (p. 37).

Nmap version 7.92 ( https://nmap.org )

Platform: x86_64-apple-darwin17.7.0
Compiled with: nmap-liblua-5.3.5 openssl-1.1.1k nmap-libssh2-1.9.0 libz-1.2.11
nmap-libpcre-7.6 nmap-libpcap-1.9.1 nmap-libdnet-1.12 ipv6 Compiled without:
Available nsock engines: kqueue poll select

Windows

Este procedimiento requiere que tenga permiso para instalar el software en el equipo.

Para instalar nmap en un equipo con Windows

1. En un navegador, abrehttps://nmap.org/download#windowsy descarga elúltimo

establelanzamiento del programa de configuración.

Si se le solicita, elijaGuardar archivo. Después de descargar el archivo, ábrelo desde la carpeta

de descargas.
2. Cuando el archivo de instalación termine de descargarse, abra descargadonmap-xxxx-
setup.exepara instalar la aplicación.
3. Acepte la configuración predeterminada a medida que se instala el programa.

No necesitas la aplicación Npcap para esta prueba. Puedes deseleccionar esa opción si no
quieres instalarla.
4. EnCommand, pruebe la instalación con este comando.

nmap --version

5. Si ve un resultado similar al siguiente,nmapestá instalado y puede continuarthe section called

“Pruebe la conexión al puerto y punto final de datos del dispositivo” (p. 37).

Nmap version 7.92 ( https://nmap.org )

Platform: i686-pc-windows-windows
Compiled with: nmap-liblua-5.3.5 openssl-1.1.1k nmap-libssh2-1.9.0 nmap-libz-1.2.11
nmap-libpcre-7.6 Npcap-1.50 nmap-libdnet-1.12 ipv6
Compiled without:
Available nsock engines: iocp poll select

36
 AWS IoT Core Guía para desarrolladores
ExploreAWS IoT Coreservicios en un tutorial práctico

Pruebe la conexión al puerto y punto final de datos del dispositivo

Para probar el puerto y el extremo de datos del dispositivo

1. En una ventana de terminal o línea de comandos del dispositivo, sustituya el extremo de datos del
dispositivo de ejemplo (a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com) con el terminal
de datos del dispositivo de su cuenta y, a continuación, introduzca este comando.

nmap -p 8443 a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com

2. Sinmapmuestra un resultado similar al siguiente,nmappudo conectarse correctamente al extremo de

datos del dispositivo en el puerto seleccionado.

Starting Nmap 7.92 ( https://nmap.org ) at 2022-02-18 16:23 Pacific Standard Time

Nmap scan report for a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com (xx.xxx.147.160)
Host is up (0.036s latency).
Other addresses for a3qEXAMPLEsffp-ats.iot.eu-west-1.amazonaws.com (not scanned):
xx.xxx.134.144 xx.xxx.55.139 xx.xxx.110.235 xx.xxx.174.233 xx.xxx.74.65 xx.xxx.122.179
xx.xxx.127.126
rDNS record for xx.xxx.147.160: ec2-EXAMPLE-160.eu-west-1.compute.amazonaws.com

PORT STATE SERVICE

8443/tcp open https-alt
MAC Address: 00:11:22:33:44:55 (Cimsys)

Nmap done: 1 IP address (1 host up) scanned in 0.91 seconds

3. Sinmapno arrojó un resultado correcto, compruebe el valor del punto de conexión para asegurarse de
que tiene el punto de conexión correcto y compruebe la conexión del dispositivo a Internet.

Puede probar otros puertos del terminal de datos del dispositivo, como el puerto 443, el puerto HTTPS
principal, sustituyendo el puerto utilizado en el paso 1,8443, con el puerto que desea probar.

ExploreAWS IoT Coreservicios en un tutorial

práctico
En este tutorial, instalará el software y creará elAWS IoTrecursos necesarios para conectar un dispositivo
aAWS IoT Corepara que pueda enviar y recibir mensajes MQTT conAWS IoT Core. Verás los mensajes
del cliente MQTT en elAWS IoTconsola.

Puede esperar dedicar entre 20 y 30 minutos a este tutorial. Si utilizas un dispositivo IoT o una Raspberry
Pi, este tutorial puede tardar más si, por ejemplo, necesitas instalar el sistema operativo y configurar el
dispositivo.

37
 AWS IoT Core Guía para desarrolladores
¿Qué opción de dispositivo es la mejor para ti?

Este tutorial es ideal para los desarrolladores que quieren empezar conAWS IoT Corepara que puedan
seguir explorando funciones más avanzadas, comomotor de reglasysombras. Este tutorial lo prepara para
seguir aprendiendo sobreAWS IoT Corey cómo interactúa con otrosAWSservicios explicando los pasos
con mayor detalle queel tutorial de inicio rápido (p. 23). Si estás buscando algo rápido,Hola mundo,
experimenta, prueba elPruebe elAWS IoTconexión rápida (p. 23).

Después de configurar suCuenta de AWSyAWS IoTconsola, seguirás estos pasos para ver cómo conectar
un dispositivo y hacer que envíe mensajes aAWS IoT Core.

Pasos siguientes

• Elige qué opción de dispositivo es la mejor para ti (p. 38)

• the section called “CrearAWS IoTrecursos” (p. 39)si no va a crear un dispositivo virtual con Amazon
EC2
• the section called “Configuración del dispositivo” (p. 42)
• the section called “Ver los mensajes MQTT con el cliente MQTT de AWS IoT” (p. 69)

Para obtener más información acerca de AWS IoT Core, consulte ¿Qué es AWS IoT Core? (p. 1).

¿Qué opción de dispositivo es la mejor para ti?

Si no estás seguro de qué opción elegir, usa la siguiente lista con las ventajas y desventajas de cada
opción para ayudarte a decidir cuál es la mejor para ti.

Opción Esta podría ser una buena Puede que esta no sea una
opción si: buena opción si:

the section called “Cree un • No tienes tu propio dispositivo • No te sientes cómodo usando
dispositivo virtual con Amazon para probar. los comandos de la línea de
EC2” (p. 42) • No querrás instalar ningún comandos.
software en tu propio sistema. • No querrás incurrir en ningún
• Desea realizar una prueba en gasto adicionalAWScargos.
un sistema operativo Linux. • No querrás realizar pruebas en
un sistema operativo Linux.

the section called “Utilice • No querrás incurrir en ningún • No querrás instalar ningún
su PC o Mac con Windows gasto adicionalAWScargos. software en tu ordenador
personal.

38
 AWS IoT Core Guía para desarrolladores
CrearAWS IoTrecursos

Opción Esta podría ser una buena Puede que esta no sea una
opción si: buena opción si:
o Linux comoAWS • No desea configurar ningún • Quieres una plataforma de
IoTdispositivo” (p. 50) dispositivo adicional. pruebas más representativa.

the section called “Conecta • Quieres probarAWS IoTcon un • No querrás comprar o

una Raspberry Pi u otro dispositivo real. configurar un dispositivo solo
dispositivo” (p. 60) • Ya tienes un dispositivo con el para probarlo.
que realizar la prueba. • Quieres probarAWS IoTde la
• Tiene experiencia en la forma más sencilla posible, por
integración de hardware en ahora.
sistemas.

CrearAWS IoTrecursos
En este tutorial, crearás elAWS IoTrecursos a los que un dispositivo necesita conectarseAWS IoT Coree
intercambiar mensajes.

1. Crea unAWS IoTdocumento de política, que autorizará al dispositivo a interactuar conAWS IoTservicios.
2. Crea un objeto objeto enAWS IoTy su certificado de dispositivo X.509 y, a continuación, adjunte
el documento de política. La cosa objeto es la representación virtual de su dispositivo en elAWS
IoTregistro. El certificado autentica el dispositivo paraAWS IoT Core, y el documento de política autoriza
al dispositivo a interactuar conAWS IoT.
Note

Si está planeandothe section called “Cree un dispositivo virtual con Amazon

EC2” (p. 42), puede saltarse esta página y continuarthe section called “Configuración del
dispositivo” (p. 42). Crearás estos recursos cuando crees tu cosa virtual.

39
 AWS IoT Core Guía para desarrolladores
CrearAWS IoTrecursos

En este tutorial se utiliza elAWS IoTconsola para crear elAWS IoTrecursos. Si su dispositivo admite un
navegador web, puede ser más fácil ejecutar este procedimiento en el navegador web del dispositivo,
ya que podrá descargar los archivos de certificado directamente en su dispositivo. Si ejecuta este
procedimiento en otro equipo, tendrá que copiar los archivos de certificado a su dispositivo para que la
aplicación de ejemplo pueda utilizarlos.

Creación de una política de AWS IoT

Los dispositivos utilizan un certificado X.509 para autenticarse conAWS IoT Core. El certificado tieneAWS
IoTpolíticas adjuntas. Estas políticas determinan cuálesAWS IoToperaciones, como suscribirse o publicar
temas de MQTT, que el dispositivo puede realizar. El dispositivo presenta su certificado cuando se conecta
y envía mensajes aAWS IoT Core.

Siga los pasos para crear una política que permita a su dispositivo realizar laAWS IoToperaciones
necesarias para ejecutar el programa de ejemplo. Debe crear elAWS IoTpolítica antes de poder adjuntarla
al certificado del dispositivo, que crearás más adelante.

Para crear una política de AWS IoT

1. En elAWS IoTconsola, en el menú de la izquierda, seleccionaSeguridady luego eligePolíticas.

2. En elAún no tienes una políticapágina, eligeCrear política.

Si tu cuenta tiene políticas existentes, eligeCrear política.

3. En elCrear políticapágina:

1. En elPropiedades de la políticasección, en laNombre de la políticacampo, introduzca un nombre

para la política (por ejemplo,My_Iot_Policy). No utilices información de identificación personal en
los nombres de tus pólizas.
2. En elDocumento de políticasección, cree las declaraciones de política que otorgan o deniegan
el acceso a los recursos aAWS IoT Coreoperaciones. Para crear una declaración de política que
permita a todos los clientes cumpliriot:Connect, sigue estos pasos:
• En elEfecto de la políticacampo, eligePermitir. Esto permite a todos los clientes que tengan esta
política adjunta a su certificado realizar la acción que se indica en laAcción políticacampo.
• En elAcción políticacampo, elija una acción política comoiot:Connect. Las acciones de política
son las acciones que el dispositivo necesita permiso para realizar cuando ejecuta el programa de
ejemplo desde el SDK de dispositivos.
• En elRecurso de políticascampo, introduzca el nombre del recurso Amazon Resource Name
(ARN) o*. UN*para seleccionar cualquier cliente (dispositivo).

Para crear las declaraciones de política paraiot:Receive,iot:Publish, yiot:Subscribe,

eligeAgregar nueva declaracióny repite los pasos.

Note
En este inicio rápido, se utiliza el carácter comodín (*) por motivos de simplicidad. Para
mayor seguridad, debe restringir los clientes (dispositivos) que pueden conectarse
y publicar mensajes especificando un ARN de cliente en lugar del carácter comodín
como recurso. Los ARN de los clientes siguen este formato:arn:aws:iot:your-
region:your-aws-account:client/my-client-id.

40
 AWS IoT Core Guía para desarrolladores
CrearAWS IoTrecursos

Sin embargo, primero debe crear el recurso (como un dispositivo cliente o una sombra
de objetos) antes de poder asignar su ARN a una política. Para obtener más información,
consulteAWS IoT Corerecursos de acción.
4. Después de introducir la información de tu póliza, eligeCrear.

Para obtener más información, consulte Cómo AWS IoT funciona con IAM (p. 411).

Crea una cosa (objeto)

Dispositivos conectados aAWS IoT Coreestán representados porobjetos de cosasen elAWS IoTregistro.
UNobjeto objetorepresenta un dispositivo o una entidad lógica específicos. Puede ser un dispositivo físico
o un sensor (por ejemplo, una bombilla o un interruptor de luz en la pared). También puede ser una entidad
lógica, como una instancia de una aplicación o una entidad física que no se conecta aAWS IoT, pero está
relacionado con otros dispositivos que sí los tienen (por ejemplo, un automóvil que tenga sensores de
motor o un panel de control).

Para crear una cosa en elAWS IoTconsola

1. En elAWS IoTconsola, en el menú de la izquierda, seleccionaTodos los dispositivosy luego

eligeCosas.
2. En elCosaspágina, eligeCrea cosas.
3. En elCrea cosaspágina, eligeCrea una sola cosa, luego eligeSiguiente.
4. En elEspecifica las propiedades de las cosaspágina, paraNombre de la cosa, introduce un nombre
para tu cosa, comoMyIotThing.

Elige los nombres de las cosas con cuidado, porque no podrás cambiarlas más adelante.

Para cambiar el nombre de un objeto, debe crear otro objeto nueva, asignarle el nuevo nombre y
eliminar después el objeto anterior.
Note

No utilices información de identificación personal en el nombre de tu objeto. El nombre de la

cosa puede aparecer en comunicaciones e informes no cifrados.
5. Mantenga vacíos el resto de los campos de esta página. Elija Siguiente.
6. En elConfigurar el certificado del dispositivo -opcionalpágina, eligeGenerar automáticamente un nuevo
certificado (recomendado). Elija Siguiente.
7. En elAdjunte políticas al certificado -opcionalpágina, seleccione la política que creó en la sección
anterior. En esa sección, la política se denominó,My_Iot_Policy. EligeCrear cosa.
8. En elDescargar certificados y clavespágina:

1. Descargue cada uno de los archivos de certificado y clave y guárdelos para más adelante. Deberás
instalar estos archivos en tu dispositivo.

Cuando guarde los archivos de certificados, asígneles los nombres de la tabla siguiente. Estos son
los nombres de archivo que se utilizan en los ejemplos posteriores.

Nombres de archivo de certificado

Archivos Ruta de archivo

Clave privada private.pem.key

Clave pública (no se utiliza en estos ejemplos)

Certificado de dispositivo device.pem.crt

41
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Archivos Ruta de archivo

Certificado de entidad de certificación raíz Amazon-root-CA-1.pem

2. Para descargar el archivo CA raíz de estos archivos, elijaDescargaenlace al archivo de certificado

de CA raíz que corresponde al tipo de extremo de datos y al conjunto de cifrado que utiliza. En
este tutorial, elijaDescargaa la derecha deClave de 2048 bits RSA: Amazon Root CA 1y descarga
elClave de 2048 bits RSA: Amazon Root CA 1archivo de certificado.
Important

Debe guardar los archivos de certificados antes de salir de esta página. Al salir de esta
página en la consola, ya no tendrá acceso a los archivos de certificados.
Si olvidó descargar los archivos de certificado que creó en este paso, debe salir de la
pantalla de la consola, ir a la lista de elementos de la consola, eliminar el objeto de cosa
que creó y, a continuación, reiniciar este procedimiento desde el principio.
3. Seleccione Done (Listo).

Después de completar este procedimiento, debería ver el nuevo objeto objeto en la lista de cosas.

Configuración del dispositivo

En esta sección se describe cómo configurar el dispositivo para conectarse aAWS IoT Core. Si quieres
empezar conAWS IoT Corepero aún no tiene un dispositivo, puede crear un dispositivo virtual mediante
Amazon EC2 o puede utilizar su PC o Mac con Windows como dispositivo de IoT.

Selecciona la mejor opción de dispositivo para probarlaAWS IoT Core. Por supuesto, puedes probarlas
todas, pero solo una a la vez. Si no estás seguro de qué opción de dispositivo es la mejor para ti, consulta
cómo elegirqué opción de dispositivo es la mejor (p. 38)y, a continuación, vuelve a esta página.

Opciones de dispositivo

• Cree un dispositivo virtual con Amazon EC2 (p. 42)

• Utilice su PC o Mac con Windows o Linux comoAWS IoTdispositivo (p. 50)
• Conecta una Raspberry Pi u otro dispositivo (p. 60)

Cree un dispositivo virtual con Amazon EC2

En este tutorial, crearás una instancia de Amazon EC2 para que sirva como dispositivo virtual en la nube.

Para completar este tutorial, necesitas unCuenta de AWS. Si no tiene uno, complete los pasos que se
describen enConfigura tuCuenta de AWS (p. 19)antes de continuar.

En este tutorial, podrás:

• Configurar una instancia de Amazon EC2 (p. 43)
• Instale Git, Node.js y configure elAWS CLI (p. 44)
• CrearAWS IoTrecursos para su dispositivo virtual (p. 45)
• Instale elAWS IoTSDK de dispositivos paraJavaScript (p. 48)
• Ejecute la aplicación de muestra (p. 49)
• Vea los mensajes de la aplicación de ejemplo enAWS IoTconsola (p. 50)

42
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Configurar una instancia de Amazon EC2

Los siguientes pasos 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 encontrar las instrucciones
enComience a utilizar las instancias de Amazon EC2Linuxpara ser más útil.

Para lanzar una instancia

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.

2. En el menú de la consola de la izquierda, expandeInstanciassección y eligeInstancias. Desde
elInstanciaspanel de control, elijaLanzar instanciasa la derecha para mostrar una lista de las
configuraciones básicas.
3. En elNombre y etiquetassección, introduzca un nombre para la instancia y, si lo desea, añada
etiquetas.
4. En elImágenes de aplicaciones y sistemas operativos (Amazon Machine Image)sección, elija una
plantilla de AMI para su instancia, comoAMI (HVM) de Amazon Linux 2. Observe que estas AMI están
marcadas como "Free tier eligible" (Apta para el nivel gratuito).
5. En elTipo de instanciaen la sección, 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.
6. En elPar de claves (inicio de sesión)sección, elija un nombre de par de claves de la lista desplegable o
elijaCrear un nuevo par de clavespara crear uno nuevo. Al crear un nuevo par de claves, asegúrate de
descargar el archivo de clave privada y guardarlo en un lugar seguro, ya que es tu única oportunidad
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.
Warning

No elija elContinuar sin un par de clavesopción. Si lanza la instancia sin un par de claves, no
podrá conectarse a ella.
7. En elAjustes de redsección y elConfigurar el almacenamientosección, puede mantener la
configuración predeterminada. Cuando esté listo, elijaLanzar instancias.
8. 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.
9. Puede ver el estado del lanzamiento en la pantalla Instances (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 de DNS público. (Si la columna Public
DNS (IPv4) (DNS público (IPv4)) está oculta, elija Show/Hide Columns (Mostrar/ocultar columnas)
(el icono con forma de engranaje) en la esquina superior derecha de la página y, a continuación,
seleccione Public DNS (IPv4) (DNS público (IPv4))).
10. 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.

Una vez que 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

Para conectarse a una instancia mediante el cliente basado en el navegador, seleccione la instancia en la
consola de Amazon EC2 y elija conectarse mediante Amazon EC2 Instance Connect. Instance Connect
gestiona los permisos y proporciona una conexión exitosa.

43
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

1. Abra la consola de Amazon EC2 en https://console.aws.amazon.com/ec2/.

2. En el menú de la izquierda, seleccionaInstancias.
3. Seleccione la instancia y elija Connect (Conectar).
4. EscojaConexión de instancias de Amazon EC2,Conectar.

Ahora deberías tener unConexión de instancias de Amazon EC2ventana que está registrada en su nueva
instancia de Amazon EC2.

Instale Git, Node.js y configure elAWS CLI

En esta sección, instalarás Git y Node.js en tu instancia de Linux.

Para instalar Git

1. En tuConexión de instancias de Amazon EC2ventana, actualiza tu instancia mediante el siguiente

comando.

sudo yum update -y

2. En tuConexión de instancias de Amazon EC2ventana, instala Git mediante el siguiente comando.

sudo yum install git -y

3. Para comprobar si se ha instalado Git y la versión actual de Git, ejecuta el siguiente comando:

git --version

Para instalar Node.js

1. En tuConexión de instancias de Amazon EC2ventana, 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.
2. En tuConexión de instancias de Amazon EC2ventana, active nvm con este comando.

. ~/.nvm/nvm.sh

3. En tuConexión de instancias de Amazon EC2ventana, utilice nvm para instalar la versión más reciente
de Node.js mediante este comando.

nvm install 16

Note

De este modo, se instala la versión 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.
4. En tuConexión de instancias de Amazon EC2ventana, compruebe que Node.js esté instalado y
funcionando correctamente mediante este comando.

44
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

node -e "console.log('Running Node.js ' + process.version)"

Este tutorial requiere Node v10.0 o posterior. Para obtener más información, consulteTutorial:
Configuración de Node.js en una instancia de Amazon EC2.

Para configurar AWS CLI

Su instancia de Amazon EC2 viene precargada conAWS CLI. Sin embargo, debe completar suAWS
CLIperfil. Para obtener más información sobre cómo configurar la CLI, consulteConfiguración delAWS CLI.

1. En el ejemplo siguiente se muestran los valores de ejemplo. Sustitúyalos por tus propios valores.
Puede encontrar estos valores en suAWSconsola en la información de tu cuenta, enCredenciales de
seguridad.

En tuConexión de instancias de Amazon EC2ventana, introduzca este comando:

aws configure

A continuación, introduzca los valores de su cuenta siguiendo las instrucciones que aparecen.

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

2. Puedes probar tuAWS CLIconfiguración con este comando:

aws iot describe-endpoint --endpoint-type iot:Data-ATS

Si tuAWS CLIestá configurado correctamente, el comando debe devolver una dirección de punto final
de suCuenta de AWS.

CrearAWS IoTrecursos para su dispositivo virtual

En esta sección se describe cómo utilizar elAWS CLIpara crear el objeto objeto y sus archivos de
certificado directamente en el dispositivo virtual. Esto se hace directamente en el dispositivo para evitar la
posible complicación que podría surgir al copiarlos al dispositivo desde otro ordenador. En esta sección,
creará los siguientes recursos para su dispositivo virtual:

• Una cosa (objeto) para representar tu dispositivo virtualAWS IoT.

• Un certificado para autenticar el dispositivo virtual.
• Un documento de política para autorizar la conexión del dispositivo virtual aAWS IoT, y para publicar,
recibir y suscribirse a mensajes.

Para crear unAWS IoTobjeto de cosa en tu instancia de Linux

Dispositivos conectados aAWS IoTestán representados porobjetos de cosasen elAWS IoTregistro.

UNobjeto objetorepresenta un dispositivo o una entidad lógica específicos. En este caso, suobjeto
objetorepresentará su dispositivo virtual, esta instancia de Amazon EC2.

1. En tuConexión de instancias de Amazon EC2ventana, ejecuta el siguiente comando para crear tu

objeto de cosa.

45
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

aws iot create-thing --thing-name "MyIotThing"

2. La respuesta JSON debería tener este aspecto:

{
"thingArn": "arn:aws:iot:your-region:your-aws-account:thing/MyIotThing",
"thingName": "MyIotThing",
"thingId": "6cf922a8-d8ea-4136-f3401EXAMPLE"
}

Para crear y adjuntarAWS IoTclaves y certificados en tu instancia de Linux

Elcreate-keys-and-certificateel comando crea certificados de cliente firmados por la autoridad de

certificación Amazon Root. Este certificado se usa para autenticar la identidad del dispositivo virtual.

1. En tuConexión de instancias de Amazon EC2ventana, cree un directorio para almacenar los archivos
de certificados y claves.

mkdir ~/certs

2. En tuConexión de instancias de Amazon EC2ventana, descargue una copia del certificado de la

autoridad certificadora (CA) de Amazon mediante este comando.

curl -o ~/certs/Amazon-root-CA-1.pem \
https://www.amazontrust.com/repository/AmazonRootCA1.pem

3. En tuConexión de instancias de Amazon EC2ventana, ejecute el siguiente comando para crear sus
archivos de clave privada, clave pública y certificado X.509. Este comando también registra y activa el
certificado conAWS 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 elcertificateArnpara que pueda usarlo en comandos
posteriores. Lo necesitarás para adjuntar tu certificado a lo tuyo y para adjuntar la política al certificado
en pasos posteriores.

{
"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

46
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

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"
}
}

4. En tuConexión de instancias de Amazon EC2ventana, adjunte su objeto thing al certificado que

acaba de crear mediante el siguiente comando y elCertificado Earnen la respuesta del comando
anterior.

aws iot attach-thing-principal \

--thing-name "MyIotThing" \
--principal "certificateArn"

Si se ejecuta correctamente, este comando no mostrará ningún resultado.

Para crear y adjuntar una política

1. En tuConexión de instancias de Amazon EC2ventana, cree el archivo de política copiando y pegando

este documento de política en un archivo denominado~/policy.json.

Si no tiene un editor de Linux favorito, puede abrirnano, mediante este comando.

nano ~/policy.json

Pegue el documento de política parapolicy.jsonen él. Introduzca ctrl-x para salir denanoeditor y
guarde el archivo.

Contenido del documento de política parapolicy.json.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect"
],
"Resource": [
"*"
]
}
]
}

47
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

2. En tuConexión de instancias de Amazon EC2ventana, cree su política mediante el siguiente comando.

aws iot create-policy \

--policy-name "MyIotThingPolicy" \
--policy-document "file://~/policy.json"

Salida:

{
"policyName": "MyIotThingPolicy",
"policyArn": "arn:aws:iot:your-region: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"
}

3. En tuConexión de instancias de Amazon EC2ventana, adjunte la política al certificado del dispositivo

virtual mediante el siguiente comando.

aws iot attach-policy \

--policy-name "MyIotThingPolicy" \
--target "certificateArn"

Si se ejecuta correctamente, este comando no mostrará ningún resultado.

Instale elAWS IoTSDK de dispositivos paraJavaScript

En esta sección, instalará elAWS IoTSDK de dispositivos paraJavaScript, que contiene el código que
las aplicaciones pueden usar para comunicarseAWS IoTy los programas de muestra. Para obtener más
información, consulteAWS IoTSDK de dispositivos paraJavaScript GitHubrepositorio.

Para instalar elAWS IoTSDK de dispositivos paraJavaScripten tu instancia de Linux

1. En tuConexión de instancias de Amazon EC2ventana, clona elAWS IoTSDK de dispositivos

paraJavaScriptrepositorio en elaws-iot-device-sdk-js-v2directorio de su directorio principal
mediante este comando.

cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git

2. Navega hasta elaws-iot-device-sdk-js-v2directorio que creó en el paso anterior.

cd aws-iot-device-sdk-js-v2

48
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

3. Usa npm para instalar el SDK.

npm install

Ejecute la aplicación de muestra

Los comandos de las siguientes secciones asumen que los archivos de claves y certificados están
almacenados en el dispositivo virtual, tal 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á elpub-sub.jsaplicación de muestra que se encuentra enaws-

iot-device-sdk-js-v2/samples/nodedirectorio delAWS IoTSDK de dispositivos paraJavaScript.
Esta aplicación muestra cómo un dispositivo, su instancia de Amazon EC2, utiliza la biblioteca MQTT para
publicar mensajes MQTT y suscribirse a ellos. Elpub-sub.jsuna aplicación de muestra se suscribe a
un tema,topic_1, publica 10 mensajes sobre ese tema y muestra los mensajes tal como se reciben del
intermediario de mensajes.

Para instalar y ejecutar la aplicación de muestra

1. En tuConexión de instancias de Amazon EC2ventana, navegue hasta laaws-iot-device-sdk-js-

v2/samples/node/pub_subdirectorio que creó el SDK e instala la aplicación de ejemplo mediante
estos comandos.

cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install

2. En tuConexión de instancias de Amazon EC2ventana, obtenersu punto final de IoTdeAWS

IoTmediante este comando.

aws iot describe-endpoint --endpoint-type iot:Data-ATS

3. En tuConexión de instancias de Amazon EC2ventana, insertarsu punto final de IoTcomo 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 muestra:

1. Se conecta aAWS IoT Corepara tu cuenta.

2. Se suscribe al tema del mensaje,tema_1, y muestra los mensajes que recibe sobre ese tema.
3. Publica 10 mensajes sobre el tema,tema_1.
4. Muestra un resultado similar al siguiente:

Publish received. topic:"topic_1" dup:false qos:1 retain:false

49
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

{"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 tienes problemas para ejecutar la aplicación de muestra, consultathe section called “Solución de
problemas con la aplicación de muestra” (p. 67).

También puede añadir el--verbosity debugparámetro de 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 enAWS IoTconsola

Puede ver los mensajes de la aplicación de ejemplo a medida que pasan por el agente de mensajes
mediante elcliente de prueba MQTTen elAWS IoTconsola.

Para ver los mensajes MQTT publicados por la aplicación de ejemplo

1. Consulte Ver los mensajes MQTT con el cliente MQTT de AWS IoT (p. 69). Esto le ayuda a
aprender a usar elcliente de prueba MQTTen elAWS IoTconsolapara ver los mensajes MQTT a
medida que pasan por el intermediario de mensajes.
2. Abra elcliente de prueba MQTTen elAWS IoTconsola.
3. EnSuscríbete a un tema, Suscríbete al tema,tema_1.
4. En tuConexión de instancias de Amazon EC2ventana, vuelva a ejecutar la aplicación de muestra y vea
los mensajes en elcliente de prueba MQTTen elAWS IoTconsola.

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ómoAWS IoT Coreadmite el protocolo, consulteMATT.

Utilice su PC o Mac con Windows o Linux comoAWS

IoTdispositivo
En este tutorial, configurará un ordenador personal para usarlo conAWS IoT. Estas instrucciones son
compatibles con ordenadores y Mac con Windows y Linux. Para lograr esto, debe instalar algún software
en su computadora. Si no quieres instalar ningún software en tu ordenador, puedes intentarloCree un
dispositivo virtual con Amazon EC2 (p. 42), que instala todo el software en una máquina virtual.

50
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

En este tutorial, podrás:

• Configura tu ordenador personal (p. 51)
• Instale Git, Python yAWS IoTSDK de dispositivos para Python (p. 51)
• Configure la política y ejecute la aplicación de ejemplo (p. 53)
• Vea los mensajes de la aplicación de ejemplo enAWS IoTconsola (p. 56)
• Ejecute el ejemplo de suscripción compartida en Python (p. 57)

Configura tu ordenador personal

Para completar este tutorial, necesitas un PC con Windows o Linux o un Mac con conexión a Internet.

Antes de continuar con el paso siguiente, asegúrese de poder abrir una ventana de línea de comandos en
su ordenador. Usacmd.exeen un PC con Windows. En un PC Linux o Mac, utiliceTerminal.

Instale Git, Python yAWS IoTSDK de dispositivos para Python

En esta sección, instalará Python yAWS IoTEl SDK de dispositivos para Python está en tu ordenador.

Instala la versión más reciente de Git y Python

Para descargar e instalar Git y Python en tu ordenador

1. Comprueba si tienes Git instalado en tu ordenador. 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, abrahttps://git-scm.com/downloade instala Git en tu ordenador.

2. Comprueba si ya has instalado Python. Introduzca el comando en la línea de comandos.

python -V

Note

Si este comando da un error:Python was not found, puede deberse a que su sistema
operativo llama al ejecutable Python v3.x comoPython3. En ese caso, sustituya todas las
instancias depythonconpython3y continúe con el resto de este tutorial.

Si el comando muestra la versión de Python, Python ya está instalado. Este tutorial requiere Python
v3.7 o posterior.
3. Si Python está instalado, puede omitir el resto de los pasos de esta sección. Si no, continúa.
4. Abrirhttps://www.python.org/downloads/y descarga el instalador para tu ordenador.
5. Si la descarga no se inicia automáticamente, ejecuta el programa descargado para instalar Python.
6. Compruebe la instalación de Python.

python -V

Confirme que el comando muestre la versión de Python. Si no aparece la versión de Python, intenta
descargar e instalar Python de nuevo.

51
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Instale elAWS IoTSDK de dispositivos para Python

Para instalar elAWS IoTSDK de dispositivos para Python en tu ordenador

1. Instale la versión 2 delAWS IoTSDK de dispositivos para Python.

python3 -m pip install awsiotsdk

2. Clona elAWS IoTEl SDK de dispositivos para el repositorio de Python en elaws-iot-device-sdkdirectorio

-python-v2 de tu directorio principal. Este procedimiento hace referencia al directorio base de los
archivos que está instalando comocasa.

La ubicación real delcasael directorio depende de su sistema operativo.

Linux/macOS

En macOS y Linux, elcasael directorio es~.

cd ~
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git

Windows

En Windows, puede encontrar elcasaruta del directorio mediante la ejecución de este comando
en elcmdventana.

echo %USERPROFILE%
cd %USERPROFILE%
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git

Note

Si usas WindowsPowerShellen contraposición acmd.exey, a continuación, utilice el siguiente

comando.

echo $home

Para obtener más información, consulteAWS IoTSDK de dispositivos para PythonGitHubrepositorio.

Preparación antes de ejecutar las aplicaciones de ejemplo

Para preparar el sistema para ejecutar la aplicación de ejemplo

• Crea elcertsdirectorio. En elcertsdirectorio, copie los archivos de clave privada, certificado de

dispositivo y certificado de CA raíz que guardó al crear y registrar el objeto thing enthe section called
“CrearAWS IoTrecursos” (p. 39). Los nombres de cada archivo del directorio de destino deben
coincidir con los de la tabla.

Los comandos de la siguiente sección asumen que los archivos de claves y certificados están
almacenados en el dispositivo, tal como se muestra en esta tabla.

Linux/macOS

Ejecute este comando para crearcertssubdirectorio que usará cuando ejecute las aplicaciones
de ejemplo.

52
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

mkdir ~/certs

En el nuevo subdirectorio, copie los archivos a las rutas de los archivos de destino que se
muestran en la tabla siguiente.

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

Ejecute este comando para enumerar los archivos delcertsdirectorio y compárelos con los que
figuran en la tabla.

ls -l ~/certs

Windows

Ejecute este comando para crearcertssubdirectorio que usará cuando ejecute las aplicaciones
de ejemplo.

mkdir %USERPROFILE%\certs

En el nuevo subdirectorio, copie los archivos a las rutas de los archivos de destino que se
muestran en la tabla siguiente.

Nombres de archivo de certificado

Archivos Ruta de archivo

Clave privada %USERPROFILE%\certs

\private.pem.key

Certificado de dispositivo %USERPROFILE%\certs\device.pem.crt

Certificado de entidad de certificación raíz %USERPROFILE%\certs\Amazon-root-

CA-1.pem

Ejecute este comando para enumerar los archivos delcertsdirectorio y compárelos con los que
figuran en la tabla.

dir %USERPROFILE%\certs

Configure la política y ejecute la aplicación de ejemplo

En esta sección, configurará su política y ejecutará elpubsub.pyejemplo de script que se encuentra
enaws-iot-device-sdk-python-v2/samplesdirectorio delAWS IoT Device SDK para Python. Este

53
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

script muestra cómo el dispositivo usa la biblioteca MQTT para publicar mensajes MQTT y suscribirse a
ellos.

Elpubsub.pyuna aplicación de muestra se suscribe a un tema,test/topic, publica 10 mensajes sobre

ese tema y muestra los mensajes tal como se reciben del intermediario de mensajes.

Para ejecutar elpubsub.pyejemplo de script, necesita la siguiente información:

Valores de los parámetros de la aplicación

Parámetro Dónde encontrar el valor

su punto final de IoT 1. En elAWS IoTconsola, en el menú de la

izquierda, seleccionaAjustes.
2. En elAjustespágina, su punto final se muestra
enPunto final de datos del dispositivosección.

Elsu punto final de IoTel valor tiene un formato de:endpoint_id-

ats.iot.region.amazonaws.com, por ejemplo,a3qj468EXAMPLE-ats.iot.us-
west-2.amazonaws.com.

Antes de ejecutar el script, asegúrate de que la política de tu aplicación proporcione permisos para que el
script de ejemplo se conecte, se suscriba, publique y reciba.

Para buscar y revisar el documento de política de un recurso

1. En elAWS IoTconsola, en elCosaslista, encuentra el recurso que representa tu dispositivo.

2. Elige elNombreenlace del recurso que representa a tu dispositivo para abrir elDetalles de la
cosapágina.
3. En elDetalles de la cosapágina, en elCertificadospestaña, elija el certificado que se adjunta al recurso
de la cosa. Solo debe haber un certificado en la lista. Si hay más de uno, elija el certificado cuyos
archivos estén instalados en su dispositivo y que se utilizará para conectarse aAWS IoT Core.

En elcertificadopágina de detalles, en laPolíticaspestaña, elija la política que se adjunta al certificado.

Solo debe haber uno. Si hay más de una, repita el siguiente paso para cada una de ellas para
asegurarse de que al menos una política otorga el acceso requerido.
4. En elPolíticapágina de descripción general, busque el editor JSON y elijaEditar documento de
políticapara revisar y editar el documento de política según sea necesario.
5. El JSON de la política se muestra en el siguiente ejemplo. En el"Resource"elemento,
reemplazarregion:accountcon tuRegión de AWSyCuenta de AWSen cada uno de
losResourcevalores.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:region:account:topic/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"

54
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

],
"Resource": [
"arn:aws:iot:region:account:topicfilter/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:region:account: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~/aws-iot-device-sdk-python-v2/

samples/node/pub_subdirectorio que el SDK creó mediante estos comandos.

cd ~/aws-iot-device-sdk-python-v2/samples

2. En la ventana de línea de comandos, reemplacesu punto final de IoTcomo 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 muestra en un PC con Windows

1. En la ventana de la línea de comandos, navegue hasta%USERPROFILE%\aws-iot-device-

sdk-python-v2\samplesdirectorio que creó el SDK e instala la aplicación de ejemplo mediante
estos comandos.

cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples

2. En la ventana de línea de comandos, reemplacesu punto final de IoTcomo 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 alAWS IoT Corepara tu cuenta.

2. Se suscribe al tema del mensaje,prueba/tema, y muestra los mensajes que recibe sobre ese tema.
3. Publica 10 mensajes sobre el tema,prueba/tema.
4. Muestra un resultado similar al siguiente:

55
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

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 tienes problemas para ejecutar la aplicación de muestra, consultathe section called “Solución de
problemas con la aplicación de muestra” (p. 67).

También puede añadir el--verbosity Debugparámetro de 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 ayudarle a
corregir el problema.

Vea los mensajes de la aplicación de ejemplo enAWS IoTconsola

Puede ver los mensajes de la aplicación de ejemplo a medida que pasan por el agente de mensajes
mediante elcliente de prueba MQTTen elAWS IoTconsola.

Para ver los mensajes MQTT publicados por la aplicación de ejemplo

1. Consulte Ver los mensajes MQTT con el cliente MQTT de AWS IoT (p. 69). Esto le ayuda a
aprender a usar elcliente de prueba MQTTen elAWS IoTconsolapara ver los mensajes MQTT a
medida que pasan por el intermediario de mensajes.
2. Abra elcliente de prueba MQTTen elAWS IoTconsola.
3. EnSuscríbete a un tema, suscríbete al tema,prueba/tema.
4. En la ventana de línea de comandos, vuelva a ejecutar la aplicación de ejemplo y observe los
mensajes delCliente MQTTen elAWS IoTconsola.

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

56
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

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ómoAWS IoT Coreadmite el protocolo, consulteMATT.

Ejecute el ejemplo de suscripción compartida en Python

AWS IoT CoresoportaSuscripciones compartidas (p. 101)tanto para MQTT 3 como para 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
utilizar las suscripciones compartidas, los clientes se suscriben a una suscripción compartidafiltro de
temas:$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, debes configurar la política de tu producto tal y
como se indica enSuscripción compartida a MQTT 5.
2. 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~/aws-iot-device-sdk-python-

v2/samplesdirectorio que el SDK creó mediante estos comandos.

cd ~/aws-iot-device-sdk-python-v2/samples

2. En la ventana de línea de comandos, reemplacesu punto final de IoTcomo 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 muestra en un PC con Windows

1. En la ventana de la línea de comandos, navegue hasta%USERPROFILE%\aws-iot-

device-sdk-python-v2\samplesdirectorio que creó el SDK e instala la aplicación de
ejemplo mediante estos comandos.

cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples

2. En la ventana de línea de comandos, reemplacesu punto final de IoTcomo 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

57
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Note

Si lo desea, puede especificar un identificador de grupo en función de sus necesidades

al ejecutar el ejemplo (p. ej.,--group_identifier consumer). Si no especificas
ninguno,python-samplees el identificador de grupo predeterminado.
3. El resultado de la línea de comandos puede tener el siguiente aspecto:

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: [<SubackReasonCode.GRANTED_QOS_1: 1>]
[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: [<SubackReasonCode.GRANTED_QOS_1: 1>]
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [1]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [2]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [3]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [4]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [5]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [6]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [7]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [8]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [9]"'
[Publisher]: Sent publish and got PubAck code: <PubackReasonCode.SUCCESS: 0>
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [10]"'

58
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

[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: [<UnsubackReasonCode.SUCCESS: 0>]
[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 [<UnsubackReasonCode.SUCCESS: 0>]
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!

4. Abrircliente de prueba MQTTen elAWS IoTconsola. EnSuscríbete a un tema, suscríbete al tema de la

suscripción compartida, como:$share/consumer/test/topic. Puede especificar un identificador
de grupo en función de sus necesidades al ejecutar el ejemplo (p. ej.,--group_identifier
consumer). Si no especificas un identificador de grupo, el valor predeterminado espython-sample.
Para obtener más información, consulteEjemplo de suscripción compartida en Python a MQTT
5ySuscripciones compartidas (p. 101)deAWS IoT CoreGuía para desarrolladores.

En la ventana de línea de comandos, vuelve a ejecutar la aplicación de muestra y observa la

distribución de los mensajes en tucliente de prueba MQTTde laAWS IoTconsolay la línea de
comandos.

59
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Conecta una Raspberry Pi u otro dispositivo

En esta sección, configuraremos una Raspberry Pi para usarla conAWS IoT. Si tienes otro dispositivo al
que te gustaría conectar, las instrucciones de la Raspberry Pi incluyen referencias que pueden ayudarte a
adaptar estas instrucciones a tu dispositivo.

Esto suele tardar unos 20 minutos, pero puede tardar más si tiene que instalar muchas actualizaciones del
software del sistema.

En este tutorial, podrás:

• Configura tu dispositivo (p. 60)
• Instale las herramientas y bibliotecas necesarias paraAWS IoTSDK de dispositivos (p. 61)
• InstalarAWS IoTSDK de dispositivos (p. 61)
• Instala y ejecuta la aplicación de muestra (p. 64)
• Vea los mensajes de la aplicación de ejemplo enAWS IoTconsola (p. 67)

Important

Adaptar estas instrucciones a otros dispositivos y sistemas operativos puede resultar difícil.
Deberás entender tu dispositivo lo suficientemente bien como para poder interpretar estas
instrucciones y aplicarlas al dispositivo.
Si tiene dificultades al configurar el dispositivo paraAWS IoT, puede probar una de las otras
opciones del dispositivo como alternativa, comoCree un dispositivo virtual con Amazon
EC2 (p. 42)oUtilice su PC o Mac con Windows o Linux comoAWS IoTdispositivo (p. 50).

Configura tu dispositivo
El objetivo de este paso es recopilar lo que necesitará para configurar el dispositivo de modo que pueda
iniciar el sistema operativo (SO), conectarse a Internet y permitirle interactuar con él en una interfaz de
línea de comandos.

Necesitará lo siguiente para completar este tutorial:

• Una Cuenta de AWS. Si no tiene uno, complete los pasos que se describen enConfigura tuCuenta de
AWS (p. 19)antes de continuar.
• UNRaspberry Pi 3 modelo Bo 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)o más adelante. Recomendamos utilizar la versión más reciente
del sistema operativo Raspberry Pi. Es posible que las versiones anteriores del sistema operativo
funcionen, 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 la Raspberry Pi y su hardware de Raspberry Pi la admite,
podría resultarle más fácil utilizar el escritorio con la GUI.
• Ethernet oWiFiconexión.
• Teclado, ratón, monitor, cables, fuentes de alimentación y demás hardware que necesite el dispositivo.

Important

Antes de continuar con el paso siguiente, el dispositivo debe tener el sistema operativo instalado,
configurado y en ejecución. El dispositivo debe estar conectado a Internet y tendrás que
poder acceder al dispositivo mediante su interfaz de línea de comandos. El acceso a la línea
de comandos puede realizarse a través de un teclado, un ratón y un monitor conectados
directamente, o mediante una interfaz remota de terminal SSH.

60
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Si ejecuta un sistema operativo en su Raspberry Pi que tiene una interfaz gráfica de usuario (GUI),
abra una ventana de terminal en el dispositivo y siga las siguientes instrucciones en esa ventana. De
lo contrario, si te conectas a tu dispositivo mediante un terminal remoto, como PuTTY, abre un terminal
remoto en tu dispositivo y úsalo.

Instale las herramientas y bibliotecas necesarias paraAWS IoTSDK de

dispositivos
Antes de instalar elAWS IoTSDK del dispositivo y código de muestra: asegúrate de que el sistema esté
actualizado y que cuente con las herramientas y bibliotecas necesarias para instalar los SDK.

1. Actualice el sistema operativo e instale las bibliotecas necesarias

Antes de instalar unAWS IoTSDK del dispositivo: ejecute 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

2. Instalar Git

Si el sistema operativo de tu dispositivo no viene con Git instalado, debes instalarlo para instalar
elAWS IoTSDK de dispositivos paraJavaScript.

a. Ejecuta este comando para comprobar si Git ya está instalado.

git --version

b. Si el comando anterior devuelve la versión de Git, significa que Git ya está instalado y puedes
saltar al paso 3.
c. Si aparece un error al ejecutar elgitcomando, instala Git ejecutando este comando.

sudo apt-get install git

d. Ejecuta este comando para comprobar si Git está instalado.

git --version

e. Si Git está instalado, continúa con la siguiente sección. De lo contrario, solucione y corrija el error
antes de continuar. Necesitas Git para instalar elAWS IoTSDK de dispositivos paraJavaScript.

InstalarAWS IoTSDK de dispositivos

Instale elAWS IoTSDK de dispositivos.

Python

En esta sección, instalará Python, sus herramientas de desarrollo yAWS IoTEl SDK de dispositivos
para Python está en tu dispositivo. Estas instrucciones son para una Raspberry Pi que ejecute el

61
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

último sistema operativo Raspberry Pi. Si tienes otro dispositivo o utilizas otro sistema operativo, es
posible que tengas que adaptar estas instrucciones para tu dispositivo.

1. Instalar Python y sus herramientas de desarrollo

ElAWS IoTEl SDK de dispositivos para Python requiere que Python v3.5 o posterior esté instalado
en tu Raspberry Pi.

En una ventana de 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.

2. Si la versión que se muestra esPython 3.5o superior, puede saltar al paso 2.
3. Si la versión que se muestra es inferior aPython 3.5, puede instalar la versión correcta
ejecutando este comando.

sudo apt install python3

4. Ejecute este comando para confirmar que ya está instalada la versión correcta de Python.

python3 --version

2. Prueba de pip3

En una ventana de terminal de su dispositivo, ejecute estos comandos.

1. Ejecute este comando para ver sipip3está instalado.

pip3 --version

2. Si el comando devuelve un número de versión,pip3está instalado y puede saltar al paso 3.

3. Si el comando anterior devuelve un error, ejecute este comando para instalarpip3.

sudo apt install python3-pip

4. Ejecute este comando para ver sipip3está instalado.

pip3 --version

3. Instale el actualAWS IoTSDK de dispositivos para Python

Instale elAWS IoTDevice SDK para Python y descarga las aplicaciones de muestra en tu
dispositivo.

En el dispositivo, ejecuta estos comandos.

cd ~
python3 -m pip install awsiotsdk

git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git

62
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

JavaScript

En esta sección, instalará Node.js, el administrador de paquetes npm yAWS IoTSDK de dispositivos
paraJavaScripten tu dispositivo. Estas instrucciones son para una Raspberry Pi que ejecuta el sistema
operativo Raspberry Pi. Si tienes otro dispositivo o utilizas otro sistema operativo, es posible que
tengas que adaptar estas instrucciones para tu dispositivo.

1. Instale la versión más reciente de Node.js.

ElAWS IoTSDK de dispositivos paraJavaScriptrequiere que Node.js y el administrador de

paquetes npm estén instalados en su Raspberry Pi.

a. Descargue la versión más reciente del repositorio de Node ingresando este comando.

cd ~
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -

b. Instale Node y npm.

sudo apt-get install -y nodejs

c. Compruebe la instalación de Node.

node -v

Confirme que el comando muestre la versión de Node. Este tutorial requiere Node v10.0 o
posterior. Si no aparece la versión de Node, intenta descargar de nuevo el repositorio de
Node.
d. Verifique la instalación de npm.

npm -v

Confirme que el comando muestre la versión npm. Si no se muestra la versión de npm,

intenta instalar Node y npm nuevamente.
e. Reinicie el dispositivo.

sudo shutdown -r 0

Continúe después de que el dispositivo se haya reiniciado.

2. Instale elAWS IoTSDK de dispositivos paraJavaScript

Instale elAWS IoTSDK de dispositivos paraJavaScripten tu Raspberry Pi.

a. Clona elAWS IoTSDK de dispositivos paraJavaScriptrepositorio en elaws-iot-device-

sdk-js-v2directorio de sucasadirectorio. En la Raspberry Pi, elcasael directorio es~/,
que se utiliza comocasadirectorio en los siguientes comandos. Si el dispositivo usa una ruta
diferente paracasadirectorio, debe reemplazar~/con la ruta correcta para su dispositivo en
los siguientes comandos.

Estos comandos crean el~/aws-iot-device-sdk-js-v2directorio y copia el código del

SDK en él.

cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git

63
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

b. Cambiar a laaws-iot-device-sdk-js-v2directorio que creó en el paso anterior y

ejecutanpm installpara instalar el SDK. El comandonpm installinvocará elaws-
crtcompilación de la biblioteca que puede tardar unos minutos en completarse.

cd ~/aws-iot-device-sdk-js-v2
npm install

Instala y ejecuta la aplicación de muestra

En esta sección, instalará y ejecutará elpubsubaplicación de muestra que se encuentra enAWS IoTSDK
de dispositivos. Esta aplicación muestra cómo su dispositivo usa la biblioteca 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 se reciben del intermediario de mensajes.

Instale los archivos de certificados

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 muestra

1. Crea uncertssubdirectorio en tucasadirectorio mediante la ejecución de estos comandos.

cd ~
mkdir certs

2. En el~/certsdirectorio, copie la clave privada, el certificado de dispositivo y el certificado de CA raíz

que creó anteriormente enthe section called “CrearAWS IoTrecursos” (p. 39).

La forma de copiar los archivos de certificado al 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 enthe section called
“CrearAWS IoTrecursos” (p. 39)desde el navegador web de su dispositivo para descargar los
archivos resultantes directamente a su 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

Archivos Ruta de archivo

Certificado de entidad de certificación raíz ~/certs/Amazon-root-CA-1.pem

Certificado de dispositivo ~/certs/device.pem.crt

Clave privada ~/certs/private.pem.key

Para ejecutar la aplicación de muestra, necesita la siguiente información:

Valores de los parámetros de la aplicación

Parámetro Dónde encontrar el valor

su punto final de IoT En elAWS IoTconsola, eligeTodos los

dispositivosy, a continuación, elijaCosas.

64
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

Parámetro Dónde encontrar el valor

Elige el dispositivo de IoT que creaste para tu
dispositivo,MyIotThingera el nombre utilizado
anteriormente y, a continuación, elijaInteractuar.

En la página de detalles de la cosa, tu punto final

aparece enHTTPSsección.

Si usa el nuevoAWS IoTconsola,

eligeAjustesdesde elAWS IoTmenú. Su punto de
conexión se muestra enPunto final de datos del
dispositivosección.

Elsu punto final de IoTel valor tiene un formato de: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 muestra

1. Navega hasta el directorio de aplicaciones de ejemplo.

cd ~/aws-iot-device-sdk-python-v2/samples

2. En la ventana de línea de comandos, reemplacesu punto final de IoTcomo 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

3. Observe que la aplicación de ejemplo:

1. Se conecta alAWS IoTservicio para tu cuenta.

2. Se suscribe al tema del mensaje,tema_1, y muestra los mensajes que recibe sobre ese tema.
3. Publica 10 mensajes sobre el tema,tema_1.
4. Muestra un resultado similar al 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]

65
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

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 tienes problemas para ejecutar la aplicación de muestra, consultathe section called “Solución
de problemas con la aplicación de muestra” (p. 67).

También puede añadir el--verbosity Debugparámetro de 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 muestra

1. En la ventana de la línea de comandos, navegue hasta~/aws-iot-device-sdk-js-v2/

samples/node/pub_subdirectorio que creó el SDK e instala la aplicación de ejemplo mediante
estos comandos. El comandonpm installinvocará elaws-crtcompilación de la biblioteca que
puede tardar unos minutos en completarse.

cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install

2. En la ventana de línea de comandos, reemplacesu punto final de IoTcomo 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

3. Observe que la aplicación de ejemplo:

1. Se conecta alAWS IoTservicio para tu cuenta.

2. Se suscribe al tema del mensaje,tema_1, y muestra los mensajes que recibe sobre ese tema.
3. Publica 10 mensajes sobre el tema,tema_1.
4. Muestra un resultado similar al 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

66
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

{"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 tienes problemas para ejecutar la aplicación de muestra, consultathe section called “Solución
de problemas con la aplicación de muestra” (p. 67).

También puede añadir el--verbosity Debugparámetro de 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 enAWS IoTconsola

Puede ver los mensajes de la aplicación de ejemplo a medida que pasan por el agente de mensajes
mediante elcliente de prueba MQTTen elAWS IoTconsola.

Para ver los mensajes MQTT publicados por la aplicación de ejemplo

1. Consulte Ver los mensajes MQTT con el cliente MQTT de AWS IoT (p. 69). Esto le ayuda a
aprender a usar elcliente de prueba MQTTen elAWS IoTconsolapara ver los mensajes MQTT a
medida que pasan por el intermediario de mensajes.
2. Abra elcliente de prueba MQTTen elAWS IoTconsola.
3. Suscríbete al tema,tema_1.
4. En la ventana de línea de comandos, vuelva a ejecutar la aplicación de ejemplo y observe los
mensajes delCliente MQTTen elAWS IoTconsola.

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 muestra

Si encuentras un error al intentar ejecutar la aplicación de muestra, comprueba lo siguiente.

Compruebe el certificado
Si el certificado no está activo,AWS IoTno aceptará ningún intento de conexión que lo utilice para la
autorización. Al crear su certificado, es fácil pasar por alto elActivarbotón. Afortunadamente, puede activar
su certificado desdeAWS IoTconsola.

Para comprobar la activación del certificado

1. En elAWS IoTconsola, en el menú de la izquierda, seleccionaSeguroy, a continuación,

elijaCertificados.

67
 AWS IoT Core Guía para desarrolladores
Configuración del dispositivo

2. En la lista de certificados, busque el certificado que creó para el ejercicio y compruebe su estado en
elEstadocolumna.

Si no recuerda el nombre del certificado, compruebe si hay alguno que lo seaInactivopara ver si
pueden ser los que estás usando.

Elija el certificado de la lista para abrir su página de detalles. En la página de detalles, puedes ver
suFecha de creaciónpara ayudarle a identificar el certificado.
3. Para activar un certificado inactivo, en la página de detalles del certificado, elijaAccionesy luego
eligeActivar.

Si has encontrado el certificado correcto y está activo, pero sigues teniendo problemas para ejecutar la
aplicación de muestra, comprueba su política tal y como se describe en el paso siguiente.

También puede intentar crear algo nuevo y un certificado nuevo siguiendo los pasos dethe section called
“Crea una cosa (objeto)” (p. 41). Si creas algo nuevo, tendrás que darle un nombre nuevo y descargar
los nuevos archivos de certificado a tu dispositivo.

Consulte la política adjunta al certificado

Las políticas autorizan acciones enAWS IoT. Si el certificado utilizado para conectarse aAWS IoTsi 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 adjuntas a un certificado

1. Busque el certificado tal y como se describe en el elemento anterior y abra su página de detalles.
2. En el menú de la izquierda de la página de detalles del certificado, elijaPolíticaspara ver las políticas
adjuntas al certificado.
3. Si no hay políticas adjuntas al certificado, añada una seleccionando laAccionesmenú y, a
continuación, elegirPolítica de adjuntos.

Elija la política que creó anteriormente enthe section called “CrearAWS IoTrecursos” (p. 39).
4. Si hay una política adjunta, seleccione el icono de la política para abrir su página de detalles.

En la página de detalles, consulta laDocumento de políticapara asegurarte de que contiene la misma

información que la que creaste enthe section called “Creación de una política de AWS IoT” (p. 40).

Compruebe la línea de comandos

Asegúrese de utilizar 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.

Compruebe la dirección del punto final

Revise el comando que ha introducido y compruebe que la dirección del punto final de su comando
coincide con la de suAWS IoTconsola.

Compruebe los nombres de los archivos de certificados

Compare los nombres de archivo del comando que ha introducido con los nombres de los archivos de
certificados de lacertsdirectorio.

Es posible que algunos sistemas requieran que los nombres de los archivos estén entre comillas para
funcionar correctamente.

68
 AWS IoT Core Guía para desarrolladores
Ver los mensajes MQTT con el cliente MQTT de AWS IoT

Compruebe la instalación del SDK

Asegúrese de que la instalación del SDK esté completa y correcta.

En caso de duda, vuelve a instalar el SDK en tu dispositivo. En la mayoría de los casos, es cuestión de
encontrar la sección del tutorial tituladaInstale elAWS IoTSDK de dispositivos paraIdioma del SDKy
siguiendo de nuevo el procedimiento.

Si está utilizando elAWS IoTSDK de dispositivos paraJavaScript, recuerde instalar las aplicaciones de
muestra antes de intentar ejecutarlas. La instalación del SDK no instala automáticamente las aplicaciones
de muestra. Las aplicaciones de muestra se deben instalar manualmente después de instalar el SDK.

Ver los mensajes MQTT con el cliente MQTT de

AWS IoT
En esta sección se describe cómo utilizar elAWS IoTCliente de prueba MQTT en elAWS IoTconsolapara
ver los mensajes MQTT enviados y recibidos porAWS IoT. El ejemplo utilizado en esta sección se
refiere a los ejemplos utilizados enIntroducción a AWS IoT Core (p. 18); sin embargo, puede
reemplazar elNombre del temautilizado en los ejemplos con cualquiernombre del tema o filtro de
tema (p. 112)utilizado por su solución de IoT.

Los dispositivos publican mensajes MQTT que se identifican contemas (p. 112)para comunicar su
estado aAWS IoT, yAWS IoTpublica mensajes MQTT para informar a los dispositivos y aplicaciones de
los cambios y eventos. Puede utilizar el cliente MQTT para suscribirse a estos temas y ver los mensajes a
medida que aparecen. También puede utilizar el cliente de prueba MQTT para publicar mensajes MQTT en
los dispositivos y servicios suscritos en suCuenta de AWS.

Contenido
• Visualización de mensajes MQTT en el cliente MQTT (p. 69)
• Publicación de mensajes MQTT desde el cliente MQTT (p. 71)
• Prueba de suscripciones compartidas en el cliente MQTT (p. 72)

Visualización de mensajes MQTT en el cliente MQTT

Para ver los mensajes MQTT en el cliente de prueba MQTT

1. En elAWS IoTconsola, en el menú de la izquierda, seleccionaPruebay luego eligecliente de prueba

MQTT.

69
 AWS IoT Core Guía para desarrolladores
Visualización de mensajes MQTT en el cliente MQTT

2. En elSuscríbete a un temapestaña, introduzca laNombre del temapara suscribirse al tema en el

que se publica su dispositivo. Para ver la aplicación de muestra para empezar, suscríbete a#, que se
suscribe a todos los temas de los mensajes.

Continuando con el ejemplo de introducción, enSuscríbete a un temapestaña, enFiltro de

temascampo, introducir#y, a continuación, elijaSuscríbete.

La página de registro de mensajes del tema,#se abre y#aparece en elSuscripcioneslista. Si el

dispositivo que configuró enthe section called “Configuración del dispositivo” (p. 42)está ejecutando
el programa de ejemplo, deberías ver los mensajes aAWS IoTen el#registro de mensajes. Las
entradas del registro de mensajes aparecerán debajo dePublicarsección cuando los mensajes con el
tema suscrito son recibidos porAWS IoT.

3. En el#página de registro de mensajes, también puedes publicar mensajes en un tema, pero tendrás
que especificar el nombre del tema. No puede publicar en#tema.

Los mensajes publicados en los temas suscritos aparecen en el registro de mensajes a medida que se
reciben, con el mensaje más reciente primero.

Solución de problemas de mensajes MQTT

Usa el filtro de temas comodín

Si tus mensajes no aparecen en el registro de mensajes como esperabas, prueba a suscribirte a un filtro
de temas comodín, tal y como se describe enFiltros de temas (p. 114). El filtro de temas comodín de
varios niveles de MQTT es el signo hash o libra (#) y se puede utilizar como filtro de temas enTema de
suscripcióncampo.

Suscribirse a la#El filtro de temas se suscribe a todos los temas recibidos por el agente de mensajes.
Puede reducir el filtro sustituyendo los elementos de la ruta del filtro del tema por un#comodín de varios
niveles o comodín de un solo nivel «+».

Cuando se utilizan caracteres comodín en un filtro de temas

• El carácter comodín de varios niveles debe ser el último carácter del filtro de temas.

70
 AWS IoT Core Guía para desarrolladores
Publicación de mensajes MQTT desde el cliente MQTT

• La ruta del filtro de temas solo puede tener un carácter comodín de un solo nivel por nivel de tema.

Por ejemplo:

Filtro de temas Muestra mensajes con

# Cualquier nombre de tema

topic_1/# Un nombre de tema que comience portopic_1/

topic_1/level_2/# Un nombre de tema que comience portopic_1/

level_2/

topic_1/+/level_3 Un nombre de tema que comience portopic_1/,

termina con/level_3, y tiene un elemento de
cualquier valor intermedio.

Para obtener más información sobre los filtros de temas, consulteFiltros de temas (p. 114).

Compruebe si hay errores en el nombre del tema

Los nombres y filtros de temas de MQTT distinguen entre mayúsculas y minúsculas. Si, por ejemplo,
su dispositivo publica mensajes enTopic_1(con mayúscula)T) en lugar detopic_1, el tema al que se
suscribió, sus mensajes no aparecerían en el cliente de prueba de MQTT. Sin embargo, si te suscribes al
filtro de temas comodín, se mostrará que el dispositivo está publicando mensajes y que está utilizando un
nombre de tema diferente al que esperabas.

Publicación de mensajes MQTT desde el cliente

MQTT
Para publicar un mensaje en un tema de MQTT

1. En la página del cliente de prueba de MQTT, enPublicar en un temapestaña, enNombre del

temacampo, introduzca elNombre del temade tu mensaje. En este ejemplo, use my/topic.
Note

No utilice información de identificación personal en los nombres de los temas, ya sea que los
utilice en el cliente de prueba de MQTT o en la implementación de su sistema. Los nombres
de los temas pueden aparecer en comunicaciones e informes no cifrados.
2. En la ventana de carga del mensaje, introduzca el siguiente JSON:

{
"message": "Hello, world",
"clientType": "MQTT test client"
}

3. EscojaPublicarpara publicar tu mensaje enAWS IoT.

Note

Asegúrese de estar suscrito a lami/tematema antes de publicar el mensaje.

71
 AWS IoT Core Guía para desarrolladores
Prueba de suscripciones compartidas en el cliente MQTT

4. En elSuscripcioneslista, eligemi/temapara ver el mensaje. Debería ver el mensaje aparecer en el

cliente de prueba de MQTT, debajo de la ventana de carga de publicación del mensaje.

Puede publicar mensajes MQTT en otros temas cambiando laNombre del temaen elNombre del
temacampo y seleccionando elPublicarbotón.

Prueba de suscripciones compartidas en el cliente

MQTT
En esta sección se describe cómo utilizar elAWS IoTCliente MQTT en elAWS IoTconsolapara
ver los mensajes MQTT enviados y recibidos porAWS IoTmediante suscripciones
compartidas.??? (p. 101)permiten que varios clientes compartan una suscripción a un tema y solo un
cliente reciba los mensajes publicados sobre ese tema mediante una distribución aleatoria. Para simular
varios clientes de MQTT (en este ejemplo, dos clientes de MQTT) que comparten la misma suscripción,
abra elAWS IoTCliente MQTT en elAWS IoTconsoladesde varios navegadores web. El ejemplo utilizado en
esta sección no se relaciona con los ejemplos utilizados enIntroducción a AWS IoT Core (p. 18). Para
obtener más información, consulteSuscripciones compartidas (p. 101).

Para compartir una suscripción a un tema de MQTT

1. En elAWS IoTconsola, en el panel de navegación, elijaPruebay luego eligecliente de prueba MQTT.

72
 AWS IoT Core Guía para desarrolladores
Prueba de suscripciones compartidas en el cliente MQTT

2. En elSuscríbete a un temapestaña, introduzca laNombre del temapara suscribirse al tema en el que

se publica su dispositivo. Para usar las suscripciones compartidas, suscríbase al filtro de temas de una
suscripción compartida de la siguiente manera:

$share/{ShareName}/{TopicFilter}

Un ejemplo de filtro de temas puede ser$share/group1/topic1, que se suscribe al tema del

mensajetopic1.

3. Abre otro navegador web y repite los pasos 1 y 2. De esta forma, está simulando dos clientes MQTT
diferentes que comparten la misma suscripción.$share/group1/topic1.
4. Elija un cliente MQTT, enPublicar en un temapestaña, enNombre del temacampo, introduzca
elNombre del temade tu mensaje. En este ejemplo, use topic1. Intenta publicar el mensaje
varias veces. Desde elSuscripcioneslista de ambos clientes de MQTT, debería poder ver que los
clientes reciben el mensaje mediante una distribución aleatoria. En este ejemplo, publicamos el mismo
mensaje «Hola desdeAWS IoTconsola» tres veces. El cliente MQTT de la izquierda recibió el mensaje
dos veces y el cliente MQTT de la derecha lo recibió una vez.

73
 AWS IoT Core Guía para desarrolladores
AWS IoT Core- puntos finales del plano de control

Conexión a AWS IoT Core

AWS IoT Coreadmite conexiones con dispositivos de IoT, puertas de enlace inalámbricas, servicios y
aplicaciones. Los dispositivos se conectan aAWS IoT Corepara que puedan enviar datos a y recibir datos
deAWS IoTservicios y otros dispositivos. Las aplicaciones y otros servicios también se conectan aAWS IoT
Corepara controlar y gestionar los dispositivos de IoT y procesar los datos de su solución de IoT. En esta
sección se describe cómo elegir la mejor forma de conectarse y comunicarse conAWS IoT Corepara cada
aspecto de su solución de IoT.

Hay varias formas de interactuar conAWS IoT. Las aplicaciones y los servicios pueden utilizar elAWS
IoT Core- puntos finales del plano de control (p. 74)y los dispositivos pueden conectarse aAWS IoT
Coremediante elAWS IoTpuntos finales del dispositivo (p. 75)oAWS IoT CoreporLoRaPuertas de enlace
y dispositivos WAN (p. 76).

AWS IoT Core- puntos finales del plano de control

ElAWS IoT Core- plano de controllos puntos finales brindan acceso a las funciones que controlan y
administran suAWS IoTsolución.

• Puntos de conexión

ElAWS IoT Core- plano de controlyAWS IoT CorePlano de control de Device Advisorlos puntos finales
son específicos de la región y se enumeran enAWS IoT CoreCriterios de valoración y cuotas. Los
formatos de los puntos finales son los siguientes.

Propósito del terminal Formato de punto de conexión Sirve

AWS IoT Core- plano de control iot.aws- AWS IoTAPI de plano de control
region.amazonaws.com

74
 AWS IoT Core Guía para desarrolladores
AWS IoTpuntos finales del dispositivo

Propósito del terminal Formato de punto de conexión Sirve

AWS IoT CoreDevice Advisor: api.iotdeviceadvisor.aws- AWS IoT CoreAPI del plano de
plano de control region.amazonaws.com control de Device Advisor

• SDK y herramientas

ElAWSSDKproporcionan soporte específico para cada idiomaAWS IoT CoreLas API y las API de
otrosAWSservicios. ElAWSSDK móvilesproporcionar a los desarrolladores de aplicaciones soporte
específico para la plataformaAWS IoT CoreAPI y otrosAWSservicios en dispositivos móviles.

ElAWS CLIproporciona acceso desde la línea de comandos a las funciones proporcionadas por elAWS
IoTpuntos finales de servicio.AWS Herramientas paraPowerShellproporciona herramientas para
gestionarAWSservicios y recursos en elPowerShellentorno de creación de scripts.
• Autenticación

Los puntos finales del servicio utilizan usuarios de IAM yAWScredenciales para autenticar a los usuarios.
• Más información

Para obtener más información y enlaces a las referencias del SDK, consultethe section called
“Conectarse aAWS IoT Corepuntos finales de servicio” (p. 77).

AWS IoTpuntos finales del dispositivo

ElAWS IoTlos puntos finales de los dispositivos admiten la comunicación entre sus dispositivos de IoT
yAWS IoT.

• Puntos de conexión

Los terminales del dispositivo admitenAWS IoT CoreyAWS IoT Device Managementfunciones. Son
específicos para suCuenta de AWSy puedes ver lo que son utilizando eldescribe-endpointcomando.

Propósito del terminal Formato de punto de conexión Sirve

AWS IoT Core- plano de datos Consulte ??? (p. 83). AWS IoTAPI de plano de datos

AWS IoT Device Management- Consulte ??? (p. 83). AWS IoTAPI de plano de datos
datos de empleos de Jobs

AWS IoTDevice Advisor: plano Consulte ??? (p. 1153). No aplicable

de datos

AWS IoT Device Management- No aplicable No aplicable

Centro de flotas

AWS IoT Device Management- api.tunneling.iot.aws- AWS IoTAPI de tunelización

construcción segura de túneles region.amazonaws.com segura

Para obtener más información sobre estos puntos de conexión y las funciones que admiten, consultethe
section called “AWS IoTpuntos finales de servicio y datos del dispositivo” (p. 83).
• SDK

ElAWS IoTSDK de dispositivos (p. 85)proporcionan soporte específico para cada idioma para el
transporte telemétrico de mensajería en cola (MQTT) yWebSocketProtocolos seguros (WSS), con los
que se comunican los dispositivosAWS IoT.AWS Mobile SDK (p. 82)también brindan soporte para las

75
 AWS IoT Core Guía para desarrolladores
AWS IoT CoreporLoRaPuertas
de enlace y dispositivos WAN

comunicaciones de dispositivos MQTT,AWS IoTLas API y las API de otrosAWSservicios en dispositivos

móviles.
• Autenticación

Los terminales del dispositivo utilizan certificados X.509 oAWSUsuarios de IAM con credenciales para
autenticar a los usuarios.
• Más información

Para obtener más información y enlaces a las referencias del SDK, consultethe section called “SDK de
dispositivos de AWS IoT” (p. 85).

AWS IoT CoreporLoRaPuertas de enlace y

dispositivos WAN
AWS IoT CoreporLoRaLa WAN conecta puertas de enlace y dispositivos inalámbricos aAWS IoT Core.

• Puntos de conexión

AWS IoT CoreporLoRaLa WAN administra las conexiones de puerta de enlace a cuentas y regiones
específicasAWS IoT Corepuntos finales. Las puertas de enlace pueden conectarse al punto final
del servidor de configuración y actualización (CUPS) de su cuenta queAWS IoT CoreporLoRaWAN
proporciona.

Propósito del terminal Formato de punto de conexión Sirve

Servidor de configuración y account-specific- Comunicación de pasarela

actualización (CUPS) prefix.cups.lorawan.aws- con el servidor de
region.amazonaws.com:443 configuración y actualización
proporcionada porAWS IoT
CoreporLoRaMENGUAR

LoRaServidor de red WAN account-specific- Comunicación de pasarela con

(LNS) elLoRaServidor de red WAN
prefix.gateway.lorawan.aws-
region.amazonaws.com:443 proporcionado porAWS IoT
CoreporLoRaMENGUAR

• SDK

ElAWS IoTAPI inalámbrica queAWS IoT CoreporLoRaLa WAN se basa en el soporte deAWSSDK. Para
obtener más información, consulteAWSSDK y kits de herramientas.
• Autenticación

AWS IoT CoreporLoRaLas comunicaciones entre dispositivos WAN utilizan certificados X.509 para
proteger las comunicaciones conAWS IoT.
• Más información

Para obtener más información sobre la configuración y la conexión de dispositivos inalámbricos,

consulteAWS IoT Corepara LoRa WAN (p. 1272).

76
 AWS IoT Core Guía para desarrolladores
Conectarse aAWS IoT Corepuntos finales de servicio

Conectarse aAWS IoT Corepuntos finales de

servicio
Puede acceder a las funciones delAWS IoT Core- plano de controlmediante el uso deAWS CLI,
elAWSSDK para su idioma preferido o llamando directamente a la API REST. Se recomienda utilizar
elAWS CLIo unAWSSDK con el que interactuarAWS IoT Coreporque incorporan las mejores prácticas
para llamarAWSservicios. Llamar directamente a las API REST es una opción, pero debe proporcionarlas
credenciales de seguridad necesariasque permiten el acceso a la API.
Note

Los dispositivos de IoT deben usarSDK de dispositivos de AWS IoT (p. 85). Los SDK de
dispositivos están optimizados para su uso en dispositivos y admiten la comunicación MQTT
conAWS IoT, y apoye elAWS IoTLas API más utilizadas por los dispositivos. Para obtener
más información sobre los SDK de dispositivos y las funciones que ofrecen, consulteSDK de
dispositivos de AWS IoT (p. 85).
Los dispositivos móviles deben utilizarAWS Mobile SDK (p. 82). Los SDK para dispositivos
móviles ofrecen soporte paraAWS IoTLas API, las comunicaciones entre dispositivos MQTT y las
API de otrosAWSservicios en dispositivos móviles. Para obtener más información sobre los SDK
para dispositivos móviles y las funciones que ofrecen, consulteAWS Mobile SDK (p. 82).

Puedes usarAWS Amplifyherramientas y recursos en aplicaciones web y móviles para conectarse

más fácilmente aAWS IoT Core. Para obtener más información sobre cómo conectarse aAWS IoT
Coremediante Amplify, consulteIntroducción a Pub Suben la documentación de Amplify.

En las siguientes secciones se describen las herramientas y los SDK que puede utilizar para desarrollar e
interactuar con ellos.AWS IoTy otrosAWSservicios. Para ver la lista completa deAWSherramientas y kits
de desarrollo que están disponibles para crear y administrar aplicaciones enAWS, consulteHerramientas
sobre las que construirAWS.

AWS CLI para AWS IoT Core

ElAWS CLIproporciona acceso desde la línea de comandos aAWSAPIs.

• Instalación

Para obtener información sobre cómo instalar elAWS CLI, consulteInstalación delAWS CLI.
• Autenticación

ElAWS CLIusa las credenciales de suCuenta de AWS.

• Referencia

Para obtener información sobre laAWS CLIcomandos para estosAWS IoT Coreservicios, consulte:
• AWS CLIReferencia de comandos para IoT
• AWS CLIReferencia de comandos para datos de IoT
• AWS CLIReferencia de comandos para datos de trabajos de IoT
• AWS CLIReferencia de comandos para túneles seguros de IoT

Para herramientas de gestiónAWSservicios y recursos en elPowerShellentorno de creación de scripts,

consulteAWSHerramientas paraPowerShell.

77
 AWS IoT Core Guía para desarrolladores
SDK de AWS

SDK de AWS
ConAWSLos SDK, tus aplicaciones y dispositivos compatibles pueden llamarAWS IoTLas API y las API
de otrosAWSservicios. En esta sección se proporcionan enlaces a laAWSLos SDK y la documentación de
referencia de la API para las API delAWS IoT Coreservicios.

ElAWSLos SDK admiten estasAWS IoT CoreAPIs

• AWS IoT
• AWS IoTPlano de datos
• AWS IoTPlano de datos de trabajos
• AWS IoTTúneles seguros
• AWS IoTinalámbrico

C++

Para instalar elAWS SDK for C++y úsalo para conectarte aAWS IoT:

1. Siga las instrucciones deCómo empezar a usar elAWSSDK para C++

Estas instrucciones describen cómo:

• Instalar y compilar el SDK a partir de los archivos fuente
• Proporcione las credenciales para usar el SDK con suCuenta de AWS
• Inicializa y cierra el SDK en tu aplicación o servicio
• Crea un proyecto de CMake para crear tu aplicación o servicio
2. Crea y ejecuta una aplicación de muestra. Para aplicaciones de ejemplo que utilizan elAWSSDK
para C++, consulteAWS SDK for C++Ejemplos de código.

Documentación para elAWS IoT Coreservicios que elAWS SDK for C++soporta

• AWSdocumentación de referencia: :IotClient»

• AWS: :IoTDataPlane::Internet de las cosasDataPlaneClientdocumentación de referencia
• AWS: :IoTJobsDataPlane::Internet de las cosasJobsDataPlaneClientdocumentación de referencia
• AWS: :IoTSecureTunneling::Internet de las cosasSecureTunnelingClientdocumentación de
referencia

Go

Para instalar elAWS SDK for Goy úsalo para conectarte aAWS IoT:

1. Siga las instrucciones deEmpezando con elAWS SDK for Go

Estas instrucciones describen cómo:

• Instalar la AWS SDK for Go
• Obtenga claves de acceso para que el SDK acceda a susCuenta de AWS
• Importe paquetes al código fuente de nuestras aplicaciones o servicios
2. Crea y ejecuta una aplicación de muestra. Para aplicaciones de ejemplo que utilizan elAWS SDK for
Go, consulteAWS SDK for GoEjemplos de código.

78
 AWS IoT Core Guía para desarrolladores
SDK de AWS

Documentación para elAWS IoT Coreservicios que elAWS SDK for Gosoporta

• Documentación de referencia de IoT

• IoTDataPlanedocumentación de referencia
• IoTJobsDataPlanedocumentación de referencia
• IoTSecureTunnelingdocumentación de referencia

Java

Para instalar elAWS SDK for Javay úsalo para conectarte aAWS IoT:

1. Siga las instrucciones deEmpezar conAWS SDK for Java 2.x

Estas instrucciones describen cómo:

• Inscríbase enAWSy cree un usuario de IAM
• Descargar el SDK
• ConfigurarAWSCredenciales y región
• Usa el SDK con Apache Maven
• Usa el SDK con Gradle
2. Cree y ejecute una aplicación de muestra con una de lasAWS SDK for Java 2.xEjemplos de código.
3. Revise elDocumentación de referencia de la API del SDK

Documentación para elAWS IoT Coreservicios que elAWS SDK for Javasoporta

• IotClientdocumentación de referencia
• IotDataPlaneClientdocumentación de referencia
• IotJobsDataPlaneClientdocumentación de referencia
• IoTSecureTunnelingClientdocumentación de referencia

JavaScript

Para instalar elAWS SDK for JavaScripty úsalo para conectarte aAWS IoT:

1. Siga las instrucciones deConfiguración delAWS SDK for JavaScript. Estas instrucciones se aplican
al uso delAWS SDK for JavaScripten el navegador y con Node.JS. Asegúrese de seguir las
instrucciones aplicables a la instalación.

Estas instrucciones describen cómo:

• Compruebe los requisitos previos
• Instale el SDK paraJavaScript
• Cargue el SDK paraJavaScript
2. Cree y ejecute una aplicación de muestra para empezar a utilizar el SDK, tal y como se describe en
la opción de inicio de su entorno.
• Comience con elAWSSDK paraJavaScripten el navegador, o
• Comience con elAWSSDK paraJavaScripten Node.js

Documentación para elAWS IoT Coreservicios que elAWS SDK for JavaScriptsoporta

• AWS.Iot reference documentation

• AWS.IotData reference documentation

79
 AWS IoT Core Guía para desarrolladores
SDK de AWS

• AWS.IotJobsDataPlane reference documentation

• AWS.IotSecureTunneling reference documentation

.NET

Para instalar elAWS SDK for .NETy úsalo para conectarte aAWS IoT:

1. Siga las instrucciones deConfiguración de suAWS SDK for .NETentorno

2. Siga las instrucciones deConfiguración de suAWS SDK for .NETproyecto

Estas instrucciones describen cómo:

• Comenzar un nuevo proyecto
• Obtener y configurarAWScredenciales
• InstalaAWSPaquetes SDK
3. Cree y ejecute uno de los programas de ejemplo enTrabajando conAWSservicios en elAWSSDK
para .NET
4. Revise elDocumentación de referencia de la API del SDK

Documentación para elAWS IoT Coreservicios que elAWS SDK for .NETsoporta

• Documentación de referencia de Amazon.IOT.Model

• Amazon.IotData.Documentación de referencia del modelo
• Amazon.IoTJobsDataPlane.Documentación de referencia del modelo
• Amazon.IoTSecureTunneling.Documentación de referencia del modelo

PHP

Para instalar elAWS SDK for PHPy úsalo para conectarte aAWS IoT:

1. Siga las instrucciones deEmpezando con elAWS SDK for PHPVersión 3

Estas instrucciones describen cómo:

• Compruebe los requisitos previos
• Instalación del SDK
• Aplicar el SDK a un script PHP
2. Cree y ejecute una aplicación de muestra con una de lasAWS SDK for PHPEjemplos de código de
la versión 3

Documentación para elAWS IoT Coreservicios que elAWS SDK for PHPsoporta

• Documentación de referencia de IOTClient

• IoTDataPlaneClientdocumentación de referencia
• IoTJobsDataPlaneClientdocumentación de referencia
• IoTSecureTunnelingClientdocumentación de referencia

Python

Para instalar elAWS SDK for Python (Boto3)y úsalo para conectarte aAWS IoT:

1. Siga las instrucciones delAWS SDK for Python (Boto3)Inicio rápido

80
 AWS IoT Core Guía para desarrolladores
SDK de AWS

Estas instrucciones describen cómo:

• Instalación del SDK
• Configuración del SDK
• Usa el SDK en tu código
2. Cree y ejecute un programa de ejemplo que utiliceAWS SDK for Python (Boto3)

Este programa muestra las opciones de registro configuradas actualmente en la cuenta. Después
de instalar el SDK y configurarlo para su cuenta, debería poder ejecutar este programa.

import boto3
import json

# initialize client
iot = boto3.client('iot')

# get current logging levels, format them as JSON, and write them to stdout
response = iot.get_v2_logging_options()
print(json.dumps(response, indent=4))

Para obtener más información sobre la función utilizada en este ejemplo, consultethe section called
“Configuración de registros de AWS IoT” (p. 459).

Documentación para elAWS IoT Coreservicios que elAWS SDK for Python (Boto3)soporta

• Documentación de referencia de IoT

• IoTDataPlanedocumentación de referencia
• IoTJobsDataPlanedocumentación de referencia
• IoTSecureTunnelingdocumentación de referencia

Ruby

Para instalar elAWS SDK for Rubyy úsalo para conectarte aAWS IoT:

• Siga las instrucciones deEmpezando con elAWS SDK for Ruby

Estas instrucciones describen cómo:

• Instalación del SDK
• Configuración del SDK
• Cree y ejecute elTutorial Hello World

Documentación para elAWS IoT Coreservicios que elAWSCompatible con SDK para Ruby

• Documentación de referencia de Aws: :IoT: :Client

• AWS: :IoTDataPlane::Documentación de referencia para el cliente
• AWS: :IoTJobsDataPlane::Documentación de referencia para el cliente
• AWS: :IoTSecureTunneling::Documentación de referencia para el cliente

81
 AWS IoT Core Guía para desarrolladores
AWS Mobile SDK

AWS Mobile SDK

ElAWSLos SDK para dispositivos móviles proporcionan a los desarrolladores de aplicaciones móviles
soporte específico para cada plataforma para las API delAWS IoT Coreservicios, comunicación de
dispositivos de IoT mediante MQTT y las API de otrosAWSservicios.

Android

AWS Mobile SDK for Android

ElAWS Mobile SDK for Androidcontiene una biblioteca, ejemplos y documentación para que los
desarrolladores puedan crear aplicaciones móviles conectadas medianteAWS. Este SDK también
incluye soporte para las comunicaciones entre dispositivos MQTT y para llamar a las API delAWS IoT
Coreservicios. Para obtener más información, consulte lo siguiente:

• AWSSDK móvil para Android activadoGitHub

• AWSSDK móvil para Android Readme
• AWSEjemplos de SDK móvil para Android
• AWSReferencia de API de SDK para Android
• AWSIoTClientDocumentación de referencia de clase

iOS

AWS Mobile SDK for iOS

ElAWS Mobile SDK for iOSes un kit de desarrollo de software de código abierto, distribuido bajo
una licencia Apache Open Source. El SDK para iOS proporciona una biblioteca, ejemplos de
código y documentación para ayudar a los desarrolladores a crear aplicaciones móviles conectadas
medianteAWS. Este SDK también incluye soporte para las comunicaciones entre dispositivos MQTT y
para llamar a las API delAWS IoT Coreservicios. Para obtener más información, consulte lo siguiente:

• AWS Mobile SDK for iOS en GitHub

• AWSSDK para iOS Readme
• AWSEjemplos de SDK para iOS
• AWS IoTDocumentos de referencia de clase enAWSSDK para iOS

API REST delAWS IoT Coreservicios

Las API REST delAWS IoT Corelos servicios se pueden llamar directamente mediante solicitudes HTTP.

• URL del punto de enlace

Los puntos finales del servicio que exponen las API REST delAWS IoT Corelos servicios varían según
la región y se enumeran enAWS IoT CoreCriterios de valoración y cuotas. Debe utilizar el punto final
de la región que tiene elAWS IoTrecursos a los que desea acceder, porqueAWS IoTlos recursos son
específicos de la región.
• Autenticación

Las API REST delAWS IoT Coreuso de serviciosAWSCredenciales de IAM para la autenticación. Para
obtener más información, consulteFirmandoAWSSolicitudes de APIen elAWSReferencia general.
• Referencia de la API

Para obtener información sobre las funciones específicas que proporcionan las API REST delAWS IoT
Coreservicios, consulte:

82
 AWS IoT Core Guía para desarrolladores
Conexión de dispositivos aAWS IoT

• Referencia de API para IoT.

• Referencia de API para datos de IoT.
• Referencia de API para datos de trabajos de IoT.
• Referencia de API para túneles seguros de IoT.

Conexión de dispositivos aAWS IoT

Los dispositivos se conectan aAWS IoTy otros servicios a través deAWS IoT Core. A través deAWS IoT
Core, los dispositivos envían y reciben mensajes mediante puntos de conexión del dispositivo que son
específicos de su cuenta. Elthe section called “SDK de dispositivos de AWS IoT” (p. 85)admiten las
comunicaciones entre dispositivos mediante los protocolos MQTT y WSS. Para obtener más información
sobre los protocolos que pueden usar los dispositivos, consultethe section called “Protocolos de
comunicación de dispositivos” (p. 87).

El intermediario de mensajes

AWS IoTgestiona la comunicación del dispositivo a través de un intermediario de mensajes. Los

dispositivos y los clientes publican mensajes en el agente de mensajes y también se suscriben a los
mensajes que publica el agente de mensajes. Los mensajes se identifican mediante una aplicación
definidatema (p. 112). Cuando el agente de mensajes recibe un mensaje publicado por un dispositivo o
un cliente, lo vuelve a publicar en los dispositivos y clientes que se han suscrito al tema del mensaje. El
intermediario de mensajes también reenvía los mensajes alAWS IoT reglas (p. 516)motor, que puede
actuar sobre el contenido del mensaje.

AWS IoTseguridad de mensajes

Conexiones de dispositivos aAWS IoTutilizarthe section called “Certificados de cliente

X.509” (p. 314)yAWSfirma V4para la autenticación. Las comunicaciones de los dispositivos están
protegidas por la versión 1.2 de TLS yAWS IoTrequiere que los dispositivos envíen elExtensión de
indicación del nombre del servidor (SNI)cuando se conectan. Para obtener más información, consulte
Seguridad de transporte en AWS IoT.

AWS IoTpuntos finales de servicio y datos del

dispositivo
Important

Puede almacenar en caché o almacenar los puntos finales en su dispositivo. Esto significa que no
necesitará consultar elDescribeEndpointAPI cada vez que se conecta un dispositivo nuevo.
Los puntos finales no cambiarán despuésAWS IoT Corelos crea para tu cuenta.

Cada cuenta tiene varios terminales de dispositivo que son exclusivos de la cuenta y admiten funciones
de IoT específicas. ElAWS IoTlos extremos de datos del dispositivo admiten un protocolo de publicación
o suscripción diseñado para las necesidades de comunicación de los dispositivos de IoT; sin embargo,
otros clientes, como aplicaciones y servicios, también pueden usar esta interfaz si su aplicación requiere
las funciones especializadas que proporcionan estos puntos finales. ElAWS IoTlos terminales de servicio
de dispositivos permiten el acceso centrado en el dispositivo a los servicios de seguridad y administración.

Para conocer el extremo de datos del dispositivo de tu cuenta, puedes encontrarlo enAjustespágina de
tuAWS IoT Coreconsola.

Para conocer el punto final del dispositivo de tu cuenta para un propósito específico, incluido el
extremo de datos del dispositivo, utiliza eldescribe-endpointEl comando CLI que se muestra aquí, o
elDescribeEndpointAPI REST y proporcione laendpointTypevalor de parámetro de la siguiente tabla.

83
 AWS IoT Core Guía para desarrolladores
AWS IoTpuntos finales de servicio y datos del dispositivo

aws iot describe-endpoint --endpoint-type endpointType

Este comando devuelve unpunto final de IoTen el siguiente formato:account-specific-

prefix.iot.aws-region.amazonaws.com.

Cada cliente tiene uniot:Data-ATSy uniot:Datapunto final. Cada terminal usa un certificado X.509
para autenticar el cliente. Recomendamos a los clientes que utilicen el tipo de punto de enlace iot:Data-
ATS más reciente para evitar problemas relacionados con la desconfianza generalizada en las entidades
de certificación de Symantec. Proporcionamos eliot:Datapunto final para que los dispositivos recuperen
datos de puntos finales antiguos que utilizanVeriSigncertificados de compatibilidad con versiones
anteriores. Para obtener más información, consulte Autenticación del servidor.

AWS IoTpuntos finales para dispositivos

Propósito del terminal endpointType value Descripción

AWS IoT Core- operaciones del iot:Data-ATS Se utiliza para enviar

plano de datos y recibir datos hacia y
desde el intermediario
de mensajes,Sombra del
dispositivo (p. 683), yMotor de
reglas (p. 516)componentes
deAWS IoT.

iot:Data-ATSdevuelve un
punto final de datos firmado por
ATS.

AWS IoT Core- operaciones del iot:Data iot:Datadevuelve

plano de datos (antiguas) unVeriSignse proporciona un
punto final de datos firmado para
garantizar la compatibilidad con
versiones anteriores. Symantec
no admite MQTT 5 (iot:Data)
puntos finales.

AWS IoT Coreacceso con iot:CredentialProvider Se usa para intercambiar el

credenciales certificado X.509 integrado
de un dispositivo por
credenciales temporales para
conectarse directamente con
otrosAWSservicios. Para obtener
más información acerca de cómo
conectarse a otros servicios
de AWS, consulte Autorizar
llamadas directas a servicios de
AWS (p. 395).

AWS IoT Device Management- iot:Jobs Se utiliza para permitir que

operaciones de datos de trabajos los dispositivos interactúen
conAWS IoTServicio de empleos
que utiliza elAPIs HTTPS de
dispositivos de trabajo (p. 817).

AWS IoTOperaciones de Device iot:DeviceAdvisor Tipo de punto final de prueba que

Advisor se utiliza para probar dispositivos
con Device Advisor. Para obtener

84
 AWS IoT Core Guía para desarrolladores
SDK de dispositivos de AWS IoT

Propósito del terminal endpointType value Descripción

más información, consulte
??? (p. 1148).

AWS IoT Coredata beta (versión iot:Data-Beta Un tipo de punto de conexión

preliminar) reservado para las versiones
beta. Para obtener información
sobre su uso actual,
consulte??? (p. 128).

También puedes usar tu propio nombre de dominio completo (FQDN), comoexample.com, y el

certificado de servidor asociado al que conectar los dispositivosAWS IoTmediante el usothe section called
“Terminales configurables” (p. 128).

SDK de dispositivos de AWS IoT

ElAWS IoTLos SDK de dispositivos lo ayudan a conectar sus dispositivos de IoT aAWS IoT Corey son
compatibles con los protocolos MQTT y MQTT a través de WSS.

ElAWS IoTLos SDK de dispositivos difieren de losAWSSDK en el sentido de que elAWS IoTLos SDK
de dispositivos satisfacen las necesidades de comunicación especializadas de los dispositivos de IoT,
pero no admiten todos los servicios compatibles conAWSSDK. ElAWS IoTLos SDK de dispositivos son
compatibles conAWSSDK que admiten todos losAWSservicios; sin embargo, utilizan diferentes métodos
de autenticación y se conectan a diferentes puntos finales, lo que podría hacer que el uso delAWSLos SDK
no son prácticos en un dispositivo de IoT.

Dispositivos móviles

Elthe section called “AWS Mobile SDK” (p. 82)admiten las comunicaciones de ambos dispositivos
MQTT, algunos de losAWS IoTlas API de servicio y las API de otrasAWSservicios. Si desarrolla en un
dispositivo móvil compatible, revise su SDK para ver si es la mejor opción para desarrollar su solución de
IoT.

C++

AWS IoTSDK de dispositivos C++

ElAWS IoTEl SDK de dispositivos C++ permite a los desarrolladores crear aplicaciones conectadas
medianteAWSy las API delAWS IoT Coreservicios. En concreto, este SDK se diseñó para los
dispositivos que no tienen limitación de recursos y requieren características avanzadas, como la
puesta en cola de mensajes, la compatibilidad con varios procesos y las características de idioma más
actualizadas. Para obtener más información, consulte lo siguiente:

• AWS IoTSDK de dispositivos C++ v2 activadoGitHub

• AWS IoTSDK de dispositivo C++ v2 Readme
• AWS IoTEjemplos de Device SDK C++ v2
• AWS IoTDocumentación de la API C++ v2 del SDK del dispositivo

Python

AWS IoTSDK de dispositivos para Python

ElAWS IoTEl SDK de dispositivos para Python permite a los desarrolladores escribir scripts de
Python para utilizar sus dispositivos para acceder aAWS IoTplataforma a través de MQTT o MQTT

85
 AWS IoT Core Guía para desarrolladores
SDK de dispositivos de AWS IoT

a través delWebSocketProtocolo seguro (WSS). Al conectar sus dispositivos a las API delAWS IoT
Coreservicios, los usuarios pueden trabajar de forma segura con el agente de mensajes, las reglas
y el servicio Device Shadow queAWS IoT Coreproporciona y con otrosAWSservicios comoAWS
Lambda, Amazon Kinesis y Amazon S3, entre otros.

• AWS IoTSDK de dispositivos para Python v2 activadoGitHub

• AWS IoT Device SDK for Python v2 Readme
• AWS IoTEjemplos de SDK de dispositivos para Python v2
• AWS IoTDocumentación de la API SDK de dispositivos para Python v2

JavaScript

AWS IoTSDK de dispositivos paraJavaScript

ElAWS IoTSDK de dispositivos paraJavaScripthace posible que los desarrolladores

escribanJavaScriptaplicaciones que acceden a las API delAWS IoT Coreutilizando MQTT o MQTT
sobre elWebSocketprotocolo. Se puede utilizar en entornos de Node.js y aplicaciones de navegador.
Para obtener más información, consulte lo siguiente:

• AWS IoTSDK de dispositivos paraJavaScriptv2 activadoGitHub

• AWS IoTSDK de dispositivos paraJavaScriptv2 Readme
• AWS IoTSDK de dispositivos paraJavaScriptMuestras v2
• AWS IoTSDK de dispositivos paraJavaScriptdocumentación de la API v2

Java

AWS IoTSDK de dispositivos para Java

ElAWS IoTEl SDK de dispositivos para Java permite a los desarrolladores de Java acceder a las API
delAWS IoT Corea través de MQTT o MQTT a través delWebSocketprotocolo. El SDK es compatible
con el servicio Device Shadow. Puede tener acceso a las sombras mediante los métodos GET,
UPDATE y DELETE de HTTP. El SDK también admite un modelo simplificado de acceso oculto,
que permite a los desarrolladores intercambiar datos con sombras mediante los métodos getter y
setter, sin tener que serializar ni deserializar ningún documento JSON. Para obtener más información,
consulte lo siguiente:

• AWS IoTSDK de dispositivos para Java v2 activadoGitHub

• Archivo léame de AWS IoT Device SDK for Java v2
• AWS IoTEjemplos de SDK de dispositivos para Java v2
• AWS IoTDocumentación de la API del SDK del dispositivo para Java v2

Embedded C

AWS IoTSDK de dispositivos para C integrado

Important

Este SDK está destinado a desarrolladores de software integrado con experiencia.

ElAWS IoT Device SDK para Embedded C(C-SDK) es una colección de archivos fuente en C bajo la
licencia de código abierto del MIT que se pueden utilizar en aplicaciones integradas para conectar
de forma segura dispositivos de IoT aAWSNúcleo de IoT. Incluye MQTT, JSON Parser yAWS
IoTBibliotecas Device Shadow y otras. Se distribuye en formato fuente y está previsto que se integre

86
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

en el firmware del cliente junto con el código de la aplicación, otras bibliotecas y, opcionalmente, un
RTOS (sistema operativo en tiempo real).

AWS IoT Device SDK para Embedded C generalmente se dirige a dispositivos con limitaciones de
recursos que requieren un tiempo de ejecución optimizado del lenguaje C. Puede usar el SDK en
cualquier sistema operativo y alojarlo en cualquier tipo de procesador (por ejemplo, MCU y MPU). Si el
dispositivo tiene suficientes recursos de memoria y procesamiento disponibles, le recomendamos que
utilice uno de los otrosAWS IoTSDK para dispositivos y dispositivos móviles, como elAWS IoTSDK de
dispositivos para C++, Java,JavaScript, o Python.

Para obtener más información, consulte lo siguiente:

• AWS IoTSDK de dispositivos para C integrado activadoGitHub

• AWS IoT Device SDK for Embedded C Readme
• AWS IoTSDK de dispositivos para muestras de C embebido

Protocolos de comunicación de dispositivos

AWS IoT Coreadmite dispositivos y clientes que utilizan el MQTT y el MQTT enWebSocketProtocolos
seguros (WSS) para publicar mensajes y suscribirse a ellos, y dispositivos y clientes que utilizan el
protocolo HTTPS para publicar mensajes. Todos los protocolos admiten IPv4 e IPv6. En esta sección se
describen las diferentes opciones de conexión para dispositivos y clientes.

TLS 1.2 y TLS 1.3

AWS IoT CoreusosTLS versión 1.2yTLS versión 1.3para cifrar todas las comunicaciones. Al conectar
dispositivos aAWS IoT Core, los clientes pueden enviar elExtensión de indicación del nombre del servidor
(SNI), que no es obligatorio pero sí muy recomendable. Para usar funciones comoregistro de múltiples
cuentas,dominios personalizados, yTerminales de VPC, debe utilizar la extensión SNI. Para obtener más
información, consulte Seguridad de transporte en AWS IoT.

ElSDK de dispositivos de AWS IoT (p. 85)admiten MQTT y MQTT a través de WSS y cumplen con los
requisitos de seguridad de las conexiones de los clientes. Se recomienda utilizar elSDK de dispositivos de
AWS IoT (p. 85)para conectar a los clientes conAWS IoT.

Protocolos, mapeos de puertos y autenticación

La forma en que un dispositivo o un cliente se conecta al intermediario de mensajes mediante un punto

final del dispositivo depende del protocolo que utilice. En la siguiente tabla se enumeran los protocolos
queAWS IoTla compatibilidad con los terminales de los dispositivos y los métodos de autenticación y los
puertos que utilizan.

Protocolos, autenticación y mapeos de puerto

Protocolo Operaciones Autenticación Port Nombre del

apoyadas protocolo ALPN

MQTT Publicar, Signature Version 443 N/A

sobreWebSocket suscribirse 4

MQTT Publicar, Autenticación 443 N/A

sobreWebSocket suscribirse personalizada
†
MQTT Publicar, Certificado de 443 x-amzn-mqtt-ca
suscribirse cliente X.509

MQTT Publicar, Certificado de 8883 N/A

suscribirse cliente X.509

87
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Protocolo Operaciones Autenticación Port Nombre del

apoyadas protocolo ALPN
†
MQTT Publicar, Autenticación 443 mqtt
suscribirse personalizada

HTTPS Publicar solo Signature Version 443 N/A

4
†
HTTPS Publicar solo Certificado de 443 x-amzn-http-ca
cliente X.509

HTTPS Publicar solo Certificado de 8443 N/A

cliente X.509

HTTPS Publicar solo Autenticación 443 N/A

personalizada

Negociación de protocolos de capa de aplicación (ALPN)

†
Los clientes que se conectan en el puerto 443 con la autenticación con certificado de cliente
X.509 deben implementar laNegociación de protocolos de capa de aplicación (ALPN)extensión
TLS y utilice elNombre del protocolo ALPNincluido en la ALPNProtocolNameListenviado por el
cliente como parte de laClientHellomensaje.
En el puerto 443, elIoT: Data-ATS (p. 84)endpoint admite ALPNx-amzn-http-caHTTP, pero
elIoT: puestos de trabajo (p. 84)endpoint no lo hace.
En el puerto 8443 HTTPS y el puerto 443 MQTT con ALPNx-amzn-mqtt-ca,autenticación
personalizada (p. 337)no se puede usar.

Los clientes se conectan a susCuenta de AWSpuntos finales del dispositivo. Consultethe section called
“AWS IoTpuntos finales de servicio y datos del dispositivo” (p. 83)para obtener información sobre cómo
encontrar los puntos de conexión de los dispositivos de tu cuenta.
Note

AWSLos SDK no requieren la URL completa. Solo requieren el nombre de host del punto final,
comopubsub.pymuestra paraAWS IoTSDK de dispositivos para Python enGitHub. Si se pasa la
URL completa tal y como se indica en la siguiente tabla, se puede generar un error, por ejemplo,
un nombre de servidor no válido.

Conexión a AWS IoT Core

Protocolo Punto final o URL

MQTT iot-endpoint

MQTT sobre WSS wss://iot-endpoint/mqtt

HTTPS https://iot-endpoint/topics

Elegir un protocolo para la comunicación del dispositivo

Para la mayoría de las comunicaciones de dispositivos de IoT a través de los terminales del dispositivo,
querrás utilizar los protocolos MQTT o MQTT a través de WSS; sin embargo, los extremos del dispositivo
también admiten HTTPS. En la siguiente tabla se compara cómoAWS IoT Coreusa los dos protocolos para
la comunicación del dispositivo.

88
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

AWS IoTprotocolos de dispositivosside-by-side

Característica MQTT (p. 90) HTTPS (p. 109)

Soporte para publicar/suscribirse Publica y suscríbete Publicar solo

Compatibilidad con SDK AWSSDK de No es compatible con el SDK,

dispositivos (p. 85)admite los pero puedes usar métodos
protocolos MQTT y WSS específicos del idioma para
realizar solicitudes HTTPS

Soporte de calidad de servicio MQTT QoS niveles 0 y Se admite QoS al pasar un

1 (p. 92) parámetro de cadena de
consulta?qos=qosdonde el valor
puede ser 0 o 1. Puede añadir
esta cadena de consulta para
publicar un mensaje con el valor
de QoS que desee.

Se pueden perder mensajes Sí No

cuando el dispositivo estaba
fuera de línea

clientIdsoporte de campo Sí No

Detección de desconexión de Sí No
dispositivos

Comunicaciones seguras Sí. Consulte Protocolos, Sí. Consulte Protocolos,

mapeos de puertos y mapeos de puertos y
autenticación (p. 87). autenticación (p. 87).

Definiciones de temas Aplicación definida Aplicación definida

Formato de datos de mensajes Aplicación definida Aplicación definida

Sobrecarga de protocolo Inferior Más alto

Consumo de energía Inferior Más alto

Límites de duración de la conexión

No se garantiza que las conexiones HTTPS duren más del tiempo necesario para recibir y responder a las
solicitudes.

La duración de la conexión MQTT depende de la función de autenticación que utilice. La siguiente tabla
muestra la duración máxima de la conexión en condiciones ideales para cada función.

Duración de la conexión MQTT mediante función de autenticación

*
Característica Duración máxima

Certificado de cliente X.509 De 1 a 2 semanas

Autenticación personalizada De 1 a 2 semanas

Signature Version 4 Hasta 24 horas

*
No está garantizado

89
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Con los certificados X.509 y la autenticación personalizada, la duración de la conexión no tiene un límite
estricto, pero puede ser de tan solo unos minutos. Las interrupciones de conexión pueden producirse por
varios motivos. La siguiente lista contiene algunos de los motivos más comunes.

• Interrupciones de disponibilidad de Wi-Fi

• Interrupciones en la conexión del proveedor de servicios de Internet (ISP)
• Parches de servicio
• Despliegues de servicios
• Escalado automático de servicios
• Host de servicio no disponible
• Problemas y actualizaciones del balanceador de carga
• Errores del cliente

Sus dispositivos deben implementar estrategias para detectar desconexiones y volver a conectarse.
Para obtener información sobre los eventos de desconexión y orientación sobre cómo gestionarlos,
consulte??? (p. 1268)en??? (p. 1267).

MQTT
MATT(Message Queue Telemetry Transport) es un protocolo de mensajería ligero y ampliamente
adoptado que está diseñado para dispositivos con restricciones.AWS IoT Coreel soporte para MQTT
se basa enEspecificación MQTT v3.1.1y elEspecificación MQTT v5.0, con algunas diferencias,
como se documenta enthe section called “AWS IoTdiferencias con respecto a las especificaciones
de MQTT” (p. 109). Como la última versión del estándar, MQTT 5 presenta varias funciones
clave que hacen que un sistema basado en MQTT sea más sólido, incluidas las nuevas mejoras de
escalabilidad, la mejora de la notificación de errores con las respuestas a los códigos de motivo, los
temporizadores de caducidad de los mensajes y las sesiones y los encabezados de los mensajes de
usuario personalizados. Para obtener más información sobre las funciones de MQTT 5 queAWS IoT
Coresoportes, consulteFunciones compatibles con MQTT 5 (p. 101).AWS IoT Coretambién admite la
comunicación entre versiones de MQTT (MQTT 3 y MQTT 5). Un publicador de MQTT 3 puede enviar un
mensaje de MQTT 3 a un suscriptor de MQTT 5 que recibirá un mensaje de publicación de MQTT 5, y
viceversa.

AWS IoT Coreadmite conexiones de dispositivos que utilizan el protocolo MQTT y el protocolo MQTT
a través de WSS y que se identifican mediante unID de cliente. ElSDK de dispositivos de AWS
IoT (p. 85)admiten ambos protocolos y son las formas recomendadas de conectar dispositivos aAWS
IoT Core. ElAWS IoTLos SDK de dispositivos admiten las funciones necesarias para que los dispositivos
y los clientes se conecten y accedanAWS IoTservicios. Los SDK de dispositivos admiten los protocolos
de autenticación que elAWS IoTlos servicios requieren y los requisitos de ID de conexión que requieren
el protocolo MQTT y los protocolos MQTT sobre WSS. Para obtener información sobre cómo conectarse
aAWS IoTutilizando elAWSSDK de dispositivos y enlaces a ejemplos deAWS IoTen los idiomas admitidos,
consultethe section called “Conectarse con MQTT mediante elAWS IoTSDK de dispositivos” (p. 91).
Para obtener más información sobre los métodos de autenticación y las asignaciones de puertos para los
mensajes MQTT, consulteProtocolos, mapeos de puertos y autenticación (p. 87).

Si bien recomendamos usar elAWS IoTSDK de dispositivos a los que conectarseAWS IoT, no son
obligatorios. Si no utiliza elAWS IoTSin embargo, los SDK de dispositivos deben proporcionar la seguridad
de conexión y comunicación necesaria. Los clientes deben enviar elExtensión TLS de indicación de
nombre de servidor (SNI)en la solicitud de conexión. Se rechazan los intentos de conexión que no incluyan
el SNI. Para obtener más información, consulte Seguridad de transporte en AWS IoT. Clientes que utilizan
usuarios de IAM yAWSlas credenciales para autenticar a los clientes deben proporcionar la información
correctaVersión de firma 4autenticación.

En este tema:

90
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

• Conectarse con MQTT mediante elAWS IoTSDK de dispositivos (p. 91)

• Opciones de calidad de servicio (QoS) de MQTT (p. 92)
• Sesiones persistentes de MQTT (p. 92)
• Mensajes retenidos en MQTT (p. 95)
• Mensajes de MQTT sobre la última voluntad y el testamento (LWT) (p. 100)
• Uso de connectAttributes (p. 100)
• Funciones compatibles con MQTT 5 (p. 101)
• Propiedades de MQTT 5 (p. 104)
• Códigos de motivos MQTT (p. 106)
• AWS IoTdiferencias con respecto a las especificaciones de MQTT (p. 109)

Conectarse con MQTT mediante elAWS IoTSDK de dispositivos

Esta sección contiene enlaces aAWS IoTLos SDK de dispositivos y el código fuente de los programas de
ejemplo que ilustran cómo conectar un dispositivo aAWS IoT. Las aplicaciones de ejemplo enlazadas aquí
muestran cómo conectarse aAWS IoTutilizando el protocolo MQTT y MQTT sobre WSS.
Note

ElAWS IoTLos SDK de dispositivos han publicado un cliente MQTT 5 en la versión preliminar
para desarrolladores. Durante el período de previsualización, es posible que realicemos cambios
incompatibles con versiones anteriores en las API públicas y en los clientes del servicio delAWS
IoTLos SDK de dispositivos siguen utilizando el cliente MQTT 3.1.1.

C++

Uso delAWS IoTSDK de dispositivos C++ para conectar dispositivos

• Código fuente de una aplicación de muestra que muestra un ejemplo de conexión MQTT en C++
• AWS IoTSDK para dispositivos C++ v2 activadoGitHub

Python

Uso delAWS IoTSDK de dispositivos para Python para conectar dispositivos

• Código fuente de una aplicación de muestra que muestra un ejemplo de conexión MQTT en Python
• AWS IoTSDK de dispositivos para Python v2 activadoGitHub

JavaScript

Uso delAWS IoTSDK de dispositivos paraJavaScriptconectar dispositivos

• Código fuente de una aplicación de muestra que muestra un ejemplo de conexión MQTT
enJavaScript
• AWS IoTSDK de dispositivos paraJavaScriptv2 activadoGitHub

Java

Uso delAWS IoTSDK de dispositivos para Java para conectar dispositivos

• Código fuente de una aplicación de muestra que muestra un ejemplo de conexión MQTT en Java

91
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

• AWS IoTSDK de dispositivos para Java v2 activadoGitHub

Embedded C

Uso delAWS IoTSDK de dispositivos para C integrado para conectar dispositivos

Important

Este SDK está destinado a desarrolladores de software integrado con experiencia.

• Código fuente de una aplicación de ejemplo que muestra un ejemplo de conexión MQTT en
Embedded C
• AWS IoTSDK de dispositivos para C integrado activadoGitHub

Opciones de calidad de servicio (QoS) de MQTT

AWS IoTy elAWS IoTLos SDK de dispositivos son compatibles conNiveles de calidad de servicio (QoS)
de MQTT0y1. El protocolo MQTT define un tercer nivel de QoS, el nivel2, peroAWS IoTno lo admite.
Solo el protocolo MQTT admite la función QoS. HTTPS admite QoS al pasar un parámetro de cadena de
consulta?qos=qosdonde el valor puede ser 0 o 1.

Esta tabla describe cómo afecta cada nivel de QoS a los mensajes publicados en y por el intermediario de
mensajes.

Con un nivel de QoS de... El mensaje es... Comentarios

Nivel 0 de QoS Enviado cero o más veces Este nivel debe usarse para los
mensajes que se envían a través
de enlaces de comunicación
confiables o que pueden omitirse
sin problemas.

Nivel 1 de QoS Enviado al menos una vez y, El mensaje no se considera

a continuación, varias veces completo hasta que el remitente
hasta quePUBACKse recibe la reciba unPUBACKrespuesta para
respuesta indicar que la entrega se ha
realizado correctamente.

Sesiones persistentes de MQTT

Las sesiones persistentes almacenan las suscripciones y los mensajes de un cliente, con una calidad de
servicio (QoS) de 1, que el cliente no ha reconocido. Cuando el dispositivo se vuelve a conectar a una
sesión persistente, la sesión se reanuda, las suscripciones se restablecen y los mensajes de suscripción
no confirmados recibidos y almacenados antes de la reconexión se envían al cliente.

El procesamiento de los mensajes almacenados se registra enCloudWatchyCloudWatchRegistros. Para

obtener información sobre las entradas escritas enCloudWatchyCloudWatchRegistros, consulteMétricas
del agente de mensajes (p. 473)yEjemplo de registro (p. 488).

Crear una sesión persistente

En MQTT 3, se crea una sesión persistente de MQTT enviando unCONNECTmensaje y configuración

delcleanSessionmarcar a0. Si no existe ninguna sesión para el cliente que envía elCONNECTmensaje,
se crea una nueva sesión persistente. Si ya existe una sesión para el cliente, el cliente reanuda
la sesión existente. Para crear una sesión limpia, envía unCONNECTenvíe un mensaje y configure

92
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

elcleanSessionmarcar a1, y el corredor no almacenará ningún estado de la sesión cuando el cliente se

desconecte.

En MQTT 5, se gestionan las sesiones persistentes configurando laClean Startbandera ySession

Expiry Interval. Clean Start controla el inicio de la sesión de conexión y el final de la sesión anterior.
Cuando configurasClean Start=1, se crea una sesión nueva y se termina una sesión anterior si existe.
Cuando configurasClean Start=0, la sesión de conexión reanudará una sesión anterior si existe. El
intervalo de caducidad de la sesión controla el final de la sesión de conexión. El intervalo de caducidad
de la sesión especifica el tiempo, en segundos (entero de 4 bytes), que una sesión persistirá tras la
desconexión. ConfiguraciónSession Expiry interval=0hace que la sesión finalice inmediatamente
después de la desconexión. Si el intervalo de caducidad de la sesión no se especifica en el mensaje
CONNECT, el valor predeterminado es 0.

Inicio limpio y caducidad de la sesión en MQTT 5

Valor de la propiedad Descripción

Clean Start= 1 Crea una sesión nueva y termina una sesión anterior si existe.

Clean Start= 0 Reanuda una sesión si existe una sesión anterior.

Session Expiry Persiste una sesión.

Interval> 0

Session Expiry No persiste una sesión.

interval= 0

En MQTT 5, si configuraClean Start=1ySession Expiry Interval=0, esto equivale a una sesión

limpia de MQTT 3. Si configurasClean Start=0ySession Expiry Interval>0, es el equivalente a
una sesión persistente de MQTT 3.
Note

No se admiten sesiones persistentes entre las versiones MQTT (MQTT 3 y MQTT 5). Una sesión
persistente de MQTT 3 no se puede reanudar como una sesión de MQTT 5 y viceversa.

Operaciones durante una sesión persistente

Los clientes utilizan elsessionPresentatributo en la conexión reconocida (CONNACK) mensaje para

determinar si hay una sesión persistente. SisessionPresentes1, existe una sesión persistente
y todos los mensajes almacenados para el cliente se entregan al cliente después de que el cliente
reciba laCONNACK, tal y como se describe enTráfico de mensajes tras la reconexión a una sesión
persistente (p. 93). SisessionPresentes1, el cliente no necesita volver a suscribirse. Sin embargo,
sisessionPresentes0, no hay ninguna sesión persistente y el cliente debe volver a suscribirse a sus
filtros de temas.

Una vez que el cliente se une a una sesión persistente, puede publicar mensajes y suscribirse a los filtros
de temas sin ningún indicador adicional en cada operación.

Tráfico de mensajes tras la reconexión a una sesión persistente

Una sesión persistente representa una conexión continua entre un cliente y un intermediario de mensajes
MQTT. Cuando un cliente se conecta al agente de mensajes mediante una sesión persistente, el agente
de mensajes guarda todas las suscripciones que el cliente realiza durante la conexión. Cuando el cliente
se desconecta, el agente de mensajes almacena los mensajes QoS 1 sin confirmar y los mensajes QoS 1
nuevos publicados en los temas a los que el cliente está suscrito. Los mensajes se almacenan según
el límite de la cuenta. Los mensajes que superen el límite se eliminarán. Para obtener más información
sobre los límites de mensajes persistentes, consulteAWS IoT Corepuntos finales y cuotas. Cuando el

93
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

cliente se vuelve a conectar a su sesión persistente, se restablecen todas las suscripciones y todos los
mensajes almacenados se envían al cliente a una velocidad máxima de 10 mensajes por segundo. En
MQTT 5, si una QoS1 saliente con el intervalo de caducidad del mensaje caduca cuando un cliente está
desconectado, una vez que se reanude la conexión, el cliente no recibirá el mensaje caducado.

Tras la reconexión, los mensajes almacenados se envían al cliente, a una velocidad limitada a 10
mensajes almacenados por segundo, junto con el tráfico de mensajes actual hasta quePublish
requests per second per connectionse ha alcanzado el límite. Dado que la velocidad de
entrega de los mensajes almacenados es limitada, se tardarán varios segundos en entregar todos los
mensajes almacenados si una sesión tiene más de 10 mensajes almacenados que entregar después de la
reconexión.

Finalización de una sesión persistente

Las sesiones persistentes pueden finalizar de las siguientes maneras:

• El tiempo de caducidad de la sesión persistente finaliza. El temporizador de caducidad de la sesión

persistente se inicia cuando el intermediario de mensajes detecta que un cliente se ha desconectado, ya
sea porque el cliente se ha desconectado o porque se ha agotado el tiempo de espera de la conexión.
• El cliente envía unCONNECTmensaje que establece elcleanSessionmarcar a1.

En MQTT 3, el valor predeterminado del tiempo de caducidad de las sesiones persistentes es de una hora,
y esto se aplica a todas las sesiones de la cuenta.

En MQTT 5, puede establecer el intervalo de caducidad de sesión para cada sesión en los paquetes
CONNECT y DISCONNECT.

Para el intervalo de caducidad de la sesión en el paquete DISCONNECT:

• Si la sesión actual tiene un intervalo de caducidad de sesión de 0, no puede establecer el intervalo de

caducidad de sesión en más de 0 en el paquete DISCONNECT.
• Si la sesión actual tiene un intervalo de caducidad de sesión superior a 0 y usted establece el intervalo
de caducidad de sesión en 0 en el paquete DISCONNECT, la sesión finalizará al DISCONNECT.
• De lo contrario, el intervalo de caducidad de la sesión en el paquete DISCONNECT actualizará el
intervalo de caducidad de la sesión actual.

Note

Los mensajes almacenados que esperan ser enviados al cliente al finalizar la sesión se descartan;
sin embargo, se siguen facturando con la tarifa de mensajería estándar, aunque no se hayan
podido enviar. Para obtener más información sobre los precios de los mensajes, consulteAWS IoT
CorePrecios. Puede configurar el intervalo de tiempo de caducidad.

Reconexión después de que haya caducado una sesión persistente

Si un cliente no se vuelve a conectar a su sesión persistente antes de que caduque, la sesión finaliza
y los mensajes almacenados se descartan. Cuando un cliente se vuelve a conectar después de que la
sesión haya expirado con uncleanSessionmarcar a0, el servicio crea una nueva sesión persistente.
Las suscripciones o los mensajes de la sesión anterior no están disponibles para esta sesión porque se
descartaron al expirar la sesión anterior.

Cargos por mensajes de sesión persistentes

Los mensajes se cargan a tu cargoCuenta de AWScuando el intermediario de mensajes envía un mensaje

a un cliente o a una sesión persistente sin conexión. Cuando un dispositivo desconectado con una sesión
persistente se vuelve a conectar y reanuda su sesión, los mensajes almacenados se envían al dispositivo

94
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

y se cargan nuevamente a tu cuenta. Para obtener más información sobre los precios de los mensajes,
consulteAWS IoT Coreprecios - Mensajería.

El tiempo de caducidad predeterminado de la sesión persistente de una hora se puede aumentar mediante
el proceso de aumento del límite estándar. Tenga en cuenta que aumentar el tiempo de caducidad de la
sesión podría aumentar los cargos por mensajes, ya que el tiempo adicional podría permitir almacenar más
mensajes para el dispositivo sin conexión y esos mensajes adicionales se cargarían a su cuenta según
la tarifa de mensajería estándar. El tiempo de caducidad de la sesión es aproximado y una sesión puede
persistir hasta 30 minutos más que el límite de la cuenta; sin embargo, una sesión no será inferior al límite
de la cuenta. Para obtener más información sobre los límites de sesión, consulteAWSCuotas de servicio.

Mensajes retenidos en MQTT

AWS IoT Coreadmite el indicador RETAIN descrito en el protocolo MQTT. Cuando un cliente
establece el indicador RETAIN en un mensaje MQTT que publica,AWS IoT Coreguarda el mensaje.
A continuación, se puede enviar a los nuevos suscriptores y se puede recuperar llamando
alGetRetainedMessageoperación, y se ve enAWS IoTconsola.

Ejemplos de uso de mensajes retenidos en MQTT

• Como mensaje de configuración inicial

Los mensajes retenidos de MQTT se envían a un cliente después de que el cliente se suscriba a un
tema. Si desea que todos los clientes que se suscriban a un tema reciban el mensaje retenido de
MQTT inmediatamente después de su suscripción, puede publicar un mensaje de configuración con
el indicador RETAIN activado. Los clientes que se suscriben también reciben actualizaciones de esa
configuración cada vez que se publica un nuevo mensaje de configuración.
• Como último mensaje de estado conocido

Los dispositivos pueden configurar el indicador RETAIN en los mensajes de estado actual para queAWS
IoT Corelos salvará. Cuando las aplicaciones se conecten o vuelvan a conectarse, pueden suscribirse a
este tema y obtener el último estado del que se informó inmediatamente después de suscribirse al tema
del mensaje conservado. De esta forma, pueden evitar tener que esperar hasta el siguiente mensaje del
dispositivo para ver el estado actual.

En esta sección:
• Tareas comunes con mensajes de MQTT retenidos enAWS IoT Core (p. 95)
• Mensajes de facturación y retenidos (p. 97)
• Comparación de los mensajes retenidos de MQTT y las sesiones persistentes de MQTT (p. 98)
• MQTT retuvo mensajes yAWS IoTSombras del dispositivo (p. 99)

Tareas comunes con mensajes de MQTT retenidos enAWS IoT Core

AWS IoT Coreguarda los mensajes MQTT con el marcador RETAIN establecido. Estosmensajes
retenidosse envían a todos los clientes que se han suscrito al tema, como un mensaje normal de MQTT, y
también se almacenan para enviarlos a los nuevos suscriptores del tema.

Los mensajes retenidos de MQTT requieren acciones políticas específicas para autorizar a los clientes
a acceder a ellos. Para ver ejemplos del uso de políticas de mensajes retenidos, consulteEjemplos de
políticas de mensajes retenidos (p. 384).

En esta sección se describen las operaciones comunes que implican la retención de mensajes.

• Crear un mensaje conservado

El cliente determina si un mensaje se conserva cuando publica un mensaje MQTT. Los clientes pueden
configurar el indicador RETAIN al publicar un mensaje mediante unSDK de dispositivos (p. 1489).

95
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Las aplicaciones y los servicios pueden establecer el indicador RETAIN cuando utilizan
elPublishacciónpara publicar un mensaje MQTT.

Solo se conserva un mensaje por nombre de tema. Un mensaje nuevo con el marcador RETAIN
establecido publicado en un tema reemplaza cualquier mensaje retenido existente que se haya enviado
anteriormente al tema.

NOTA:No puedes publicar en untema reservado (p. 115)con el indicador RETAIN activado.
• Suscribirse a un tema de mensaje conservado

Los clientes se suscriben a los temas de mensajes retenidos como lo harían con cualquier otro tema
de mensajes de MQTT. Los mensajes retenidos que se reciben al suscribirse a un tema de mensajes
retenidos tienen el indicador RETAIN activado.

Los mensajes retenidos se eliminan deAWS IoT Corecuando un cliente publica un mensaje retenido con
una carga de mensajes de 0 bytes en el tema del mensaje retenido. Los clientes que se hayan suscrito
al tema del mensaje conservado también recibirán el mensaje de 0 bytes.

Suscribirse a un filtro de temas comodín que incluye un tema de mensaje retenido permite al cliente
recibir los mensajes posteriores publicados en el tema del mensaje retenido, pero no entrega el mensaje
retenido al suscribirse.

NOTA:Para recibir un mensaje retenido al suscribirse, el filtro de temas de la solicitud de suscripción

debe coincidir exactamente con el tema del mensaje retenido.

Los mensajes retenidos que se reciben al suscribirse a un tema de mensajes retenidos tienen el
indicador RETAIN activado. Los mensajes retenidos que recibe un cliente suscriptor después de la
suscripción no se conservan.
• Recuperar un mensaje retenido

Los mensajes retenidos se entregan a los clientes automáticamente cuando se suscriben al tema con
el mensaje retenido. Para que un cliente reciba el mensaje retenido al suscribirse, debe suscribirse al
nombre de tema exacto del mensaje retenido. Al suscribirse a un filtro de temas comodín que incluye un
tema de mensaje retenido, el cliente recibe los mensajes posteriores publicados en el tema del mensaje
retenido, pero no entrega el mensaje retenido al suscribirse.

Los servicios y las aplicaciones pueden enumerar y recuperar los mensajes retenidos
llamandoListRetainedMessagesyGetRetainedMessage.

No se impide que un cliente publique mensajes en un tema de mensajes conservadosinconfigurar el

indicador RETAIN. Esto podría provocar resultados inesperados, como que el mensaje retenido no
coincida con el mensaje recibido al suscribirse al tema.

Con MQTT 5, si un mensaje retenido tiene establecido el intervalo de caducidad del mensaje y el
mensaje retenido caduca, el nuevo suscriptor que se suscriba a ese tema no recibirá el mensaje retenido
una vez que la suscripción se haya realizado correctamente.
• Listar temas de mensajes retenidos

Puede enumerar los mensajes retenidos llamandoListRetainedMessagesy los mensajes retenidos

se pueden ver enAWS IoTconsola.
• Obtener detalles de mensajes retenidos

Puede obtener los detalles de los mensajes retenidos llamandoGetRetainedMessagey pueden

consultarse enAWS IoTconsola.
• Conservar un mensaje de testamento

MATTVoluntadmensajesque se crean cuando un dispositivo se conecta se pueden conservar

configurando laWill Retainbandera en elConnect Flag bitscampo.

96
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

• Eliminar un mensaje retenido

Los dispositivos, las aplicaciones y los servicios pueden eliminar un mensaje retenido publicando un
mensaje con el marcador RETAIN establecido y una carga de mensajes vacía (0 bytes) en el nombre del
tema del mensaje retenido que se va a eliminar. Estos mensajes eliminan el mensaje retenido deAWS
IoT Core, se envían a los clientes que tienen una suscripción al tema, pero no son retenidos porAWS IoT
Core.

Los mensajes retenidos también se pueden eliminar de forma interactiva accediendo al mensaje retenido
enAWS IoTconsola. Mensajes retenidos que se eliminan mediante elAWS IoTconsolatambién envía un
mensaje de 0 bytes a los clientes que se hayan suscrito al tema del mensaje retenido.

Los mensajes retenidos no se pueden restaurar después de eliminarlos. Un cliente tendría que publicar
un nuevo mensaje conservado para reemplazar el mensaje eliminado.
• Depuración y solución de problemas de mensajes retenidos

ElAWS IoTconsolaproporciona varias herramientas para ayudarle a solucionar problemas con los
mensajes retenidos:
• ElMensajes retenidospágina

ElMensajes retenidospágina en elAWS IoTla consola proporciona una lista paginada de los mensajes
retenidos que su cuenta ha almacenado en la región actual. Desde esta página, puede:
• Consulte los detalles de cada mensaje retenido, como la carga útil del mensaje, la QoS y la hora en
que se recibió.
• Actualiza el contenido de un mensaje conservado.
• Eliminar un mensaje retenido.
• Elcliente de prueba MQTT

Elcliente de prueba MQTTpágina en elAWS IoTla consola puede suscribirse y publicar temas de
MQTT. La opción de publicación le permite configurar el indicador RETAIN en los mensajes que
publique para simular el comportamiento de sus dispositivos.

Algunos resultados inesperados podrían deberse a estos aspectos de la forma en que se implementan
los mensajes retenidos enAWS IoT Core.
• Límites de mensajes retenidos

Cuando una cuenta ha almacenado el número máximo de mensajes retenidos,AWS IoT Coredevuelve
una respuesta restringida a los mensajes publicados con RETAIN configurado y a cargas superiores a
0 bytes hasta que se eliminen algunos mensajes retenidos y el recuento de mensajes retenidos caiga
por debajo del límite.
• Orden de entrega de mensajes retenida

La secuencia de entrega de mensajes retenidos y mensajes suscritos no está garantizada.

Mensajes de facturación y retenidos

Publicar mensajes con el indicador RETAIN establecido desde un cliente, medianteAWS IoTconsola o
llamandoPublishincurre en los cargos de mensajería adicionales descritos enAWS IoT Coreprecios -
Mensajería.

Recuperación de mensajes retenidos por un cliente, medianteAWS IoTconsola o

llamandoGetRetainedMessageincurre en cargos de mensajería además de los cargos normales de uso
de la API. Los cargos adicionales se describen enAWS IoT Coreprecios - Mensajería.

MATTVoluntadmensajesque se publican cuando un dispositivo se desconecta inesperadamente conllevan

los cargos de mensajería descritos enAWS IoT Coreprecios - Mensajería.
97
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Para obtener más información sobre los costos de mensajería, consulteAWS IoT Coreprecios - Mensajería.

Comparación de los mensajes retenidos de MQTT y las sesiones persistentes de MQTT

Los mensajes retenidos y las sesiones persistentes son características estándar de MQTT que permiten
a los dispositivos recibir mensajes publicados sin conexión. Los mensajes retenidos se pueden publicar
desde sesiones persistentes. En esta sección se describen los aspectos clave de estas funciones y cómo
funcionan juntas.

Mensajes retenidos Sesiones persistentes

Características principales Los mensajes retenidos se Las sesiones persistentes son

pueden usar para configurar o útiles para los dispositivos que
notificar a grupos grandes de tienen conectividad intermitente
dispositivos después de que se y pueden perder varios mensajes
conecten. importantes.

Los mensajes retenidos también Los dispositivos pueden

se pueden usar cuando desee conectarse con una sesión
que los dispositivos reciban solo persistente para recibir los
el último mensaje publicado mensajes que se envíen sin
en un tema después de una conexión.
reconexión.

Ejemplos Los mensajes retenidos pueden Los dispositivos que se conectan

proporcionar a los dispositivos a través de una red móvil con
información de configuración conectividad intermitente pueden
sobre su entorno cuando se utilizar sesiones persistentes
conectan. La configuración inicial para evitar perder mensajes
podría incluir una lista de otros importantes que se envían
temas de mensajes a los que cuando el dispositivo está fuera
debe suscribirse o información de la cobertura de la red o
sobre cómo debe configurar su cuando necesita apagar la radio
zona horaria local. móvil.

Mensajes recibidos en la Tras suscribirse a un tema con Tras suscribirse a un tema sin
suscripción inicial a un tema un mensaje retenido, se recibe el conservar ningún mensaje, no se
mensaje retenido más reciente. recibe ningún mensaje hasta que
se publique uno sobre el tema.

Temas suscritos después de la Sin una sesión persistente, el Los temas suscritos se restauran
reconexión cliente debe suscribirse a los tras la reconexión.
temas después de la reconexión.

Mensajes recibidos después de Tras suscribirse a un tema con Todos los mensajes publicados
la reconexión un mensaje retenido, se recibe el con un QOS = 1 y a los que se
mensaje retenido más reciente. haya suscrito con un QOS =1
mientras el dispositivo estaba
desconectado se envían después
de que el dispositivo se vuelva a
conectar.

Vencimiento de datos/sesión En MQTT 3, los mensajes Las sesiones persistentes

retenidos no caducan. Se caducan si el cliente no se vuelve
almacenan hasta que se a conectar dentro del período
sustituyan o eliminen. En MQTT de tiempo de espera. Cuando
5, los mensajes retenidos caduca una sesión persistente,
caducan después del intervalo de se eliminan las suscripciones

98
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Mensajes retenidos Sesiones persistentes

caducidad de mensajes que haya y los mensajes guardados del
establecido. Para obtener más cliente que se publicaron con un
información, consulteCaducidad QOS = 1 y a los que se suscribió
del mensaje (p. 101). con un QOS =1 mientras el
dispositivo estaba desconectado.
Los mensajes caducados no se
entregarán. Para obtener más
información sobre la caducidad
de las sesiones con sesiones
persistentes, consultethe section
called “Sesiones persistentes de
MQTT” (p. 92).

Para obtener información sobre las sesiones persistentes, consultethe section called “Sesiones
persistentes de MQTT” (p. 92).

Con los mensajes retenidos, el cliente de publicación determina si un mensaje debe conservarse y
entregarse a un dispositivo después de que se conecte, si ha tenido una sesión anterior o no. El editor
elige almacenar un mensaje y el mensaje almacenado se entrega a todos los clientes actuales y futuros
que se suscriban con suscripciones de QoS 0 o QoS 1. Los mensajes retenidos guardan solo un mensaje
sobre un tema determinado a la vez.

Cuando una cuenta ha almacenado el número máximo de mensajes retenidos,AWS IoT Coredevuelve una
respuesta restringida a los mensajes publicados con RETAIN configurado y a cargas superiores a 0 bytes
hasta que se eliminen algunos mensajes retenidos y el recuento de mensajes retenidos caiga por debajo
del límite.

MQTT retuvo mensajes yAWS IoTSombras del dispositivo

Tanto los mensajes retenidos como las sombras de dispositivos retienen datos de un dispositivo, pero se
comportan de manera diferente y tienen propósitos diferentes. En esta sección se describen sus similitudes
y diferencias.

Mensajes retenidos Sombras del dispositivo

La carga útil del mensaje tiene Según lo definido en la AWS IoTadmite una estructura
una estructura o esquema implementación. MQTT no de datos específica.
predefinidos especifica una estructura o
esquema para la carga de sus
mensajes.

La actualización de la carga útil Al publicar un mensaje Actualizar un dispositivo produce

de mensajes genera mensajes conservado, se envía el mensaje Shadowactualizar los mensajes
de eventos a los clientes suscritos, pero que describen el cambio.
no se generan mensajes de
actualización adicionales.

Las actualizaciones de mensajes Los mensajes retenidos no se Los documentos de Device

están numeradas numeran automáticamente. Shadow tienen números de
versión y marcas de tiempo
automáticos.

La carga útil del mensaje está Los mensajes retenidos no se Las sombras del dispositivo
adjunta a un recurso de cosa adjuntan a ningún recurso. están asociadas a un recurso de
la cosa.

99
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Mensajes retenidos Sombras del dispositivo

Actualización de elementos Los elementos individuales del Los elementos individuales de un

individuales de la carga útil del mensaje no se pueden cambiar documento de Device Shadow se
mensaje sin actualizar toda la carga útil pueden actualizar sin necesidad
del mensaje. de actualizar todo el documento
de Device Shadow.

El cliente recibe los datos del El cliente recibe Los clientes pueden suscribirse
mensaje al suscribirse automáticamente un mensaje a las actualizaciones de Device
retenido después de suscribirse Shadow, pero deben solicitar
a un tema con un mensaje el estado actual de forma
retenido. deliberada.

Indexación y capacidad de Los mensajes retenidos no se La indexación de flotas indexa

búsqueda indexan para la búsqueda. los datos de Device Shadow para
su búsqueda y agregación.

Mensajes de MQTT sobre la última voluntad y el testamento (LWT)

Last Will and Testament (LWT) es una característica de MQTT. Con LWT, los clientes pueden especificar
un mensaje que el corredor publicará en un tema definido por el cliente y lo enviará a todos los clientes
que se suscribieron al tema cuando se produzca una desconexión no iniciada. El mensaje que especifican
los clientes se denomina mensaje LWT o mensaje de testamento, y el tema que definen los clientes se
denomina tema de testamento. Puede especificar un mensaje LWT cuando un dispositivo se conecte al
corredor. Estos mensajes se pueden conservar configurando laWill Retainbandera en elConnect
Flag bitscampo durante la conexión. Por ejemplo, si elWill Retainla bandera está configurada en1,
se almacenará un mensaje de testamento en el corredor en el tema del testamento asociado. Para obtener
más información, consulteMensajes de testamento.

El corredor almacenará los mensajes del testamento hasta que se produzca una desconexión no iniciada.
Cuando eso suceda, el corredor publicará los mensajes a todos los clientes que se suscribieron al Will
Topic para notificar la desconexión. Si el cliente se desconecta del corredor mediante una desconexión
iniciada por el cliente mediante el mensaje MQTT DISCONNECT, el corredor no publicará los mensajes
de LWT almacenados. En todos los demás casos, se enviarán los mensajes LWT. Para obtener una
lista completa de los escenarios de desconexión en los que el corredor enviará los mensajes de LWT,
consulteConectar o desconectar eventos.

Uso de connectAttributes
ConnectAttributesle permiten especificar los atributos que desea usar en su mensaje de conexión en
sus políticas de IAM, comoPersistentConnectyLastWill. ConConnectAttributes, puedes crear
políticas que no den a los dispositivos acceso a las nuevas funciones de forma predeterminada, lo que
puede resultar útil si un dispositivo se ve comprometido.

connectAttributes es compatible con las siguientes características:

PersistentConnect

Utilice elPersistentConnectfunción para guardar todas las suscripciones que el cliente realiza
durante la conexión cuando se interrumpe la conexión entre el cliente y el corredor.
LastWill

Utilice elLastWillfunción para publicar un mensaje enLastWillTopiccuando un cliente se

desconecta inesperadamente.

100
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

De forma predeterminada, su política tiene una conexión no persistente y no se transfieren atributos para
esta conexión. Debe especificar una conexión persistente en su política de IAM si desea tener una.

ParaConnectAttributesejemplos, consulteEjemplos de políticas de conexión (p. 363).

Funciones compatibles con MQTT 5

AWS IoT Corela compatibilidad con MQTT 5 se basa enEspecificación MQTT v5.0con algunas diferencias,
tal como se documenta enthe section called “AWS IoTdiferencias con respecto a las especificaciones de
MQTT” (p. 109).

AWS IoT Coreadmite las siguientes funciones de MQTT 5:

• Suscripciones compartidas (p. 101)
• Inicio limpio y caducidad de la sesión (p. 103)
• Código de motivo en todos los ACK (p. 103)
• Alias de temas (p. 103)
• Caducidad del mensaje (p. 103)
• Otras funciones de MQTT 5 (p. 104)

Suscripciones compartidas

AWS IoT Coreadmite suscripciones compartidas 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. Las suscripciones compartidas pueden
equilibrar de manera efectiva la carga de los mensajes MQTT entre varios suscriptores. Por ejemplo,
supongamos que tiene 1000 dispositivos que publican sobre el mismo tema y 10 aplicaciones de fondo
que procesan esos mensajes. En ese caso, las aplicaciones de fondo pueden suscribirse al mismo
tema y cada una recibirá de forma aleatoria los mensajes publicados por los dispositivos en el tema
compartido. Esto es efectivamente «compartir» la carga de esos mensajes. Las suscripciones compartidas
también permiten una mayor resiliencia. Cuando alguna aplicación de backend se desconecta, el corredor
distribuye la carga entre los suscriptores restantes del grupo.

Para utilizar las suscripciones compartidas, los clientes se suscriben a una suscripción compartidafiltro de
temasde la siguiente manera:

$share/{ShareName}/{TopicFilter}

• $sharees una cadena literal para indicar el filtro de temas de una suscripción compartida, que debe
empezar por$share.
• {ShareName}es una cadena de caracteres para especificar el nombre compartido que utiliza un grupo
de suscriptores. El filtro de temas de una suscripción compartida debe contener unShareNamey será
seguido por el/personaje. El{ShareName}no debe incluir los siguientes caracteres:/,+, o#. El tamaño
máximo para{ShareName}es de 128 bytes.
• {TopicFilter}sigue lo mismofiltro de temassintaxis como suscripción no compartida. El tamaño
máximo para{TopicFilter}es de 256 bytes.
• Las dos barras obligatorias (/) para$share/{ShareName}/{TopicFilter}no están incluidos en
elNúmero máximo de barras en el tema y el filtro de temaslímite.

Suscripciones que tienen lo mismo{ShareName}/{TopicFilter}pertenecen al mismo grupo de

suscripciones compartidas. Puede crear varios grupos de suscripciones compartidas y no superar elLímite
de suscripciones compartidas por grupo. Para obtener más información, consulteAWS IoT Corepuntos
finales y cuotasdesde elAWSReferencia general.

En las tablas siguientes se comparan las suscripciones no compartidas y las suscripciones compartidas:

101
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Suscripción Descripción Ejemplos de filtros de

temas

Suscripciones no Cada cliente crea una suscripción independiente para

sports/tennis
compartidas recibir los mensajes publicados. Cuando se publica sports/#
un mensaje en un tema, todos los suscriptores de ese
tema reciben una copia del mensaje.

Suscripciones Varios clientes pueden compartir una suscripción

$share/consumer/
compartidas a un tema y solo un cliente recibirá los mensajes sports/tennis
publicados sobre ese tema de forma aleatoria. $share/consumer/
sports/#

Flujo de suscripciones Flujo de suscripciones

no compartidas compartidas

Notas importantes sobre el uso de suscripciones compartidas

• Si falla un intento de publicación para un suscriptor de QoS0, no se volverá a intentar y el mensaje se

eliminará.
• Cuando se produce un error al intentar publicar a un suscriptor de QoS1 con una sesión limpia, el
mensaje se enviará a otro suscriptor del grupo para que lo intente varias veces. Los mensajes que no se
entreguen después de todos los reintentos se eliminarán.
• Cuando se intenta publicar a un suscriptor de QoS1 consesiones persistentes (p. 92)se produce un
error porque el suscriptor no está conectado, los mensajes no se pondrán en cola y se enviarán a otro
suscriptor del grupo. Los mensajes que no se entreguen después de todos los reintentos se eliminarán.
• Las suscripciones compartidas no recibenmensajes retenidos.
• Cuando las suscripciones compartidas contienen caracteres comodín (# o +), es posible que haya
varias suscripciones compartidas coincidentes con un tema. Si eso ocurre, el intermediario de mensajes
copia el mensaje de publicación y lo envía a un cliente aleatorio en cada suscripción compartida
coincidente. El comportamiento comodín de las suscripciones compartidas se puede explicar en el
siguiente diagrama.

102
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

En este ejemplo, hay tres suscripciones compartidas que coinciden con el tema de publicación de
MQTTsports/tennis. El intermediario de mensajes copia el mensaje publicado y lo envía a un cliente
aleatorio de cada grupo coincidente.

El cliente 1 y el cliente 2 comparten la suscripción:$share/consumer1/sports/tennis

El cliente 3 y el cliente 4 comparten la suscripción:$share/consumer1/sports/#

El cliente 5 y el cliente 6 comparten la suscripción:$share/consumer2/sports/tennis

Para obtener más información sobre los límites de las suscripciones compartidas, consulteAWS IoT
Corepuntos finales y cuotasdesde elAWSReferencia general. Para probar las suscripciones compartidas
mediante elAWS IoTCliente MQTT en elAWS IoTconsola, consulte??? (p. 72). Para obtener más
información sobre las suscripciones compartidas, consulteSuscripciones compartidasde la especificación
MQTTV5.0.

Inicio limpio y caducidad de la sesión

Puede utilizar Clean Start y Session Expiry para gestionar las sesiones persistentes con más flexibilidad.
Un indicador de inicio limpio indica si la sesión debe iniciarse sin utilizar una sesión existente. El intervalo
de caducidad de la sesión indica cuánto tiempo se debe conservar la sesión después de una desconexión.
El intervalo de caducidad de la sesión se puede modificar en el momento de la desconexión. Para obtener
más información, consulte the section called “Sesiones persistentes de MQTT” (p. 92).

Código de motivo en todos los ACK

Puede depurar o procesar los mensajes de error más fácilmente mediante los códigos de motivo. El
intermediario de mensajes devuelve los códigos de motivo en función del tipo de interacción con el
intermediario (suscripción, publicación, confirmación). Para obtener más información, consulteCódigos
de motivos MQTT (p. 106). Para obtener una lista completa de los códigos de motivo de MQTT,
consulteEspecificación MQTT v5.

Alias de temas
Puede sustituir el nombre de un tema por un alias de tema, que es un entero de dos bytes. El uso de
alias de temas puede optimizar la transmisión de los nombres de los temas para reducir potencialmente
los costos de datos en los servicios de datos medidos.AWS IoT Coretiene un límite predeterminado de
8 alias de temas. Para obtener más información, consulteAWS IoT Corepuntos finales y cuotasdesde
elAWSReferencia general.

Caducidad del mensaje

Puede añadir valores de caducidad de los mensajes a los mensajes publicados. Estos valores representan
el intervalo de caducidad del mensaje en segundos. Si los mensajes no se han enviado a los suscriptores
dentro de ese intervalo, el mensaje caducará y se eliminará. Si no configuras el valor de caducidad del
mensaje, el mensaje no caducará.

En la salida, el suscriptor recibirá un mensaje con el tiempo restante restante en el intervalo de caducidad.
Por ejemplo, si un mensaje de publicación entrante tiene una caducidad de 30 segundos y se envía al
suscriptor transcurridos 20 segundos, el campo de caducidad del mensaje se actualizará a 10. Es posible
que el mensaje recibido por el suscriptor tenga un MEI actualizado de 0. Esto se debe a que tan pronto
como el tiempo restante sea de 999 ms o menos, se actualizará a 0.

EnAWS IoT Core, el intervalo mínimo de caducidad de los mensajes es 1. Si el intervalo se establece en 0
desde el lado del cliente, se ajustará a 1. El intervalo máximo de caducidad de los mensajes es 604800 (7
días). Los valores superiores a este se ajustarán al valor máximo.

En la comunicación entre versiones, el comportamiento de caducidad del mensaje lo decide la versión

MQTT del mensaje de publicación entrante. Por ejemplo, un mensaje con caducidad de mensaje enviado

103
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

por una sesión conectada a través de MQTT5 puede caducar para los dispositivos suscritos a sesiones
de MQTT3. La siguiente tabla muestra cómo la caducidad de los mensajes admite los siguientes tipos de
mensajes de publicación:

Publicar tipo de Intervalo de caducidad de mensajes

mensaje

Publicación Si un servidor no entrega el mensaje dentro del tiempo especificado, el mensaje

regular caducado se eliminará y el suscriptor no lo recibirá. Esto incluye situaciones como
cuando un dispositivo no envía sus mensajes de QoS 1.

Retener Si un mensaje retenido caduca y un cliente nuevo se suscribe al tema, el cliente no

recibirá el mensaje en el momento de la suscripción.

Ultimo El intervalo para los mensajes de última voluntad comienza cuando el cliente se
testamento desconecta y el servidor intenta entregar el mensaje de última voluntad a sus
suscriptores.

Mensajes en Si una QoS1 saliente con intervalo de caducidad de mensajes caduca cuando un
cola cliente está desconectado, después desesión persistente (p. 92)se reanuda, el
cliente no recibirá el mensaje caducado.

Otras funciones de MQTT 5

Desconexión del servidor

Cuando se produce una desconexión, el servidor puede enviar de forma proactiva al cliente un mensaje de
DESCONEXIÓN para notificar el cierre de la conexión con un código de motivo de la desconexión.

Solicitud/respuesta

Los editores pueden solicitar que el destinatario envíe una respuesta a un tema especificado por el editor
en el momento de la recepción.

Tamaño máximo de paquete

El cliente y el servidor pueden especificar de forma independiente el tamaño máximo de paquete que
admiten.

Formato de carga y tipo de contenido

Puede especificar el formato de carga (binario, texto) y el tipo de contenido cuando se publique un
mensaje. Se reenvían al receptor del mensaje.

Propiedades de MQTT 5
Las propiedades de MQTT 5 son adiciones importantes al estándar MQTT para soportar las nuevas
funciones de MQTT 5, como la caducidad de la sesión y el patrón de solicitud/respuesta. EnAWS IoT Core,
puedes crearreglasque puede reenviar las propiedades de los mensajes salientes o utilizarPublicación
HTTPpara publicar mensajes MQTT con algunas de las nuevas propiedades.

La siguiente tabla muestra todas las propiedades de MQTT 5 queAWS IoT Coresoportes.

Propiedad Descripción Input Paquete

type

Indicador de Un valor booleano que indica si la carga está Byte PUBLICAR, CONECTAR
formato de formateada como UTF-8.
carga

104
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Propiedad Descripción Input Paquete

type

Content Type Cadena UTF-8 que describe el contenido de la Cadena PUBLICAR, CONECTAR
carga. UTF-8

Tema de Cadena UTF-8 que describe el tema en el que Cadena PUBLICAR, CONECTAR
respuesta el receptor debe publicar como parte del flujo UTF-8
de solicitud-respuesta. El tema no debe tener
caracteres comodín.

Datos de Datos binarios utilizados por el remitente del Binario PUBLICAR, CONECTAR
correlación mensaje de solicitud para identificar a qué
solicitud se dirige el mensaje de respuesta.

Propiedad de Un par de cadenas UTF-8. Esta propiedad Par CONECTAR, PUBLICAR,

usuario puede aparecer varias veces en un paquete. Los de Will Properties,
receptores recibirán los pares clave-valor en el cadenasSUSCRIBIRSE,
mismo orden en que se enviaron. UTF-8 DESCONECTARSE,
CANCELAR
SUSCRIPCIÓN

Intervalo de Un entero de 4 bytes que representa el intervalo Entero PUBLICAR, CONECTAR

caducidad de de caducidad del mensaje en segundos. Si está de 4
mensajes ausente, el mensaje no caduca. bytes

Intervalo de Un entero de 4 bytes que representa el intervalo Entero CONECTAR,

caducidad de de caducidad de la sesión en segundos.AWS de 4 CONECTAR,
sesión IoT Coreadmite un máximo de 7 días, con un bytes DESCONECTAR
máximo predeterminado de una hora. Si el valor
que has establecido supera el máximo de tu
cuenta,AWS IoT Coredevolverá el valor ajustado
en el CONNACK.

Identificador Un ID de cliente aleatorio generado porAWS IoT Cadena CHIVATO

de cliente Corecuando los dispositivos no especifican un UTF-8
asignado ID de cliente. El ID de cliente aleatorio debe ser
un identificador de cliente nuevo que no utilice
ninguna otra sesión gestionada actualmente por
el corredor.

Servidor Keep Un entero de 2 bytes que representa el tiempo de Entero CHIVATO

Alive mantenimiento de vida asignado por el servidor. de 2
El servidor desconectará al cliente si el cliente bytes
permanece inactivo durante más tiempo que el
de mantenimiento.

Solicitar Un valor booleano que indica si la cadena de Byte CONNECT

información motivo o las propiedades del usuario se envían
sobre el en caso de errores.
problema

Reciba el Un entero de 2 bytes que representa el número Entero CONECTAR, CONECTAR

máximo máximo de paquetes PUBLISH QOS > 0 que se de 2
pueden enviar sin recibir un PUBACK. bytes

Tema Alias Este valor indica el valor más alto que Entero CONECTAR, CONECTAR
Maximum se aceptará como alias de tema. El valor de 2
predeterminado es 0. bytes

105
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Propiedad Descripción Input Paquete

type

QoS máxima El valor máximo de QoS queAWS IoT Byte CHIVATO

Coresoportes. El valor predeterminado es 1.AWS
IoT Coreno admite QoS2.

Retener Un valor booleano que indica siAWS IoT Coreel Byte CHIVATO
disponible corredor de mensajes admite los mensajes
retenidos. El valor predeterminado es 1.

Tamaño El tamaño máximo de paquete queAWS IoT Entero CONECTAR, CONECTAR

máximo de Coreacepta y envía. No puede superar los 128 de 4
paquete KB. bytes

Suscripción Un valor booleano que indica siAWS IoT CoreEl Byte CHIVATO
a Wildcard corredor de mensajes admite la suscripción
disponible Wildcard disponible. El valor predeterminado es
1.

Identificador Un valor booleano que indica siAWS IoT Coreel Byte CHIVATO
de suscripción corredor de mensajes admite el identificador de
disponible suscripción disponible. El valor predeterminado
es 0.

Códigos de motivos MQTT

MQTT 5 introduce una mejora en la notificación de errores con respuestas de código de motivo.AWS
IoT Corepuede devolver códigos de motivo que incluyen, entre otros, los siguientes agrupados
por paquetes. Para obtener una lista completa de los códigos de motivo compatibles con MQTT 5,
consulteEspecificaciones de MQTT 5.

Códigos de motivos de CONNACK

Valor HexágonoNombre del código Descripción

de motivo

0 0x00 Correcto Se acepta la conexión.

128 0x80 Error no El servidor no desea revelar el motivo del error o no se aplica
especificado ninguno de los otros códigos por los que se aplica.

133 0x85 Identificador de El identificador del cliente es una cadena válida, pero el servidor
cliente no válido no lo permite.

134 0x86 Nombre de usuario El servidor no acepta el nombre de usuario ni la contraseña

o contraseña especificados por el cliente.
incorrectos

135 0x87 No autorizado El cliente no está autorizado a conectarse.

144 0x90 Nombre de tema El nombre del tema del testamento está formado correctamente,
no válido pero el servidor no lo acepta.

151 0x97 Cuota excedida Se ha superado un límite impuesto administrativo o de

implementación.

155 0x9B No se admite QoS El servidor no admite la QoS establecida en Will QoS.

106
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Códigos de motivos de PUBACK

Valor Hexágono Nombre del Descripción

código de motivo

0 0x00 Correcto Se acepta el mensaje. Continúa la publicación del mensaje de

QoS 1.

128 0x80 Error no El destinatario no acepta la publicación, pero no quiere revelar

especificado el motivo o no coincide con ninguno de los otros valores.

135 0x87 No autorizado La PUBLICACIÓN no está autorizada.

144 0x90 Nombre de tema El nombre del tema no tiene un formato incorrecto, pero el
no válido cliente o el servidor no lo aceptan.

145 0x91 Identificador de El identificador del paquete ya está en uso. Esto podría indicar
paquete en uso una discrepancia en el estado de la sesión entre el cliente y el
servidor.

151 0x97 Cuota excedida Se ha superado un límite impuesto administrativo o de

implementación.

Códigos de motivo de DESCONEXIÓN

Valor Hexágono Nombre del Descripción

código de motivo

129 0x81 Paquete mal El paquete recibido no cumple con esta especificación.
formado

130 0x82 Error de Se recibió un paquete inesperado o fuera de servicio.

protocolo

135 0x87 No autorizado La solicitud no está autorizada.

139 0x8B El servidor se El servidor se está apagando.

está apagando

141 0x8D Tiempo de La conexión se cierra porque no se ha recibido ningún paquete

espera de Keep durante 1,5 veces el tiempo de Keep Alive.
Alive

142 0x8E Sesión Se ha conectado otra conexión con el mismo ClientID, lo que
interrumpida hace que esta conexión se cierre.

143 0x8F Filtro de tema no El filtro de temas está configurado correctamente, pero el
válido servidor no lo acepta.

144 0x90 Nombre de tema El nombre del tema tiene el formato correcto, pero este cliente
no válido o servidor no lo acepta.

147 0x93 Se ha superado El cliente o el servidor ha recibido más de la publicación

el máximo de Receive Maximum para la que no ha enviado PUBACK ni
recepción PUBCOMP.

148 0x94 Alias de tema no El cliente o servidor ha recibido un paquete PUBLISH que
válido contiene un alias de tema superior al alias de tema máximo que
envió en el paquete CONNECT o CONNACK.

107
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

Valor Hexágono Nombre del Descripción

código de motivo

151 0x97 Cuota excedida Se ha superado un límite impuesto administrativo o de

implementación.

152 0x98 Acción La conexión se ha cerrado debido a una acción administrativa.

administrativa

155 0x9B No se admite El cliente especificó una QoS superior a la QoS especificada en
QoS la QoS máxima del CONNACK.

161 0xA1 No se admiten El servidor no admite identificadores de suscripción; la

identificadores suscripción no se acepta.
de suscripción

Códigos de motivos de SUBACK

Valor HexágonoNombre del Descripción

código de motivo

0 0x00 QoS concedida: 0 Se acepta la suscripción y la QoS máxima enviada será QoS 0.
Es posible que se trate de una QoS inferior a la solicitada.

1 0x01 QoS 1 concedida Se acepta la suscripción y la QoS máxima enviada será QoS 1.
Es posible que se trate de una QoS inferior a la solicitada.

128 0x80 Error no No se acepta la suscripción y el servidor no desea revelar el

especificado motivo o no se aplica ninguno de los demás códigos de motivo.

135 0x87 No autorizado El Cliente no está autorizado a realizar esta suscripción.

143 0x8F Filtro de tema no El filtro de temas está configurado correctamente, pero no está
válido permitido para este cliente.

145 0x91 Identificador de El identificador de paquete especificado ya está en uso.

paquetes en uso

151 0x97 Cuota excedida Se ha superado un límite impuesto administrativo o de

implementación.

Códigos de motivos de UNSUBACK

Valor HexágonoNombre del Descripción

código de motivo

0 0x00 Correcto Se elimina la suscripción.

128 0x80 Error no No se pudo completar la cancelación de la suscripción y el

especificado servidor no desea revelar el motivo o no se aplica ninguno de los
demás códigos de motivo.

143 0x8F Filtro de tema no El filtro de temas está configurado correctamente, pero no está
válido permitido para este cliente.

145 0x91 Identificador de El identificador de paquete especificado ya está en uso.

paquetes en uso

108
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

AWS IoTdiferencias con respecto a las especificaciones de MQTT

La implementación del broker de mensajes se basa en laEspecificación MQTT v3.1.1y elEspecificación
MQTT v5.0, pero difiere de las especificaciones en los siguientes aspectos:

• AWS IoTno admite los siguientes paquetes para MQTT 3: PUBREC, PUBREL y PUBCOMP.
• AWS IoTno admite los siguientes paquetes para MQTT 5: PUBREC, PUBREL, PUBCOMP y AUTH.
• AWS IoTno admite la redirección del servidor MQTT 5.
• AWS IoTsolo admite los niveles 0 y 1 de calidad de servicio (QoS) de MQTT.AWS IoTno admite la
publicación ni la suscripción con el nivel 2 de QoS. Cuando se solicita el nivel 2 de QoS, el intermediario
de mensajes no envía ningún PUBACK ni un SUBACK.
• En AWS IoT, suscribirse a un tema con QoS nivel 0 significa que un mensaje se entrega cero o más
veces. Es posible que un mensaje se entregue más de una vez. Los mensajes que se entreguen más de
una vez pueden enviarse con otro ID de paquete. En tal caso, la marca DUP no se establece.
• Cuando responde a una solicitud de conexión, el agente de mensajes envía un mensaje CONNACK.
Este mensaje contiene una marca para indicar si la conexión reanuda una sesión anterior.
• Antes de enviar paquetes de control adicionales o una solicitud de desconexión, el cliente debe esperar
a que el mensaje CONNACK se reciba en su dispositivo desde elAWS IoTagente de mensajes.
• Cuando un cliente se suscribe a un tema, puede haber un retraso entre el momento en que el agente
de mensajes envía un SUBACK y el momento en que el cliente empieza a recibir nuevos mensajes
coincidentes.
• Cuando un cliente usa el carácter comodín#en el filtro de temas para suscribirse a un tema, coinciden
todas las cadenas en su nivel de la jerarquía de temas o por debajo de él. Sin embargo, el tema principal
no coincide. Por ejemplo, una suscripción al temasensor/#recibe los mensajes publicados en los
temassensor/,sensor/temperature,sensor/temperature/room1, pero no los mensajes
publicados ensensor. Para obtener más información sobre los comodines, consulteFiltros de
temas (p. 114).
• El agente de mensajes utiliza el ID de cliente para identificar a cada cliente. El ID de cliente se transfiere
desde el cliente al agente de mensajes como parte de la carga de MQTT. Dos clientes con el mismo
ID de cliente no se pueden conectar simultáneamente al agente de mensajes. Cuando un cliente se
conecta al agente de mensajes mediante un ID de cliente que otro cliente está utilizando, se acepta la
nueva conexión de cliente y se desconecta el cliente previamente conectado.
• En raras ocasiones, el agente de mensajes reenviará el mismo mensaje PUBLISH lógico con otro ID de
paquete.
• La suscripción a los filtros de temas que contienen un carácter comodín no puede recibir mensajes
retenidos. Para recibir un mensaje retenido, la solicitud de suscripción debe contener un filtro de tema
que coincida exactamente con el tema del mensaje retenido.
• El agente de mensajes no garantiza el orden en que se reciben los mensajes y el ACK.
• AWS IoTpueden tener límites diferentes a los de las especificaciones. Para obtener más información,
consulteAWS IoT Corelímites y cuotas del intermediario de mensajes y del protocolodesde elAWS
IoTGuía de referencia.

HTTPS
Los clientes pueden publicar mensajes realizando solicitudes a la API REST utilizando los protocolos
HTTP 1.0 o 1.1. Para obtener información sobre la autenticación y los mapeos de puertos utilizados por las
solicitudes HTTP, consulte Protocolos, mapeos de puertos y autenticación (p. 87).
Note

HTTPS no admite unclientIdvalor como lo hace MQTT.clientIdestá disponible cuando se

usa MQTT, pero no cuando se usa HTTPS.

109
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

URL del mensaje HTTPS

Los dispositivos y los clientes publican sus mensajes mediante solicitudes POST a un punto final
específico del cliente y a una URL específica del tema:

https://IoT_data_endpoint/topics/url_encoded_topic_name?qos=1"

• Endpoint de datos de IoTes elAWS IoTpunto final de datos del dispositivo (p. 83). Puede
encontrar el punto final enAWS IoTconsola en la página de detalles del objeto o en el cliente mediante
elAWS CLIcomando:

aws iot describe-endpoint --endpoint-type iot:Data-ATS

El punto de enlace debería tener un aspecto similar al siguiente: a3qjEXAMPLEffp-ats.iot.us-

west-2.amazonaws.com
• url_encoded_topic_name es el nombre del tema (p. 113) completo del mensaje enviado.

Ejemplos de códigos de mensajes HTTPS

Estos son algunos ejemplos de cómo enviar un mensaje HTTPS aAWS IoT.

Python (port 8443)

import requests
import argparse

# define command-line parameters

parser = argparse.ArgumentParser(description="Send messages through an HTTPS
connection.")
parser.add_argument('--endpoint', required=True, help="Your AWS IoT data custom
endpoint, not including a port. " +
"Ex: \"abcdEXAMPLExyz-ats.iot.us-
east-1.amazonaws.com\"")
parser.add_argument('--cert', required=True, help="File path to your client
certificate, in PEM format.")
parser.add_argument('--key', required=True, help="File path to your private key, in PEM
format.")
parser.add_argument('--topic', required=True, default="test/topic", help="Topic to
publish messages to.")
parser.add_argument('--message', default="Hello World!", help="Message to publish. " +
"Specify empty string to publish
nothing.")

# parse and load command-line parameter values

args = parser.parse_args()

# create and format values for HTTPS request

publish_url = 'https://' + args.endpoint + ':8443/topics/' + args.topic + '?qos=1'
publish_msg = args.message.encode('utf-8')

# make request
publish = requests.request('POST',
publish_url,
data=publish_msg,
cert=[args.cert, args.key])

# print results
print("Response status: ", str(publish.status_code))
if publish.status_code == 200:

110
 AWS IoT Core Guía para desarrolladores
Protocolos de comunicación de dispositivos

print("Response body:", publish.text)

Python (port 443)

import requests
import http.client
import json
import ssl

ssl_context = ssl.SSLContext(protocol=ssl.PROTOCOL_TLS_CLIENT)
ssl_context.minimum_version = ssl.TLSVersion.TLSv1_2

# note the use of ALPN

ssl_context.set_alpn_protocols(["x-amzn-http-ca"])
ssl_context.load_verify_locations(cafile="./<root_certificate>")

# update the certificate and the AWS endpoint

ssl_context.load_cert_chain("./<certificate_in_PEM_Format>",
"<private_key_in_PEM_format>")
connection = http.client.HTTPSConnection('<the ats IoT endpoint>', 443,
context=ssl_context)
message = {'data': 'Hello, I'm using TLS Client authentication!'}
json_data = json.dumps(message)
connection.request('POST', '/topics/device%2Fmessage?qos=1', json_data)

# make request
response = connection.getresponse()

# print results
print(response.read().decode())

CURL

Puedes usarrizodesde un cliente o dispositivo al que enviar un mensajeAWS IoT.

Para usar curl para enviar un mensaje desde un dispositivo cliente de AWS IoT

1. Compruebe elcurlversión.

a. En su cliente, ejecute este comando en un símbolo del sistema.

curl --help

En el texto de ayuda, busque las opciones TLS. Debería ver la opción --tlsv1.2.
b. Si ve la opción --tlsv1.2, continúe.
c. Si no ve el--tlsv1.2opción o obtienes uncommand not founderror, es posible que
tengas que actualizar o instalar curl en tu cliente o instalaropensslantes de continuar.
2. Instale los certificados en su cliente.

Copie los archivos de certificado que creó cuando registró su cliente (objeto) en la consola
de AWS IoT. Asegúrese de que tiene estos tres archivos de certificado en su cliente antes de
continuar.

• El archivo de certificado de CA (Amazon-root-CA-1.pemen este ejemplo).

• El archivo de certificado del cliente (dispositivo.pem.crten este ejemplo).
• El archivo de clave privada del cliente (clave privada.pem.keyen este ejemplo).
3. Crea elcurllínea de comandos, sustituyendo los valores reemplazables por los de su cuenta y
sistema.

curl --tlsv1.2 \

111
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

--cacert Amazon-root-CA-1.pem \
--cert device.pem.crt \
--key private.pem.key \
--request POST \
--data "{ \"message\": \"Hello, world\" }" \
"https://IoT_data_endpoint:8443/topics/topic?qos=1"

--tlsv1.2

Use TLS 1.2 (SSL).

--cacertAmazon-root-CA-1.pem

El nombre de archivo y la ruta de acceso, si es necesario, del certificado de entidad de

certificación para verificar el par.
--certificadodispositivo.pem.crt

El nombre y la ruta de acceso del archivo de certificado del cliente, si es necesario.

--claveclave privada.pem.key

El nombre y la ruta del archivo de la clave privada del cliente, si es necesario.

--solicitar POST

El tipo de solicitud HTTP (en este caso, POST).

--datos»{\ "message\»:\ "Hola, mundo\»}«

Los datos de HTTP POST que quiere publicar. En este caso, es una cadena JSON, con las
comillas internas con el carácter de escape de barra invertida (\).
«https://Endpoint de datos de IoT: 8443/temas/tema? qos=1"

La URL de su clienteAWS IoTpunto final de datos del dispositivo, seguido del puerto
HTTPS,:8443, que luego va seguida de la palabra clave,/topics/y el nombre del
tema,topic, en este caso. Especifique la calidad de servicio como parámetro de consulta,?
qos=1.
4. Abra el cliente de prueba MQTT en elAWS IoTconsola.

Siga las instrucciones deVer los mensajes MQTT con el cliente MQTT de AWS IoT (p. 69)y
configure la consola para suscribirse a los mensajes con el nombre del tema detemautilizado en
sucurlcomando, o utilice el filtro de temas comodín de#.
5. Pruebe el comando.

Mientras monitorea el tema en el cliente de prueba de la consola de AWS IoT, vaya a su cliente y
ejecute la línea de comandos curl que creó en el paso 3. Debería ver los mensajes de su cliente
en la consola.

Temas de MQTT
Los temas de MQTT identificanAWS IoTmensajes.AWS IoTlos clientes identifican los mensajes que
publican asignando nombres de temas a los mensajes. Los clientes identifican los mensajes a los que
desean suscribirse (recibir) registrando un filtro de temas con AWS IoT Core. El agente de mensajes de
utiliza nombres y filtros de temas para dirigir los mensajes de los clientes de publicación a los clientes de
suscripción.

El agente de mensajes utiliza temas para identificar los mensajes enviados mediante MQTT y enviados
mediante HTTP alURL del mensaje HTTPS (p. 110).

112
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Aunque AWS IoT admite algunos temas reservados del sistema (p. 115), la mayoría de los temas de
MQTT los crea y administra el diseñador del sistema. AWS IoT utiliza temas para identificar los mensajes
que se reciben de los clientes de publicación y para seleccionar los mensajes que se van a enviar a los
clientes suscriptores, tal y como se describe en las secciones siguientes. Antes de crear un espacio de
nombres de temas para el sistema, consulte las características de los temas de MQTT para crear la
jerarquía de nombres de temas que funcione mejor con su sistema de IoT.

Nombres de temas
Los nombres de los temas y los filtros de temas son cadenas codificadas por UTF-8. Pueden representar
una jerarquía de información utilizando el carácter de barra diagonal (/) para separar los niveles de la
jerarquía. Por ejemplo, este nombre de tema podría referirse a un sensor de temperatura en la sala 1:

• sensor/temperature/room1

En este ejemplo, también puede haber otros tipos de sensores en otras salas con nombres de temas
como:

• sensor/temperature/room2
• sensor/humidity/room1
• sensor/humidity/room2

Note

Cuando considere los nombres de los temas para los mensajes de su sistema, tenga en cuenta:

• Los nombres de temas y los filtros de temas distinguen entre mayúsculas y minúsculas.
• Los nombres de los temas no deben contener información de identificación personal.
• Los nombres de tema que comienzan por $ son temas reservados (p. 115) que debe utilizar
únicamente AWS IoT Core.
• AWS IoT Coreno puede enviar ni recibir mensajes entreCuenta de AWSs o regiones.

Para obtener más información sobre cómo diseñar los nombres de los temas y el espacio de nombres,
consulta nuestro documento técnico,Diseño de temas de MQTT paraAWS IoT Core.

Para ver ejemplos de cómo las aplicaciones pueden publicar mensajes y suscribirse a ellos, comienza
conIntroducción a AWS IoT Core (p. 18)yAWS IoTSDK para dispositivos, SDK para dispositivos móviles
yAWS IoTCliente de dispositivo (p. 1489).
Important

El espacio de nombres del tema está limitado aCuenta de AWSy región. Por ejemplo, elsensor/
temp/room1tema utilizado por unCuenta de AWSen una región es distinta de lasensor/temp/
room1tema utilizado por el mismoAWScuenta en otra región o utilizada por cualquier otraCuenta
de AWSen cualquier región.

ARN de tema
Todos los ARN (nombres de recursos de Amazon) de los temas tienen el siguiente formato:

arn:aws:iot:aws-region:AWS-account-ID:topic/Topic

Por ejemplo,arn:aws:iot:us-west-2:123EXAMPLE456:topic/application/topic/device/
sensores un ARN para el tema application/topic/device/sensor.

113
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Filtros de temas
Los clientes suscriptores registran filtros de temas con el agente de mensajes de para especificar los
temas de mensajes que el agente de mensajes debe enviarles. Un filtro de tema puede ser un nombre de
tema único para suscribirse a un solo nombre de tema o puede incluir caracteres comodín para suscribirse
a varios nombres de temas al mismo tiempo.

Los clientes de publicación no pueden usar caracteres comodín en los nombres de los temas que publican.

En la tabla siguiente se enumeran los caracteres comodín que se pueden utilizar en un filtro de temas.

Comodines de tema
Carácter comodín Coincide Notas

# Todas las cadenas en y por Debe ser el último carácter del

debajo de su nivel en la jerarquía filtro de temas.
de temas.
Debe ser el único carácter en su
nivel de jerarquía de temas.

Se puede utilizar en un filtro de

temas que también contiene el
carácter comodín +.

+ Cualquier cadena en el nivel que Debe ser el único carácter en su

contiene el carácter. nivel de jerarquía de temas.

Se puede utilizar en varios

niveles de un filtro de tema.

Uso de comodines con los ejemplos de nombres de tema de sensor anteriores:

• Una suscripción a sensor/# recibe los mensajes publicados en sensor/, sensor/temperature y

sensor/temperature/room1, pero no los mensajes publicados en sensor.
• Una suscripción a sensor/+/room1 recibe mensajes publicados en sensor/temperature/room1 y
sensor/humidity/room1, pero no mensajes enviados a sensor/temperature/room2 o sensor/
humidity/room2.

Filtro de temas ARN

Todos los ARN del filtro de temas (nombres de recursos de Amazon) tienen el siguiente formato:

arn:aws:iot:aws-region:AWS-account-ID:topicfilter/TopicFilter

Por ejemplo,arn:aws:iot:us-west-2:123EXAMPLE456:topicfilter/application/topic/+/
sensores un ARN para el filtro de temas application/topic/+/sensor.

Carga útil de mensajes MQTT

La carga útil de mensajes que se envía en sus mensajes de MQTT no está especificada porAWS IoT, a
menos que sea para uno de losthe section called “Temas reservados” (p. 115). Para adaptarse a las
necesidades de su aplicación, le recomendamos que defina la carga útil de mensajes para sus temas
dentro de las restricciones de laAWS IoT CoreCuotas de servicio para protocolos.

El uso de un formato JSON para la carga de mensajes permite laAWS IoTmotor de reglas para analizar
sus mensajes y aplicarles consultas SQL. Si la aplicación no requiere que el motor de reglas aplique

114
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

consultas SQL a las cargas de mensajes, puede utilizar cualquier formato de datos que requiera la
aplicación. Para obtener información sobre las limitaciones y los caracteres reservados de un documento
JSON utilizado en las consultas SQL, consulteExtensiones JSON (p. 672).

Para obtener más información sobre el diseño de los temas de MQTT y sus correspondientes cargas de
mensajes, consulteDiseño de temas de MQTT paraAWS IoT Core.

Si el límite de tamaño de un mensaje supera las cuotas de servicio, se generará unCLIENT_ERRORcon

razónPAYLOAD_LIMIT_EXCEEDEDy «La carga útil del mensaje supera el límite de tamaño para el tipo de
mensaje». Para obtener más información sobre el límite de tamaño de los mensajes, consulteAWS IoT
Corelímites y cuotas del intermediario de mensajes.

Temas reservados
Los temas que comienzan por un signo de dólar ($) están reservados para su uso por parte de AWS IoT.
Puedes suscribirte a estos temas reservados y publicarlos en la medida en que lo permitan; sin embargo,
no puedes crear nuevos temas que comiencen por el signo del dólar. Las operaciones de publicación o
suscripción no admitidas a temas reservados pueden dar como resultado que se termine la conexión.

Temas del modelo de activos

Tema Operaciones de cliente permitidas Descripción

$aws/sitewise/asset- Suscribirse AWS IoT SiteWise publica

models/assetModelId/ notificaciones de propiedades
activos/ID del activo/ de activos en este tema. Para
propiedades/ID de obtener más información,
propiedad consulteInteractuar con
otrosAWSserviciosen elAWS
IoT SiteWiseGuía del usuario.

Temas de AWS IoT Device Defender

Estos mensajes admiten búferes de respuesta en formato de representación binaria concisa de objetos
(CBOR) yJavaScriptNotación de objetos (JSON), segúnformato de cargadel tema.AWS IoT Device
Defenderlos temas solo admiten la publicación en MQTT.

payload-format Tipo de datos de formato de respuesta

cbor Concise Binary Object Representation

(Representación concisa de objetos binarios,
CBOR)

json JavaScriptNotación de objetos (JSON)

Para obtener más información, consulte Envío de métricas desde dispositivos (p. 1108).

Tema Operaciones permitidas Descripción

$aws/things/thingName/ Publicación AWS IoT Device Defenderlos agentes

defender/metrics/payload- publican métricas sobre este tema. Para
format obtener más información, consulte Envío de
métricas desde dispositivos (p. 1108).

115
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones permitidas Descripción

$aws/things/thingName/ Suscribirse AWS IoTpublica sobre este tema después

defender/metrics/payload- de unAWS IoT Device Defenderel agente
format/accepted publica un mensaje exitoso en $aws/
things/Nombre de la cosa/defender/
métricas/formato de carga. Para obtener
más información, consulte Envío de métricas
desde dispositivos (p. 1108).

$aws/things/thingName/ Suscribirse AWS IoTpublica sobre este tema después

defender/metrics/payload- de unAWS IoT Device Defenderel agente
format/rejected publica un mensaje incorrecto en $aws/
things/Nombre de la cosa/defender/
métricas/formato de carga. Para obtener
más información, consulte Envío de métricas
desde dispositivos (p. 1108).

AWS IoT CoreTemas sobre ubicación de dispositivos

AWS IoT CoreLa ubicación del dispositivo puede resolver los datos de medición de su dispositivo y
proporcionar una ubicación estimada de sus dispositivos de IoT. Los datos de medición del dispositivo
pueden incluir GNSS, Wi-Fi, telefonía móvil e IP.AWS IoT Core A continuación, Device Location selecciona
el tipo de medición que proporciona la mejor precisión y resuelve la información de ubicación del
dispositivo. Para obtener más información, consulte AWS IoT CoreUbicación del dispositivo (p. 1234)
y Resolver la ubicación del dispositivo medianteAWS IoT CoreTemas de MQTT sobre ubicación de
dispositivos (p. 1241).

Tema Operaciones permitidas Descripción

$aws/ Publicación Un dispositivo publica sobre este tema para

dispositivo_ubicación/ que los datos de medición sin procesar
identificador escaneados se resuelvan medianteAWS IoT
del dispositivo CoreUbicación del dispositivo.
del cliente/
get_position_estimate

$aws/ Suscribirse AWS IoT CoreDevice Location publica

dispositivo_ubicación/ este tema una vez que se haya resuelto
identificador correctamente la ubicación del dispositivo.
del dispositivo
del cliente/
get_position_estimate/
accepted

$aws/ Suscribirse AWS IoT CoreDevice Location publica este

dispositivo_ubicación/ tema cuando no puede resolver la ubicación
identificador del dispositivo correctamente debido a un
del dispositivo error de 4xx.
del cliente/
get_position_estimate/rejected

116
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Temas de eventos

Tema Operaciones de cliente Descripción

permitidas

$aws/events/certificados/ Suscribirse AWS IoT publica este mensaje cuando AWS

registrado/caCertificateId IoT registra automáticamente un certificado
y cuando un cliente presenta un certificado
con el estado PENDING_ACTIVATION.
Para obtener más información, consulte
the section called “Configurar la primera
conexión de un cliente para el registro
automático” (p. 329).

$aws/events/trabajo/Oferta Suscribirse AWS IoTpublica este mensaje cuando

de trabajo/cancelado se cancela un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/trabajo/Oferta Suscribirse AWS IoTpublica este mensaje cuando hay

de trabajo/ una cancelación de trabajo en curso. Para
cancelación_in_progreso obtener más información, consulte Eventos
de trabajos (p. 1264).

$aws/events/trabajo/Oferta Suscribirse AWS IoTpublica este mensaje cuando se

de trabajo/completado ha completado un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/trabajo/Oferta Suscribirse AWS IoTpublica este mensaje cuando

de trabajo/eliminado se elimina un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/trabajo/Oferta Suscribirse AWS IoTpublica este mensaje cuando se

de trabajo/ está eliminando una tarea. Para obtener
deletion_in_progress más información, consulte Eventos de
trabajos (p. 1264).

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando se

del trabajo/Oferta de cancela la ejecución de un trabajo. Para
trabajo/cancelado obtener más información, consulte Eventos
de trabajos (p. 1264).

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando se

del trabajo/Oferta de elimina la ejecución de un trabajo. Para
trabajo/eliminado obtener más información, consulte Eventos
de trabajos (p. 1264).

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando se

del trabajo/Oferta de produce un error en la ejecución de un
trabajo/falló trabajo. Para obtener más información,
consulte Eventos de trabajos (p. 1264).

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando se

del trabajo/Oferta de rechaza la ejecución de un trabajo. Para
trabajo/rechazado obtener más información, consulte Eventos
de trabajos (p. 1264).

117
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando se

del trabajo/Oferta de elimina la ejecución de un trabajo. Para
trabajo/eliminado obtener más información, consulte Eventos
de trabajos (p. 1264).

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando la

del trabajo/Oferta de ejecución de un trabajo se ha realizado
trabajo/tuvo éxito correctamente. Para obtener más
información, consulte Eventos de
trabajos (p. 1264).

$AWS/Eventos/Ejecución Suscribirse AWS IoTpublica este mensaje cuando se

del trabajo/Oferta de agota el tiempo de ejecución de un trabajo.
trabajo/agotado_de_tiempo Para obtener más información, consulte
Eventos de trabajos (p. 1264).

$aws/events/presence/ Suscribirse AWS IoT publica en este tema cuando

connected/idCliente un cliente MQTT con el ID de cliente
especificado se conecta a AWS IoT. Para
obtener más información, consulte Eventos
de conexión/desconexión (p. 1268).

$aws/events/presence/ Suscribirse AWS IoT publica en este tema cuando

disconnected/idCliente un cliente MQTT con el ID de cliente
especificado se desconecta de AWS IoT.
Para obtener más información, consulte
Eventos de conexión/desconexión (p. 1268).

$aws/events/subscriptions/ Suscribirse AWS IoT publica en este tema cuando

subscribed/idCliente un cliente MQTT con el ID de cliente
especificado se suscribe a un tema MQTT.
Para obtener más información, consulte
Eventos de suscripción/cancelación de
suscripción (p. 1270).

$aws/events/subscriptions/ Suscribirse AWS IoT publica en este tema cuando

unsubscribed/idCliente un cliente MQTT con el ID de cliente
especificado anula la suscripción de un
tema MQTT. Para obtener más información,
consulte Eventos de suscripción/cancelación
de suscripción (p. 1270).

$aws/events/ Suscribirse AWS IoT publica en este tema cuando se

thing/thingName/created crea el objeto thingName. Para obtener
más información, consulte the section called
“Eventos de registro” (p. 1257).

$aws/events/ Suscribirse AWS IoT publica en este tema cuando se

thing/thingName/updated actualiza el objeto thingName. Para obtener
más información, consulte the section called
“Eventos de registro” (p. 1257).

118
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/events/ Suscribirse AWS IoT publica en este tema cuando se

thing/thingName/deleted elimina el objeto thingName. Para obtener
más información, consulte the section called
“Eventos de registro” (p. 1257).

$AWS/eventos/ Suscribirse AWS IoTpublica sobre este tema cuando

ThingGroup/ un grupo de cosasthingGroupNamese
thingGroupName/creado crea. Para obtener más información,
consulte the section called “Eventos de
registro” (p. 1257).

$AWS/eventos/ Suscribirse AWS IoTpublica sobre este tema cuando

ThingGroup/ un grupo de cosasthingGroupNameestá
thingGroupName/ actualizado. Para obtener más información,
actualizado consulte the section called “Eventos de
registro” (p. 1257).

$AWS/eventos/ Suscribirse AWS IoTpublica sobre este tema cuando

ThingGroup/ un grupo de cosasthingGroupNamese
thingGroupName/eliminado elimina. Para obtener más información,
consulte the section called “Eventos de
registro” (p. 1257).

$AWS/eventos/ Suscribirse AWS IoTpublica sobre este tema

ThingType/thingTypeName/ cuandothingTypeNamese crea el tipo
creado de cosa. Para obtener más información,
consulte the section called “Eventos de
registro” (p. 1257).

$AWS/eventos/ Suscribirse AWS IoTpublica sobre este tema

ThingType/thingTypeName/ cuandothingTypeNameel tipo de cosa está
actualizado actualizado. Para obtener más información,
consulte the section called “Eventos de
registro” (p. 1257).

$AWS/eventos/ Suscribirse AWS IoTpublica sobre este tema

ThingType/thingTypeName/ cuandothingTypeNamese elimina el tipo
eliminado de cosa. Para obtener más información,
consulte the section called “Eventos de
registro” (p. 1257).

$aws/eventos/ Suscribirse AWS IoTpublica sobre este tema cuando

thingTypeAssociation/ la cosaNombre de la cosaestá
cosa/Nombre de la asociado o disociado del tipo de
cosa/thingTypeName cosathingTypeName. Para obtener más
información, consulte the section called
“Eventos de registro” (p. 1257).

$aws/eventos/ Suscribirse AWS IoTpublica sobre este tema cuando

thingGroupMembership/Grupo la cosaNombre de la cosase agrega
de cosas/thingGroupName/ al grupo de cosasthingGroupName.
cosa/Nombre de la cosa/ Para obtener más información,
añadido consulte the section called “Eventos de
registro” (p. 1257).

119
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/eventos/ Suscribirse AWS IoTpublica sobre este tema cuando

thingGroupMembership/Grupo la cosaNombre de la cosase elimina
de cosas/thingGroupName/ del grupo de cosasthingGroupName.
cosa/Nombre de la cosa/ Para obtener más información,
eliminado consulte the section called “Eventos de
registro” (p. 1257).

$aws/eventos/ Suscribirse AWS IoTpublica sobre este

thingGroupHierarchy/Grupo de tema cuando un grupo de
cosas/ cosaschildThingGroupNombrese
parentThingGroupNombre/ agrega al grupo de
childThingGroup/ cosasparentThingGroupNombre.
childThingGroupNombre/ Para obtener más información,
añadido consulte the section called “Eventos de
registro” (p. 1257).

$aws/eventos/ Suscribirse AWS IoTpublica sobre este

thingGroupHierarchy/Grupo de tema cuando un grupo de
cosas/ cosaschildThingGroupNombrese
parentThingGroupNombre/ elimina del grupo de
childThingGroup/ cosasparentThingGroupNombre.
childThingGroupNombre/ Para obtener más información,
eliminado consulte the section called “Eventos de
registro” (p. 1257).

Temas de aprovisionamiento de flotas

Note

Las operaciones del cliente se indican comoRecibiren esta tabla, indique los temas queAWS
IoTpublica directamente en el cliente que lo solicitó, independientemente de que el cliente se haya
suscrito al tema o no. Los clientes deben esperar recibir estos mensajes de respuesta incluso
si no se han suscrito a ellos. Estos mensajes de respuesta no pasan por el intermediario de
mensajes y no pueden suscribirse a ellos otros clientes ni reglas.

Estos mensajes admiten búferes de respuesta en formato de representación binaria concisa de objetos
(CBOR) yJavaScriptNotación de objetos (JSON), segúnformato de cargadel tema.

payload-format Tipo de datos de formato de respuesta

cbor Concise Binary Object Representation

(Representación concisa de objetos binarios,
CBOR)

json JavaScriptNotación de objetos (JSON)

Para obtener más información, consulte API de MQTT de aprovisionamiento de dispositivos (p. 915).

120
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/certificates/ Publicación Publique en este tema para crear un

create/payload-format certificado a partir de una solicitud de firma de
certificado (CSR).

$aws/certificates/ Suscríbete, recibe AWS IoT publica en este tema después de

create/payload-format/ una llamada exitosa a $aws/certificates/
accepted create/payload-format.

$aws/certificates/ Suscríbete, recibe AWS IoT publica en este tema después

create/payload-format/ de una llamada fallida a $aws/certificates/
rejected create/payload-format.

$aws/certificados/create-from- Publicación Publica en este tema para crear un certificado

csr/formato de carga a partir de una CSR.

$aws/certificados/create-from- Suscríbete, recibe AWS IoTpublica sobre este tema una llamada
csr/formato de carga/ exitosa a $aws/certificates/create-from-
aceptado csr/formato de carga.

$aws/certificados/create-from- Suscríbete, recibe AWS IoTpublica sobre este tema una llamada
csr/formato de carga/ fallida a $aws/certificates/create-from-
rechazado csr/formato de carga.

$aws/provisioning- Publicación Publique en este tema para registrar un

templates/templateName/ objeto.
provision/payload-format

$aws/provisioning- Suscríbete, recibe AWS IoT publica en este tema después

templates/templateName/ de una llamada exitosa a $aws/
provision/payload-format/ provisioning-templates/TemplateName/
accepted provision/payload-format.

$aws/provisioning- Suscríbete, recibe AWS IoT publica en este tema

templates/templateName/ después de una llamada fallida a $aws/
provision/payload-format/ provisioning-templates/TemplateName/
rejected provision/payload-format.

Temas de trabajos
Note

Las operaciones del cliente se indican comoRecibiren esta tabla, indique los temas queAWS
IoTpublica directamente en el cliente que lo solicitó, independientemente de que el cliente se haya
suscrito al tema o no. Los clientes deben esperar recibir estos mensajes de respuesta incluso si
no se han suscrito a ellos.
Estos mensajes de respuesta no pasan por el intermediario de mensajes y no pueden suscribirse
a ellos otros clientes ni reglas. Para suscribirse a los mensajes relacionados con la actividad
laboral, utilice elnotifyynotify-nexttemas.
Al suscribirse al trabajo yjobExecutiontemas de eventos para su solución de monitoreo de
flotas, primero debe habilitartrabajo y eventos de ejecución de trabajos (p. 1253)para recibir
cualquier evento en la nube.
Para obtener más información, consulte Operaciones de la API MQTT del dispositivo
Jobs (p. 817).

121
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/things/thingName/jobs/ Publicación Los dispositivos publican un mensaje

get en este tema para realizar una solicitud
GetPendingJobExecutions. Para
obtener más información, consulte
Operaciones de la API MQTT del
dispositivo Jobs (p. 817).

$aws/things/thingName/jobs/ Suscríbete, recibe Los dispositivos se suscriben a este tema

get/accepted para recibir respuestas correctas de una
solicitud GetPendingJobExecutions.
Para obtener más información, consulte
Operaciones de la API MQTT del
dispositivo Jobs (p. 817).

$aws/things/thingName/jobs/ Suscríbete, recibe Los dispositivos se suscriben a este

get/rejected tema para recibir una respuesta
cuandoGetPendingJobExecutionsse
rechaza la solicitud. Para obtener más
información, consulte Operaciones de la
API MQTT del dispositivo Jobs (p. 817).

$aws/things/thingName/jobs/ Publicación Los dispositivos publican un mensaje

start-next en este tema para realizar una solicitud
StartNextPendingJobExecution.
Para obtener más información, consulte
Operaciones de la API MQTT del
dispositivo Jobs (p. 817).

$aws/things/thingName/jobs/ Suscríbete, recibe Los dispositivos se suscriben a

start-next/accepted este tema para recibir respuestas
correctas a una solicitud
StartNextPendingJobExecution.
Para obtener más información, consulte
Operaciones de la API MQTT del
dispositivo Jobs (p. 817).

$aws/things/thingName/jobs/ Suscríbete, recibe Los dispositivos se suscriben a este

start-next/rejected tema para recibir una respuesta
cuandoStartNextPendingJobExecutionse
rechaza la solicitud. Para obtener más
información, consulte Operaciones de la
API MQTT del dispositivo Jobs (p. 817).

$aws/things/thingName/ Publicación Los dispositivos publican un mensaje

jobs/jobId/get en este tema para realizar una solicitud
DescribeJobExecution. Para obtener
más información, consulte Operaciones de
la API MQTT del dispositivo Jobs (p. 817).

$aws/things/thingName/ Suscríbete, recibe Los dispositivos se suscriben a este tema

jobs/jobId/get/accepted para recibir respuestas correctas a una
solicitud DescribeJobExecution.
Para obtener más información, consulte
Operaciones de la API MQTT del
dispositivo Jobs (p. 817).

122
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/things/thingName/ Suscríbete, recibe Los dispositivos se suscriben a este

jobs/jobId/get/rejected tema para recibir una respuesta
cuandoDescribeJobExecutionse
rechaza la solicitud. Para obtener más
información, consulte Operaciones de la
API MQTT del dispositivo Jobs (p. 817).

$aws/things/thingName/ Publicación Los dispositivos publican un mensaje

jobs/jobId/update en este tema para realizar una solicitud
UpdateJobExecution. Para obtener más
información, consulte Operaciones de la
API MQTT del dispositivo Jobs (p. 817).

$aws/things/thingName/ Suscríbete, recibe Los dispositivos se suscriben a este

jobs/jobId/update/accepted tema para recibir respuestas correctas
a una solicitud UpdateJobExecution.
Para obtener más información, consulte
Operaciones de la API MQTT del
dispositivo Jobs (p. 817).
Nota

Solo el dispositivo que publica

en $aws/things/thingName/
jobs/jobId/update recibirá
mensajes en este tema.

$aws/things/thingName/ Suscríbete, recibe Los dispositivos se suscriben a este

jobs/jobId/update/rejected tema para recibir una respuesta cuando
unUpdateJobExecutionse rechaza la
solicitud. Para obtener más información,
consulte Operaciones de la API MQTT del
dispositivo Jobs (p. 817).
Nota

Solo el dispositivo que publica

en $aws/things/thingName/
jobs/jobId/update recibirá
mensajes en este tema.

$aws/things/thingName/jobs/ Suscribirse Los dispositivos se suscriben a este tema

notify para recibir notificaciones cuando la
ejecución de un trabajo se añade o elimina
de la lista de ejecuciones pendientes de
un objeto. Para obtener más información,
consulte Operaciones de la API MQTT del
dispositivo Jobs (p. 817).

$aws/things/thingName/jobs/ Suscribirse Los dispositivos se suscriben a este

notify-next tema para recibir notificaciones cuando
cambia la siguiente ejecución de un trabajo
pendiente para el objeto. Para obtener más
información, consulte Operaciones de la
API MQTT del dispositivo Jobs (p. 817).

123
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica un evento

completed sobre este tema cuando se completa un
trabajo. Para obtener más información,
consulte Eventos de trabajos (p. 1264).

$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica un evento

canceled sobre este tema cuando se cancela un
trabajo. Para obtener más información,
consulte Eventos de trabajos (p. 1264).

$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica un evento

deleted sobre este tema cuando se elimina un
trabajo. Para obtener más información,
consulte Eventos de trabajos (p. 1264).

$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica un evento

cancellation_in_progress sobre este tema cuando se inicia la
cancelación de un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica un evento

deletion_in_progress sobre este tema cuando se inicia la
eliminación de un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/ sobre este tema cuando la ejecución del
succeeded trabajo se ejecuta satisfactoriamente. Para
obtener más información, consulte Eventos
de trabajos (p. 1264).

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/failed sobre este tema cuando la ejecución de
un trabajo produce un error. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/rejected sobre este tema cuando se rechaza una
ejecución de un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/canceled sobre este tema cuando se cancela la
ejecución de un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

124
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/ sobre este tema cuando se agota el tiempo
timed_out de espera de ejecución de un trabajo. Para
obtener más información, consulte Eventos
de trabajos (p. 1264).

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/removed sobre este tema cuando se elimina la
ejecución de un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

$aws/events/ Suscribirse El servicio de trabajos publica un evento

jobExecution/jobId/deleted sobre este tema cuando se elimina la
ejecución de un trabajo. Para obtener
más información, consulte Eventos de
trabajos (p. 1264).

Temas de reglas

Tema Operaciones de cliente Descripción

permitidas

$aws/rules/nombreRegla Publicación Los dispositivos o las aplicaciones

publican en este tema para activar
reglas directamente. Para obtener más
información, consulte Reducir los costos de
mensajería con Basic Ingest (p. 609).

Temas de tunelización segura

Tema Operaciones de cliente Descripción

permitidas

$aws/things/thing-name/ Suscribirse AWS IoT publica este mensaje para que

tunnels/notify un agente de IoT inicie un proxy local en
el dispositivo remoto. Para obtener más
información, consulte the section called
“Fragmento de agente de IoT” (p. 875).

Temas de sombra
Las sombras con nombre y sin nombre utilizan los temas de esta sección. Los temas utilizados por cada
uno solo difieren en el prefijo del tema. Esta tabla muestra el prefijo de tema utilizado por cada tipo de
sombra.

ShadowTopicPrefix value Tipo de sombra

$aws/things/thingName/shadow Sombra sin nombre (clásica)

125
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

ShadowTopicPrefix value Tipo de sombra

$aws/things/thingName/shadow/ Sombra con nombre

name/shadowName

Para crear un tema completo, seleccionaShadowTopicPrefixpara el tipo de sombra al que desea

hacer referencia, sustituyaNombre de la cosay, si procede,Nombre sombrío, con sus valores
correspondientes y, a continuación, añádelos al código auxiliar del tema, como se muestra en la siguiente
tabla. Recuerde que los temas distinguen entre mayúsculas y minúsculas.

Tema Operaciones de cliente Descripción

permitidas

ShadowTopicPrefix/ Publicar/suscribirse Un dispositivo o una aplicación publica

eliminar en este tema para eliminar una sombra.
Para obtener más información, consulte /
delete (p. 719).

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía mensajes

eliminar/aceptado a este tema cuando se elimina una sombra.
Para obtener más información, consulte /
delete/accepted (p. 720).

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía mensajes

eliminar/rechazado a este tema cuando se rechaza una
solicitud para eliminar una sombra. Para
obtener más información, consulte /delete/
rejected (p. 721).

ShadowTopicPrefix/ Publicar/suscribirse Una aplicación o un objeto publica un

obtener mensaje vacío en este tema para obtener
una sombra. Para obtener más información,
consulte Temas MQTT de sombra de
dispositivo (p. 713).

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía

obtener/aceptado mensajes a este tema cuando se realiza
correctamente una solicitud de una sombra.
Para obtener más información, consulte /
get/accepted (p. 714).

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía

obtener/rechazado mensajes a este tema cuando se rechaza
una solicitud de una sombra. Para
obtener más información, consulte /get/
rejected (p. 715).

ShadowTopicPrefix/ Publicar/suscribirse Un objeto o una aplicación publica en

actualizar este tema para actualizar una sombra.
Para obtener más información, consulte /
update (p. 716).

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía

actualizar/aceptado mensajes a este tema cuando se realiza
correctamente una actualización en una
sombra. Para obtener más información,
consulte /update/accepted (p. 717).

126
 AWS IoT Core Guía para desarrolladores
Temas de MQTT

Tema Operaciones de cliente Descripción

permitidas

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía mensajes

actualizar/rechazado a este tema cuando se rechaza una
actualización en una sombra. Para obtener
más información, consulte /update/
rejected (p. 719).

ShadowTopicPrefix/ Suscribirse El servicio Device Shadow envía mensajes

update/delta a este tema cuando se detecta una
diferencia entre las secciones para los
estados reported y desired de una sombra.
Para obtener más información, consulte /
update/delta (p. 717).

ShadowTopicPrefix/ Suscribirse AWS IoT publica un documento de estado

actualización/documentos en este tema siempre que se realiza una
actualización correcta de la sombra. Para
obtener más información, consulte /update/
documents (p. 718).

Temas de entrega de archivos basados en MQTT

Estos mensajes admiten búferes de respuesta en formato de representación binaria concisa de objetos
(CBOR) yJavaScriptNotación de objetos (JSON), segúnformato de cargadel tema.

payload-format Tipo de datos de formato de respuesta

cbor Concise Binary Object Representation

(Representación concisa de objetos binarios,
CBOR)

json JavaScriptNotación de objetos (JSON)

Tema Operaciones de cliente Descripción

permitidas

$aws/cosas/ThingName/ Suscribirse AWSLa entrega de archivos basada

streams/StreamId/ en MQTT publica sobre este tema si
datos/formato de carga el»GetStream«se acepta la solicitud de
un dispositivo. La carga contiene los
datos de la transmisión. Para obtener
más información, consulte UsandoAWS
IoTEntrega de archivos en dispositivos
basada en MQTT (p. 958).

$aws/cosas/ThingName/ Publicación Un dispositivo publica sobre este tema

streams/StreamId/ para realizar una»GetStream«solicitud.
obtener/formato de carga Para obtener más información, consulte
UsandoAWS IoTEntrega de archivos en
dispositivos basada en MQTT (p. 958).

$aws/cosas/ThingName/ Suscribirse AWSLa entrega de archivos basada

streams/StreamId/ en MQTT publica sobre este tema si

127
 AWS IoT Core Guía para desarrolladores
Terminales configurables

Tema Operaciones de cliente Descripción

permitidas
descripción/formato de el»DescribeStream«se acepta la solicitud
carga de un dispositivo. La carga contiene
la descripción de la transmisión. Para
obtener más información, consulte
UsandoAWS IoTEntrega de archivos en
dispositivos basada en MQTT (p. 958).

$aws/cosas/ThingName/ Publicación Un dispositivo publica sobre

streams/StreamId/ este tema para realizar
describir/formato de carga una»DescribeStream«solicitud. Para
obtener más información, consulte
UsandoAWS IoTEntrega de archivos en
dispositivos basada en MQTT (p. 958).

$aws/cosas/ThingName/ Suscribirse AWSLa entrega de archivos basada

streams/StreamId/ en MQTT publica sobre este tema si
rechazado/formato de un»DescribeStream«o»GetStream«se
carga rechaza la solicitud de un dispositivo.
Para obtener más información, consulte
UsandoAWS IoTEntrega de archivos en
dispositivos basada en MQTT (p. 958).

Tema reservado ARN

Todos los ARN (nombres de recursos de Amazon) de los temas reservados tienen el siguiente formato:

arn:aws:iot:aws-region:AWS-account-ID:topic/Topic

Por ejemplo,arn:aws:iot:us-west-2:123EXAMPLE456:topic/$aws/things/thingName/jobs/
get/acceptedes un ARN para el tema reservado$aws/things/thingName/jobs/get/accepted.

Terminales configurables
ConAWS IoT Core, puede configurar y administrar los comportamientos de sus extremos de datos
mediante configuraciones de dominio. Con las configuraciones de dominio, puede generar múltiplesAWS
IoT Corepuntos de enlace de datos, personalice los extremos de datos con sus propios nombres de
dominio completos (FQDN) y certificados de servidor asociados, y también asocie un autorizador
personalizado. Para obtener más información, consulte Autenticación y autorización a la medida (p. 337).
Note

Esta función no está disponible enGovCloud Regiones de AWS.

Puede utilizar configuraciones de dominio para simplificar tareas como las siguientes.

• Migrar dispositivos a AWS IoT Core

• Admitir flotas de dispositivos heterogéneas manteniendo configuraciones de dominio diferentes para
cada tipo de dispositivo
• Mantener la identidad de la marca (por ejemplo, a través del nombre de dominio) migrando al mismo
tiempo la infraestructura de la aplicación a AWS IoT Core

AWS IoT Core utiliza la extensión TLS de indicación de nombre de servidor (SNI) para aplicar
configuraciones de dominio. Los dispositivos deben usar esta extensión cuando se conecten. También

128
 AWS IoT Core Guía para desarrolladores
Terminales configurables

deben incluir un nombre de servidor que sea idéntico al nombre de dominio que especifique en
la configuración del dominio. Para probar este servicio, utilice la versión v2 delAWS IoTSDK de
dispositivosenGitHub.

Si crea varios puntos finales de datos en suCuenta de AWS, compartiránAWS IoT Corerecursos como
temas de MQTT, sombras de dispositivos y reglas.

Al proporcionar los certificados de servidor paraAWS IoT Coreconfiguración de dominio personalizada,

los certificados tienen un máximo de cuatro nombres de dominio. Para obtener más información, consulte
Puntos de enlace y cuotas de AWS IoT Core.

Temas
• Creación y configuración de dominios administrados por AWS (p. 129)
• Creación y configuración de dominios personalizados (p. 129)
• Administrar configuraciones de dominio (p. 133)
• Configuración de los ajustes de TLS en las configuraciones de dominio (p. 134)

Creación y configuración de dominios administrados por AWS

Se crea un punto final configurable en unAWS-dominio administrado mediante
elCreateDomainConfigurationAPI. Una configuración de dominio para un dominio administrado por AWS
consta de lo siguiente:

• domainConfigurationName

Un nombre definido por el usuario que identifique la configuración del dominio y el valor debe ser
exclusivo de suRegión de AWS. No puede usar nombres de configuración de dominio que comiencen
conIoT:porque están reservados para los puntos finales predeterminados.
• defaultAuthorizerName (opcional)

El nombre del autorizador personalizado que se utilizará en el punto final.

• allowAuthorizerOverride

Un valor booleano que especifica si los dispositivos pueden anular el autorizador predeterminado
especificando un autorizador diferente en el encabezado HTTP de la solicitud. Este valor es obligatorio si
se especifica un valor para defaultAuthorizerName.
• serviceType

El tipo de servicio que ofrece el endpoint.AWS IoT Coresolo es compatible conDATAtipo de

servicio. Cuando especifiquesDATA,AWS IoT Coredevuelve un punto final con un tipo de punto final
deiot:Data-ATS. No puedes crear un configurableiot:Data(VeriSign) punto final.
• TlsConfig (opcional)

Objeto que especifica la configuración de TLS para un dominio. Para obtener más información, consulte
??? (p. 134).

El siguiente ejemploAWS CLIel comando crea una configuración de dominio para unDatapunto final.

aws iot create-domain-configuration --domain-configuration-name "myDomainConfigurationName"

--service-type "DATA"

Creación y configuración de dominios personalizados

Las configuraciones de dominio permiten especificar un nombre de dominio completo (FQDN)
personalizado para conectarse a AWS IoT Core. Con los dominios personalizados, puede administrar sus

129
 AWS IoT Core Guía para desarrolladores
Terminales configurables

propios certificados de servidor para poder gestionar detalles, como la autoridad certificadora (CA) raíz
utilizada para firmar el certificado, el algoritmo de firma, la profundidad de la cadena de certificados y el
ciclo de vida del certificado.

El flujo de trabajo para establecer una configuración de dominio con un dominio personalizado consta de
las tres etapas siguientes.

1. Registro de certificados de servidor en AWS Certificate Manager (p. 130)

2. Creación de una configuración de dominio (p. 131)
3. Creación de registros DNS (p. 132)

Registro de certificados de servidor enAWSadministrador de certificados

Antes de crear una configuración de dominio con un dominio personalizado, debe registrar la cadena de
certificados de su servidor enAWS Certificate Manager(CM). Puede utilizar los tres tipos de certificados de
servidor siguientes.

• Certificados públicos generados por ACM (p. 131)

• Certificados externos firmados por una entidad emisora de certificación pública (p. 131)
• Certificados externos firmados por una entidad emisora de certificación privada (p. 131)

Note

AWS IoT Core considera que un certificado está firmado por una entidad de certificación pública
(CA) si está incluido en el paquete de CA de confianza de Mozilla.

Requisitos de certificado

ConsulteRequisitos previos para la importación de certificadospara conocer los requisitos para importar
certificados a ACM. Además de estos requisitos,AWS IoT Coreañade los siguientes requisitos.

• El certificado foliar debe incluir elUso extendido de clavesextensión x509 v3 con un valor
deAutenticación del servidor(Autenticación de servidor web TLS). Si solicita el certificado a ACM, esta
extensión se agrega automáticamente.
• La profundidad máxima de la cadena de certificados es de 5 certificados.
• El tamaño máximo de la cadena de certificados es de 16 KB.
• El tamaño de la clave del certificado es 2048.

Uso de un certificado para varios dominios

Si tiene previsto utilizar un certificado para cubrir varios subdominios, utilice un dominio comodín
en el campo Nombre común (CN) o Nombres alternativos del firmante (SAN). Por ejemplo, utilice
*.iot.example.com para cubrir dev.iot.example.com, qa.iot.example.com y prod.iot.example.com.
Cada FQDN requiere su propia configuración de dominio, pero varias configuraciones de dominio pueden
usar el mismo valor comodín. El CN o el SAN deben cubrir el FQDN que desea utilizar como dominio
personalizado. Si hay SAN, se ignora la CN y una SAN debe cubrir el FQDN que desea usar como dominio
personalizado. Esta cobertura puede ser una coincidencia exacta o una coincidencia de caracteres
comodín. Una vez validado y registrado un certificado comodín en una cuenta, se impide que otras cuentas
de la región creen dominios personalizados que se superpongan con el certificado.

En las siguientes secciones se describe cómo obtener cada tipo de certificado. Cada recurso de certificado
requiere un nombre de recurso de Amazon (ARN) registrado en ACM que utilice al crear la configuración
de su dominio.

130
 AWS IoT Core Guía para desarrolladores
Terminales configurables

Certificados públicos generados por ACM

Puede generar un certificado público para su dominio personalizado mediante elRequestCertificateAPI. Al

generar un certificado de esta manera, ACM valida su propiedad del dominio personalizado. Para obtener
más información, consulte Solicitud de un certificado público en la Guía del usuario de AWS Certificate
Manager.

Certificados externos firmados por una entidad emisora de certificación pública

Si ya tienes un certificado de servidor firmado por una CA pública (una CA que se incluye en el paquete
de CA de confianza de Mozilla), puedes importar la cadena de certificados directamente a ACM
medianteImportCertificateAPI. Para obtener más información sobre esta tarea, los requisitos previos y los
requisitos de formato de certificado, consulte Importación de certificados.

Certificados externos firmados por una entidad emisora de certificación privada

Si ya tiene un certificado de servidor firmado por una CA privada o autofirmado, puede usar el certificado
para crear la configuración de su dominio, pero también debe crear un certificado público adicional en
ACM para validar la propiedad de su dominio. Para ello, registre la cadena de certificados de su servidor
en ACM mediante elImportCertificateAPI. Para obtener más información sobre esta tarea, los requisitos
previos y los requisitos de formato de certificado, consulte Importación de certificados.

Creación de un certificado de validación

Tras importar el certificado a ACM, genere un certificado público para su dominio personalizado mediante
elRequestCertificateAPI. Al generar un certificado de esta manera, ACM valida su propiedad del dominio
personalizado. Para obtener más información, consulte Solicitar un certificado público. Cuando cree la
configuración de dominio, utilice este certificado público como certificado de validación.

Crear una configuración de dominio

Para crear un punto de conexión configurable en un dominio personalizado, utilice
laCreateDomainConfigurationAPI. Una configuración de dominio para un dominio personalizado consta de
lo siguiente:

• domainConfigurationName

Nombre definido por el usuario que identifica la configuración del dominio. Los nombres de configuración
de dominio que comienzan por IoT: están reservados para los puntos de enlace predeterminados y no
se pueden usar. Además, este valor debe ser exclusivo de suRegión de AWS.
• domainName

El FQDN que utilizan sus dispositivos para conectarseAWS IoT Core.AWS IoT Coreaprovecha la
extensión TLS de indicación del nombre del servidor (SNI) para aplicar configuraciones de dominio. Los
dispositivos deben usar esta extensión al conectarse y pasar un nombre de servidor idéntico al nombre
de dominio especificado en la configuración del dominio.
• serverCertificateArns

El ARN de la cadena de certificados del servidor que registró en ACM.AWS IoT Coreactualmente solo
admite un certificado de servidor.
• validationCertificateArn

El ARN del certificado público que generó en ACM para validar la propiedad de su dominio
personalizado. Este argumento no es obligatorio si utiliza un certificado de servidor generado por ACM o
firmado públicamente.
• defaultAuthorizerName (optional)

El nombre del autorizador personalizado que se utilizará en el punto final.

131
 AWS IoT Core Guía para desarrolladores
Terminales configurables

• allowAuthorizerOverride

Un valor booleano que especifica si los dispositivos pueden anular el autorizador predeterminado
especificando un autorizador diferente en el encabezado HTTP de la solicitud. Este valor es obligatorio si
se especifica un valor para defaultAuthorizerName.
• serviceType

AWS IoT Core actualmente solo admite el tipo de servicio DATA. Cuando especifiquesDATA,AWS
IoTdevuelve un punto final con un tipo de punto final deiot:Data-ATS.
• TlsConfig (opcional)

Objeto que especifica la configuración de TLS para un dominio. Para obtener más información, consulte
??? (p. 134).

El siguiente comando de la AWS CLI crea una configuración de dominio para iot.example.com.

aws iot create-domain-configuration --domain-configuration-name "myDomainConfigurationName"

--service-type "DATA"
--domain-name "iot.example.com" --server-certificate-arns serverCertARN --validation-
certificate-arn validationCertArn

Note

Después de crear la configuración de dominio, pueden pasar hasta 60 minutos hasta queAWS IoT
Coresirve sus certificados de servidor personalizados.

Para obtener más información, consulte ??? (p. 133).

Creación de registros DNS

Después de registrar la cadena de certificados de servidor y crear la configuración de dominio, cree un
registro DNS para que el dominio personalizado apunte a un dominio de AWS IoT. Este registro debe
apuntar a un punto de enlace de AWS IoT de tipo iot:Data-ATS. Puede obtener su punto de conexión
mediante elDescribeEndpointAPI.

Los siguientesAWS CLIel comando muestra cómo obtener su punto final.

aws iot describe-endpoint --endpoint-type iot:Data-ATS

Cuando tenga el punto de enlace iot:Data-ATS, cree un registro CNAME en el dominio personalizado
para este punto de enlace de AWS IoT. Si creas varios dominios personalizados en el mismoCuenta de
AWS, ponerles el alias de este mismoiot:Data-ATSpunto final.

Solución de problemas
Si tienes problemas para conectar dispositivos a un dominio personalizado, asegúrate de queAWS IoT
Coreha aceptado y aplicado su certificado de servidor. Puedes verificarloAWS IoT Coreha aceptado su
certificado mediante elAWS IoT Coreconsola oAWS CLI.

Para utilizar elAWS IoT Coreconsola, navega hasta laAjustespágina y seleccione el nombre de
configuración del dominio. En elDetalles del certificado de servidorsección, compruebe el estado y los
detalles del estado. Si el certificado no es válido, sustitúyalo en ACM por un certificado que cumpla
conrequisitos de certificado (p. 130)listados en la sección anterior. Si el certificado tiene el mismo
ARN,AWS IoT Corelo recogerá y lo aplicará automáticamente.

Para comprobar el estado del certificado mediante elAWS CLI, llame alDescribeDomainConfigurationUtilice
la API y especifique el nombre de configuración de su dominio.

132
 AWS IoT Core Guía para desarrolladores
Terminales configurables

Note
Si su certificado no es válido,AWS IoT Coreseguirá entregando el último certificado válido.

Puede comprobar qué certificado se entrega en su terminal mediante el siguiente comando openssl.

openssl s_client -connect custom-domain-name:8883 -showcerts -servername

custom-domain-name

Administrar configuraciones de dominio

Puede administrar los ciclos de vida de las configuraciones existentes mediante las siguientes API.

• ListDomainConfigurations
• DescribeDomainConfiguration
• UpdateDomainConfiguration
• DeleteDomainConfiguration

Visualización de configuraciones de dominio

Para mostrar una lista paginada de todas las configuraciones de dominio de suCuenta de AWS,
utilice elListDomainConfigurationsAPI. Puede ver los detalles de una configuración de dominio
determinada mediante laDescribeDomainConfigurationAPI. Esta API toma un único parámetro
domainConfigurationName y devuelve los detalles de la configuración especificada.

Ejemplo

Actualización de configuraciones de dominio

Para actualizar el estado o el autorizador personalizado de la configuración de su dominio, utilice
laUpdateDomainConfigurationAPI. Puede establecer el estado en ENABLED o DISABLED. Si deshabilita la
configuración del dominio, los dispositivos conectados a ese dominio recibirán un error de autenticación.
Actualmente no puede actualizar el certificado de servidor en la configuración de su dominio. Para cambiar
el certificado de una configuración de dominio, debe eliminarlo y volver a crearlo.

Ejemplo

Eliminar configuraciones de dominio

Antes de eliminar una configuración de dominio, utiliceUpdateDomainConfigurationAPI para establecer
el estado enDISABLED. Esto le ayuda a evitar que se elimine el punto de enlace por error. Después de
deshabilitar la configuración del dominio, elimínela mediante elDeleteDomainConfigurationAPI. Debes
colocarAWS-dominios gestionados enDISABLEDestado durante 7 días antes de poder eliminarlos. Puede
colocar dominios personalizados enDISABLEDestado y, a continuación, elimínelos inmediatamente.

Ejemplo

Después de eliminar una configuración de dominio, AWS IoT Core ya no sirve el certificado de servidor
asociado a ese dominio personalizado.

Certificados rotativos en dominios personalizados

Es posible que deba reemplazar periódicamente el certificado de servidor por un certificado actualizado. La
velocidad a la que lo haga depende del período de validez de su certificado. Si ha generado su certificado
de servidor medianteAWS Certificate Manager(ACM), puede configurar el certificado para que se renueve
automáticamente. Cuando ACM renueve su certificado,AWS IoT Corerecoge automáticamente el nuevo
certificado. No tiene que realizar ninguna acción adicional. Si ha importado su certificado de servidor
de una fuente diferente, puede rotarlo volviéndolo a importar a ACM. Para obtener información sobre la
reimportación de certificados, consulteVolver a importar un certificado.

133
 AWS IoT Core Guía para desarrolladores
Terminales configurables

Note
AWS IoT Coresolo recoge las actualizaciones de los certificados en las siguientes condiciones.

• El nuevo certificado tiene el mismo ARN que el anterior.

• El nuevo certificado tiene el mismo algoritmo de firma, nombre común o nombre alternativo de
asunto que el anterior.

Configuración de los ajustes de TLS en las configuraciones de

dominio
AWS IoT Coreproveepolíticas de seguridad predefinidas (p. 403)para personalizar la configuración
de seguridad de la capa de transporte (TLS) paraTLS 1.2yTLS 1.3en configuraciones de dominio. Una
política de seguridad es una combinación de protocolos TLS y sus cifrados que determinan los protocolos y
cifrados compatibles durante las negociaciones de TLS entre un cliente y un servidor. Con las políticas de
seguridad compatibles, puede administrar la configuración de TLS de sus dispositivos con más flexibilidad
y aplicar la mayor cantidadup-to-datemedidas de seguridad al conectar dispositivos nuevos y mantener
configuraciones de TLS consistentes para los dispositivos existentes.

La siguiente tabla describe las políticas de seguridad, sus versiones de TLS y las regiones compatibles:

Nombre de la política de Regiones de AWS admitidos

seguridad

IoTSecurityPolicy_TLS13_1_3_2022_10
TodosRegiones de AWS

IoTSecurityPolicy_TLS13_1_2_2022_10
TodosRegiones de AWS

IoTSecurityPolicy_TLS12_1_2_2022_10
TodosRegiones de AWS

IoTSecurityPolicy_TLS12_1_0_2016_01
ap-este-1, ap-norte-2, ap-sur-1, ap-sudeast-2, ca-central-1, cn-norte-1, cn-
noroeste-1, eu-norte1, eu-oeste-2, eu-oeste-3, me-sur-1, sa-este-2,us-gov-
west-1,us-gov-west-2, US-oeste-1

IoTSecurityPolicy_TLS12_1_0_2015_01
ap-nordeste-1, ap-sudeast-1, EU-centro-1, EU-oeste-1, EE. UU. Este-2

Los nombres de las políticas de seguridad enAWS IoT Coreincluyen información sobre la versión en
función del año y el mes en que se publicaron. Si crea una nueva configuración de dominio, la política de
seguridad se establecerá de forma predeterminada enIoTSecurityPolicy_TLS13_1_2_2022_10.
Para obtener una tabla completa de políticas de seguridad con detalles de los protocolos, los puertos TCP
y los cifrados, consultePolíticas de seguridad (p. 403).AWS IoT Coreno admite políticas de seguridad
personalizadas. Para obtener más información, consulte ??? (p. 402).

Para configurar los ajustes de TLS en las configuraciones de dominio, puede utilizar laAWS IoTconsola
oAWS CLI.

Contenido
• Configurar los ajustes de TLS en las configuraciones de dominio (consola) (p. 134)
• Configurar los ajustes de TLS en las configuraciones de dominio (CLI) (p. 135)

Configurar los ajustes de TLS en las configuraciones de dominio (consola)

Para configurar los ajustes de TLS mediante elAWS IoTconsola

1. Inicie sesión en la AWS Management Console y abra la consola de AWS IoT.

134
 AWS IoT Core Guía para desarrolladores
Terminales configurables

2. Para configurar los ajustes de TLS al crear una nueva configuración de dominio, siga estos pasos.

1. En el panel de navegación de la izquierda, seleccionaAjustes, y luego, desdeConfiguraciones de

dominiosección, eligeCrear configuración de dominio.
2. En elCrear configuración de dominiopágina, en elConfiguración de dominio personalizada
-opcionalsección, elija una política de seguridad deSeleccione la política de seguridad.
3. Sigue el widget y completa el resto de los pasos. EligeCrear configuración de dominio.
3. Para actualizar la configuración de TLS en una configuración de dominio existente, sigue estos pasos.

1. En el panel de navegación de la izquierda, seleccionaAjustes, y luego, enConfiguraciones de

dominio, elija una configuración de dominio.
2. En elDetalles de configuración del dominiopágina, eligeEditar. Luego, en elConfiguración de
dominio personalizada -opcionalsección, enSeleccione la política de seguridad, elija una política de
seguridad.
3. EligeActualizar la configuración del dominio.

Para obtener más información, consulteCrear una configuración de dominioyAdministrar configuraciones

de dominio (p. 133).

Configurar los ajustes de TLS en las configuraciones de dominio (CLI)

Puede utilizar elcreate-domain-configurationyupdate-domain-configurationComandos de CLI para
configurar la configuración de TLS en las configuraciones de dominio.

1. Para especificar la configuración de TLS mediantecreate-domain-configurationComando CLI:

aws iot create-domain-configuration \

--domain-configuration-name domainConfigurationName \
--tls-config securityPolicy=IoTSecurityPolicy_TLS13_1_2_2022_10

El resultado de este comando puede tener el siguiente aspecto:

{
"domainConfigurationName": "test",
"domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/
test/34ga9"
}

Si crea una nueva configuración de dominio sin especificar la política de seguridad, el valor
predeterminado será:IoTSecurityPolicy_TLS13_1_2_2022_10.
2. Para describir la configuración de TLS mediantedescribe-domain-configurationComando CLI:

aws iot describe-domain-configuration \

--domain-configuration-name domainConfigurationName

Este comando puede devolver los detalles de configuración del dominio que incluyen la configuración de
TLS, como se muestra a continuación:

{
"tlsConfig": {
"securityPolicy": "IoTSecurityPolicy_TLS13_1_2_2022_10"
},
"domainConfigurationStatus": "ENABLED",
"serviceType": "DATA",
"domainType": "AWS_MANAGED",

135
 AWS IoT Core Guía para desarrolladores
Conectarse aAWS IoTTerminales FIPS

"domainName": "d1234567890abcdefghij-ats.iot.us-west-2.amazonaws.com",
"serverCertificates": [],
"lastStatusChangeDate": 1678750928.997,
"domainConfigurationName": "test",
"domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/
test/34ga9"
}

3. Para actualizar la configuración de TLS medianteupdate-domain-configurationComando CLI:

aws iot update-domain-configuration \

--domain-configuration-name domainConfigurationName \
--tls-config securityPolicy=IoTSecurityPolicy_TLS13_1_2_2022_10

El resultado de este comando puede tener el siguiente aspecto:

{
"domainConfigurationName": "test",
"domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/
test/34ga9"
}

4. Para actualizar la configuración de TLS de su terminal de ATS, ejecute elupdate-domain-

configurationComando CLI. El nombre de configuración de dominio de su terminal de ATS
esiot:Data-ATS.

aws iot update-domain-configuration \

--domain-configuration-name "iot:Data-ATS" \
--tls-config securityPolicy=IoTSecurityPolicy_TLS13_1_2_2022_10

El resultado del comando puede tener el siguiente aspecto:

{
"domainConfigurationName": "iot:Data-ATS",
"domainConfigurationArn": "arn:aws:iot:us-west-2:123456789012:domainconfiguration/
iot:Data-ATS"
}

Para obtener más información consulte CreateDomainConfiguration y UpdateDomainConfiguration en la

Referencia de la API de AWS.

Conectarse aAWS IoTTerminales FIPS

AWS IoTproporciona puntos de conexión que admiten laNorma Federal de Procesamiento de Información
(FIPS) 140-2. Los terminales que cumplen con FIPS son diferentes de los estándaresAWSpuntos finales.
Para interactuar conAWS IoTde manera que cumpla con la FIPS, debe utilizar los puntos de conexión que
se describen a continuación con su cliente que cumpla con la FIPS. ElAWS IoTla consola no cumple con
FIPS.

En las siguientes secciones se describe cómo acceder a la normativa FIPS.AWS IoTpuntos de conexión
mediante la API REST, un SDK o elAWS CLI.

Temas
• AWS IoT Core- puntos finales del plano de control (p. 137)
• AWS IoT Core- puntos finales del plano de datos (p. 137)

136
 AWS IoT Core Guía para desarrolladores
AWS IoT Core- puntos finales del plano de control

• AWS IoT Device Management- puntos finales de datos de trabajos (p. 137)
• AWS IoT Device Management- Terminales Fleet Hub (p. 138)
• AWS IoT Device Management- puntos finales de tunelización seguros (p. 138)

AWS IoT Core- puntos finales del plano de control

Cumple con FIPSAWS IoT Core- plano de controlpuntos de conexión que admiten laAWS IoToperaciones
y sus operaciones relacionadasComandos de CLIfiguran enTerminales FIPS por servicio. EnTerminales
FIPS por servicio, encuentra elAWS IoT Core- plano de controlservicio y busque el punto final para
suRegión de AWS.

Para utilizar el punto final que cumple con la FIPS al acceder alAWS IoToperaciones, utilice elAWSEl SDK
o la API REST con el punto de conexión adecuado para suRegión de AWS.

Para utilizar el punto de conexión compatible con FIPS cuando ejecutaaws iotComandos de CLI, añada el--
endpointparámetro con el punto final adecuado para suRegión de AWSal comando.

AWS IoT Core- puntos finales del plano de datos

Cumple con FIPSAWS IoT Core- plano de datoslos puntos finales se enumeran enTerminales FIPS por
servicio. EnTerminales FIPS por servicio, encuentra elAWS IoT Core- plano de datosservicio y busque el
punto final para suRegión de AWS.

Puede utilizar el terminal compatible con FIPS para suRegión de AWScon un cliente compatible con
FIPS mediante elAWS IoTSDK del dispositivo y proporcionar el punto final a la función de conexión del
SDK en lugar de la predeterminada de tu cuentaAWS IoT Core- plano de datospunto final. La función de
conexión es específica deAWS IoTSDK de dispositivos. Para ver un ejemplo de una función de conexión,
consulteFunción de conexión en elAWS IoTSDK de dispositivos para Python.
Note

AWS IoTno admiteCuenta de AWS-específicoAWS IoT Core- plano de datospuntos de conexión

que cumplen con FIPS. Características del servicio que requieren unCuenta de AWS-punto
final específico en elIndicación del nombre del servidor (SNI) (p. 402)no se puede usar.
Cumple con FIPSAWS IoT Core- plano de datoslos endpoints no pueden admitirCertificados
de registro de múltiples cuentas (p. 315),Dominios personalizados (p. 129),Autorizadores
personalizados (p. 337), yTerminales configurables (p. 128)(incluido el compatiblePolíticas de
TLS (p. 403)).

AWS IoT Device Management- puntos finales de datos

de trabajos
Cumple con FIPSAWS IoT Device Management- datos de empleoslos puntos finales se enumeran
enTerminales FIPS por servicio. EnTerminales FIPS por servicio, encuentra elAWS IoT Device
Management- datos de empleosservicio y busque el punto final para suRegión de AWS.

Para utilizar la norma FIPSAWS IoT Device Management- datos de empleospunto final cuando corresaws
iot-jobs-dataComandos CLI, añada el--endpointparámetro con el punto final adecuado para suRegión de
AWSal comando. También puede utilizar la API REST con este punto de conexión.

Puede utilizar el terminal compatible con FIPS para suRegión de AWScon un cliente compatible con FIPS
mediante elAWS IoTSDK del dispositivo y proporcionar el punto final a la función de conexión del SDK en
lugar de la predeterminada de tu cuentaAWS IoT Device Management- datos de empleospunto final. La
función de conexión es específica deAWS IoTSDK de dispositivos. Para ver un ejemplo de una función de
conexión, consulteFunción de conexión en elAWS IoTSDK de dispositivos para Python.

137
 AWS IoT Core Guía para desarrolladores
AWS IoT Device Management- Terminales Fleet Hub

AWS IoT Device Management- Terminales Fleet Hub

Cumple con FIPSAWS IoT Device Management- Centro de flotaspuntos finales para usar conFleet Hub
paraAWS IoTAdministración de dispositivos Comandos de CLIfiguran enTerminales FIPS por servicio.
EnTerminales FIPS por servicio, encuentra elAWS IoT Device Management- Centro de flotasservicio y
busque el punto final para suRegión de AWS.

Para utilizar la norma FIPSAWS IoT Device Management- Centro de flotaspunto final cuando corresaws
iotfleethubComandos de CLI, añada el--endpointparámetro con el punto final adecuado para suRegión de
AWSal comando. También puede utilizar la API REST con este punto de conexión.

AWS IoT Device Management- puntos finales de

tunelización seguros
Cumple con FIPSAWS IoT Device Management- construcción segura de túnelespuntos finales para
elAWS IoTAPI de tunelización seguray el correspondienteComandos de CLIfiguran enTerminales FIPS por
servicio. EnTerminales FIPS por servicio, encuentra elAWS IoT Device Management- construcción segura
de túnelesservicio y busque el punto final para suRegión de AWS.

Para utilizar la norma FIPSAWS IoT Device Management- construcción segura de túnelespunto final
cuando corresaws iotsecuretunnelingComandos CLI, añada el--endpointparámetro con el punto final
adecuado para suRegión de AWSal comando. También puede utilizar la API REST con este punto de
conexión.

138
 AWS IoT Core Guía para desarrolladores
Creación de demostraciones con
elAWS IoTCliente del dispositivo

Tutoriales de AWS IoT

LaAWS IoTlos tutoriales se dividen en dos vías de aprendizaje para apoyar dos objetivos diferentes. Elige
la mejor ruta de aprendizaje para tu objetivo.

• Quieres construir un proof-of-concept para probar o demostrar unAWS IoTidea de solución

Para demostrar tareas y aplicaciones comunes de IoT mediante elAWS IoTDevice Client en tus
dispositivos, sigue lathe section called “Creación de demostraciones con elAWS IoTCliente del
dispositivo” (p. 139)ruta de aprendizaje. LaAWS IoTDevice Client proporciona software de dispositivo
con el que puede aplicar sus propios recursos en la nube para demostrar un end-to-end solución con un
desarrollo mínimo.

Para obtener más información acerca de laAWS IoTDevice Client, consulte laAWS IoTCliente del
dispositivo.
• Desea aprender a crear software de producción para implementar su solución

Para crear su propio software de solución que cumpla con sus requisitos específicos mediante unAWS
IoTSDK del dispositivo, siga elthe section called “Creación de soluciones con elAWS IoTSDKs de
dispositivos” (p. 191)ruta de aprendizaje.

Para obtener más información acerca de los disponiblesAWS IoTSDKs de dispositivos,

consulte??? (p. 1489). Para obtener más información acerca de laAWSSDKs, consulteHerramientas
sobre las que basarseAWS.

AWS IoTopciones de ruta de aprendizaje tutorial

• Creación de demostraciones con elAWS IoTCliente del dispositivo (p. 139)
• Creación de soluciones con elAWS IoTSDKs de dispositivos (p. 191)

Creación de demostraciones con elAWS IoTCliente

del dispositivo
Los tutoriales de esta ruta de aprendizaje le guiarán por los pasos para desarrollar software de
demostración mediante elAWS IoTCliente del dispositivo. LaAWS IoTDevice Client proporciona software
que se ejecuta en su dispositivo IoT para probar y demostrar aspectos de una solución IoT basada enAWS
IoT.

El objetivo de estos tutoriales es facilitar la exploración y la experimentación para que puedas estar seguro
de queAWS IoTes compatible con la solución antes de desarrollar el software del dispositivo.

Lo que aprenderás en estos tutoriales:

• Cómo preparar un Raspberry Pi para usarlo como dispositivo IoT conAWS IoT
• Cómo demostrarAWS IoTfunciones mediante elAWS IoTDevice Client en el dispositivo

En esta ruta de aprendizaje, instalará elAWS IoTDevice Client en tu propio Raspberry Pi y crea elAWS
IoTrecursos en la nube para demostrar ideas de soluciones de IoT. Si bien los tutoriales de esta ruta

139
 AWS IoT Core Guía para desarrolladores
Requisitos previos para crear demostraciones
con elAWS IoTCliente del dispositivo

de aprendizaje muestran características mediante el uso de una Raspberry Pi, explican los objetivos y
procedimientos para ayudarle a adaptarlos a otros dispositivos.

Requisitos previos para crear demostraciones con

elAWS IoTCliente del dispositivo
En esta sección se describe lo que debe tener antes de iniciar los tutoriales en esta ruta de aprendizaje.

Para completar los tutoriales en esta ruta de aprendizaje, necesitará:

• Una Cuenta de AWS

Puede utilizar su existenteCuenta de AWS, si tienes uno, pero es posible que tengas que añadir
funciones o permisos adicionales para usar elAWS IoTcaracterísticas que utilizan estos tutoriales.

Si necesita crear una nuevaCuenta de AWS, consultethe section called “Configura tuCuenta de
AWS” (p. 19).
• Raspberry Pi o dispositivo IoT compatible

Los tutoriales utilizan unRaspberry Piporque viene en diferentes factores de forma, es omnipresente y es
un dispositivo de demostración relativamente económico. Los tutoriales se han probado en laRaspberry
Pi 3 Modelo B+, elRaspberry Pi 4 Modelo By en una instancia de Amazon EC2 que ejecuta Ubuntu
Server 20.04 LTS (HVM). Para utilizar elAWS CLIy ejecute los comandos, le recomendamos que utilice
la última versión del Raspberry Pi OS (Raspberry Pi OS (64 bits)o OS Lite). Las versiones anteriores del
sistema operativo podrían funcionar, pero no lo hemos probado.
Note

Los tutoriales explican los objetivos de cada paso para ayudarle a adaptarlos al hardware
de IoT en el que no los hemos probado; sin embargo, no describen específicamente cómo
adaptarlos a otros dispositivos.
• Familiaridad con el sistema operativo del dispositivo IoT

En los pasos de estos tutoriales se supone que está familiarizado con el uso de comandos y operaciones
básicos de Linux desde la interfaz de línea de comandos compatible con Raspberry Pi. Si no estás
familiarizado con estas operaciones, tal vez quieras dedicarte más tiempo para completar los tutoriales.

Para completar estos tutoriales, ya debe comprender cómo:

• Realice operaciones básicas del dispositivo de forma segura, como ensamblar y conectar
componentes, conectar el dispositivo a las fuentes de alimentación necesarias e instalar y quitar
tarjetas de memoria.
• Cargue y descargue el software y los archivos del sistema en el dispositivo. Si el dispositivo no utiliza
un dispositivo de almacenamiento extraíble, como una tarjeta microSD, tendrá que saber cómo
conectarse al dispositivo y cargar y descargar el software del sistema y los archivos en el dispositivo.
• Connect tu dispositivo a las redes en las que planeas usarlo.
• Connect al dispositivo desde otro equipo mediante un terminal SSH o un programa similar.
• Utilice una interfaz de línea de comandos para crear, copiar, mover, cambiar el nombre y establecer
los permisos de los archivos y directorios del dispositivo.
• Instale nuevos programas en el dispositivo.
• Transfiera archivos desde y hacia su dispositivo mediante herramientas como FTP o SCP.
• Un entorno de desarrollo y pruebas para su solución IoT

Los tutoriales describen el software y el hardware necesarios; sin embargo, los tutoriales suponen
que podrá realizar operaciones que podrían no describirse explícitamente. Algunos ejemplos de este
hardware y operaciones incluyen:

140
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

• Un equipo host local en el que descargar y almacenar archivos

Para el Raspberry Pi, suele ser un ordenador personal o portátil que puede leer y escribir en tarjetas
de memoria microSD. El equipo host local debe:
• Conectarse a Internet.
• Tenga laAWS CLIinstalada y configurada.
• Disponer de un navegador web que admita laAWSconsola de .
• Una forma de conectar el equipo host local al dispositivo para comunicarse con él, introducir
comandos y transferir archivos

En Raspberry Pi, esto se hace a menudo utilizando SSH y SCP desde el equipo host local.
• Monitor y teclado para conectarse al dispositivo IoT

Estos pueden ser útiles, pero no son necesarios para completar los tutoriales.
• Una forma de que el equipo host local y los dispositivos IoT se conecten a Internet

Podría ser una conexión de red por cable o inalámbrica a un router o puerta de enlace que está
conectado a Internet. El host local también debe poder conectarse a Raspberry Pi. Esto podría
requerir que estén en la misma red de área local. Los tutoriales no pueden mostrarle cómo
configurarlo para la configuración de su dispositivo o dispositivo en particular, pero muestran cómo
puede probar esta conectividad.
• Acceso al enrutador de la red de área local para ver los dispositivos conectados

Para completar los tutoriales de esta ruta de aprendizaje, tendrás que poder encontrar la dirección IP
de tu dispositivo IoT.

En una red de área local, esto se puede hacer accediendo a la interfaz de administración del router de
red al que se conectan los dispositivos. Si puede asignar una dirección IP fija para su dispositivo en el
router, puede simplificar la reconexión cada vez que se reinicie el dispositivo.

Si tienes un teclado y un monitor conectados al dispositivo,ifconfigpuede mostrar la dirección IP del

dispositivo.

Si ninguna de estas opciones es una opción, tendrás que encontrar una forma de identificar la
dirección IP del dispositivo después de cada vez que se reinicie.

Después de tener todos sus materiales, continúethe section called “Preparación de los dispositivos para
elAWS IoTCliente del dispositivo” (p. 141).

Tutoriales en esta trayectoria de aprendizaje

• Tutorial: Preparación de los dispositivos para elAWS IoTCliente del dispositivo (p. 141)
• Tutorial: Instalar y configurar elAWS IoTCliente del dispositivo (p. 151)
• Tutorial: Demostrar la comunicación de mensajes MQTT con elAWS IoTCliente del
dispositivo (p. 160)
• Tutorial: Demuestre acciones remotas (trabajos) con elAWS IoTDispositivo de cliente (p. 174)
• Tutorial: Cómo limpiar después de ejecutar los tutoriales de AWS IoT Device Client (p. 184)

Tutorial: Preparación de los dispositivos para elAWS

IoTCliente del dispositivo
Este tutorial le guiará por la inicialización de su Raspberry Pi para prepararlo para los tutoriales posteriores
en esta ruta de aprendizaje.

141
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

El objetivo de este tutorial es instalar la versión actual del sistema operativo del dispositivo y asegurarse de
que puede comunicarse con el dispositivo en el contexto de su entorno de desarrollo.

Para comenzar este tutorial:

• Haga que los artículos estén listados enthe section called “Requisitos previos para crear demostraciones
con elAWS IoTCliente del dispositivo” (p. 140)disponible y listo para su uso.

Este tutorial tarda unos 90 minutos en completarse.

Cuando haya terminado este tutorial:

• El dispositivo IoT tendrá un sistema operativo actualizado.

• El dispositivo IoT tendrá el software adicional que necesita para los tutoriales posteriores.
• Sabrá que su dispositivo tiene conectividad a Internet.
• Habrá instalado un certificado obligatorio en su dispositivo.

Después de completar este tutorial, el siguiente tutorial prepara el dispositivo para las demostraciones que
utilizan elAWS IoTCliente del dispositivo.

Procedimientos de este tutorial

• Paso 1: Instalación y actualización del sistema operativo del dispositivo (p. 142)
• Paso 2: Instala y verifica el software necesario en tu dispositivo (p. 145)
• Paso 3: Probar el dispositivo y guardar el certificado de CA de Amazon (p. 148)

Paso 1: Instalación y actualización del sistema operativo del

dispositivo
Los procedimientos de esta sección describen cómo inicializar la tarjeta microSD que la Raspberry Pi
utiliza para su unidad de sistema. La tarjeta microSD de Raspberry Pi contiene su software de sistema
operativo (SO) así como espacio para el almacenamiento de archivos de su aplicación. Si no utilizas
un Raspberry Pi, sigue las instrucciones del dispositivo para instalar y actualizar el software del sistema
operativo del dispositivo.

Después de completar esta sección, debería poder iniciar el dispositivo IoT y conectarse a él desde el
programa terminal de su equipo host local.

Equipo requerido:

• Su entorno de pruebas y desarrollo local

• Un Raspberry Pi que o su dispositivo IoT se puede conectar a Internet
• Tarjeta de memoria microSD con al menos 8 GB de capacidad o almacenamiento suficiente para el
sistema operativo y el software requerido.
Note

Al seleccionar una tarjeta microSD para estos ejercicios, elija una que sea lo más grande que
sea necesario pero, lo más pequeña posible.
Una pequeña tarjeta SD será más rápida de realizar copias de seguridad y actualización. En
Raspberry Pi, no necesitarás más de una tarjeta microSD de 8 GB para estos tutoriales. Si
necesita más espacio para su aplicación específica, los archivos de imagen más pequeños que
guarde en estos tutoriales pueden cambiar el tamaño del sistema de archivos en una tarjeta
más grande para utilizar todo el espacio admitido de la tarjeta que elija.

142
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

Equipamiento opcional:

• Un teclado USB conectado al Raspberry Pi

• Un monitor HDMI y un cable para conectar el monitor al Raspberry Pi

Procedimientos de esta sección:

• Cargue el sistema operativo del dispositivo en la tarjeta microSD (p. 143)
• Inicie su dispositivo IoT con el nuevo sistema operativo (p. 143)
• Connect el equipo host local al dispositivo (p. 144)

Cargue el sistema operativo del dispositivo en la tarjeta microSD

Este procedimiento utiliza el equipo host local para cargar el sistema operativo del dispositivo en una
tarjeta microSD.
Note

Si el dispositivo no utiliza un medio de almacenamiento extraíble para su sistema operativo,

instale el sistema operativo siguiendo el procedimiento correspondiente a ese dispositivo y
continúethe section called “Inicie su dispositivo IoT con el nuevo sistema operativo” (p. 143).

Para instalar el sistema operativo en su Raspberry Pi

1. En el equipo host local, descargue y descomprima la imagen del sistema operativo Raspberry Pi
que desea utilizar. Las últimas versiones están disponibles enhttps://www.raspberrypi.com/software/
operating-systems/

Elegir una versión de Raspberry Pi OS

En este tutorial se utilizaRaspberry Pi OS Liteversión porque es la versión más pequeña que admite
estos tutoriales en esta ruta de aprendizaje. Esta versión del sistema operativo Raspberry Pi solo
tiene una interfaz de línea de comandos y no tiene interfaz gráfica de usuario. Una versión del último
sistema operativo Raspberry Pi con una interfaz gráfica de usuario también funcionará con estos
tutoriales; sin embargo, los procedimientos descritos en esta ruta de aprendizaje utilizan únicamente la
interfaz de línea de comandos para realizar operaciones en Raspberry Pi.
2. Inserte la tarjeta microSD en el equipo host local.
3. Con una herramienta de imagen de tarjetas SD, escriba el archivo de imagen del sistema operativo
descomprimido en la tarjeta microSD.
4. Después de escribir la imagen del sistema operativo Raspberry Pi en la tarjeta microSD:

a. Abra la partición BOOT de la tarjeta microSD en una ventana de línea de comandos o en una
ventana del explorador de archivos.
b. En la partición BOOT de la tarjeta microSD, en el directorio raíz, cree un archivo vacío
denominadosshsin extensión de archivo ni contenido. Esto indica a Raspberry Pi que active las
comunicaciones SSH la primera vez que se inicia.
5. Expulsa la tarjeta microSD y quítala de forma segura del equipo host local.

Su tarjeta microSD está lista parathe section called “Inicie su dispositivo IoT con el nuevo sistema
operativo” (p. 143).

Inicie su dispositivo IoT con el nuevo sistema operativo

Este procedimiento instala la tarjeta microSD e inicia la Raspberry Pi por primera vez utilizando el sistema
operativo descargado.

143
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

Para iniciar el dispositivo IoT con el nuevo sistema operativo

1. Con la alimentación desconectada del dispositivo, inserte la tarjeta microSD del paso anterior,the
section called “Cargue el sistema operativo del dispositivo en la tarjeta microSD” (p. 143), en el
Raspberry Pi.
2. Connect del dispositivo a una red cableada.
3. Estos tutoriales interactuarán con su Raspberry Pi desde su equipo host local mediante un terminal
SSH.

Si también quieres interactuar directamente con el dispositivo, puedes:

a. Connect un monitor HDMI a él para ver los mensajes de la consola de Raspberry Pi antes de
poder conectar la ventana del terminal del equipo host local a la Raspberry Pi.
b. Connect un teclado USB si quieres interactuar directamente con la Raspberry Pi.
4. Connect la alimentación a la Raspberry Pi y espera alrededor de un minuto para que se inicialice.

Si tienes un monitor conectado a tu Raspberry Pi, puedes ver el proceso de inicio en él.
5. Averigua la dirección IP de tu dispositivo:

• Si ha conectado un monitor HDMI a Raspberry Pi, la dirección IP aparece en los mensajes

mostrados en el monitor
• Si tiene acceso al router al que se conecta Raspberry Pi, puede ver su dirección en la interfaz de
administración del router.

Cuando tenga la dirección IP de su Raspberry Pi, estará listo parathe section called “Connect el equipo
host local al dispositivo” (p. 144).

Connect el equipo host local al dispositivo

Este procedimiento utiliza el programa de terminal del equipo host local para conectarse a Raspberry Pi y
cambiar su contraseña predeterminada.

Para conectar el equipo host local al dispositivo

1. En el equipo host local, abra el programa terminal SSH:

• Windows: PuTTY
• Linux/macOS:Terminal

Note

PuTTY no se instala automáticamente en Windows. Si no está en el equipo, tal vez tenga que
descargarlo e instalarlo.
2. Connect el programa de terminal a la dirección IP de Raspberry Pi e inicie sesión con sus credenciales
predeterminadas.

username: pi
password: raspberry

3. Después de iniciar sesión en Raspberry Pi, cambie la contraseña delpiusuario.

passwd

Siga las instrucciones para cambiar la contraseña.

144
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

Changing password for pi.

Current password: raspberry
New password: YourNewPassword
Retype new password: YourNewPassword
passwd: password updated successfully

Después de tener el símbolo de línea de comandos de Raspberry Pi en la ventana del terminal y cambiar
la contraseña, estará listo para continuarthe section called “Paso 2: Instala y verifica el software necesario
en tu dispositivo” (p. 145).

Paso 2: Instala y verifica el software necesario en tu dispositivo

Los procedimientos de esta sección continúan desdela sección anterior (p. 142)para actualizar el sistema
operativo de Raspberry Pi e instalar el software en Raspberry Pi que se utilizará en la siguiente sección
para compilar e instalar elAWS IoTCliente del dispositivo.

Después de completar esta sección, su Raspberry Pi tendrá un sistema operativo actualizado, el software
requerido por los tutoriales de esta ruta de aprendizaje y se configurará para su ubicación.

Equipo requerido:

• Su entorno de pruebas y desarrollo local desdela sección anterior (p. 142)

• La Raspberry Pi que usaste enla sección anterior (p. 142)
• La tarjeta de memoria microSD dela sección anterior (p. 142)

Note

Raspberry Pi Model 3+ y Raspberry Pi Model 4 pueden ejecutar todos los comandos descritos
en esta ruta de aprendizaje. Si el dispositivo IoT no puede compilar software o ejecutar elAWS
Command Line Interface, es posible que tenga que instalar los compiladores necesarios en el
equipo host local para crear el software y, a continuación, transferirlo a su dispositivo IoT. Para
obtener más información sobre cómo instalar y crear software para su dispositivo, consulte la
documentación del software de su dispositivo.

Procedimientos de esta sección:

• Actualizar el software del sistema operativo (p. 145)
• Instale las aplicaciones y bibliotecas necesarias (p. 147)
• (Opcional) Guardar la imagen de la tarjeta microSD (p. 147)

Actualizar el software del sistema operativo

Este procedimiento actualiza el software del sistema operativo.

Para actualizar el software del sistema operativo en el dispositivo Raspberry Pi

Lleve a cabo estos pasos en la ventana de terminal del equipo host local.

1. Escriba estos comandos para actualizar el software del sistema en su Raspberry Pi.

sudo apt-get -y update

sudo apt-get -y upgrade
sudo apt-get -y autoremove

145
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

2. Actualice la configuración regional y de la zona horaria de Raspberry Pi (opcional).

Introduzca este comando para actualizar la configuración regional y la zona horaria del dispositivo.

sudo raspi-config

a. Para configurar la configuración regional del dispositivo:

i. En el navegadorHerramienta de configuración del software Raspberry Pi (raspi-

config)pantalla, elija la opción5.

5 Localisation Options Configure language and regional settings

UsarTabclave para moverse<Select>,y luego pulsespace bar.

ii. En el menú de opciones de localización, elija la opciónL1.

L1 Locale Configure language and regional settings

UsarTabclave para moverse<Select>,y luego pulsespace bar.

iii. En la lista de opciones de configuración regional, elija las configuraciones regionales que
desea instalar en su Raspberry Pi utilizando las teclas de flecha para desplazarse y elspace
barpara marcar los que quieres.

En los Estados Unidos,en_US.UTF-8es bueno para elegir.

iv. Después de seleccionar las configuraciones regionales de su dispositivo, utilice elTabclave
para elegir<OK>y, a continuación, pulsespace barPara visualizarConfiguración de
configuraciones regionalespágina de confirmación.
b. Para configurar la zona horaria del dispositivo:

i. En el navegadorraspi-configpantalla, elija la opción5.

5 Localisation Options Configure language and regional settings

UsarTabclave para moverse<Select>,y luego pulsespace bar.

ii. En el menú de opciones de localización, utilice la tecla de flecha para elegir la opciónL2:

L2 time zone Configure time zone

UsarTabclave para moverse<Select>,y luego pulsespace bar.

iii. En el navegadorConfiguración de tzdata, elija su área geográfica de la lista.

UsarTabclave para moverse<OK>y, a continuación, pulsespace bar.

iv. En la lista de ciudades, usa las teclas de flecha para elegir una ciudad de tu zona horaria.

Para configurar la zona horaria, utilice la opciónTabclave para moverse<OK>y, a

continuación, pulsespace bar.
c. Cuando haya terminado de actualizar la configuración, utilice elTabclave para moverse<Finish>y,
a continuación, pulsespace barpara cerrarraspi-configapp.
3. Escriba este comando para reiniciar el dispositivo Raspberry Pi.

sudo shutdown -r 0

4. Espere a que se reinicie su Raspberry Pi.

5. Una vez reiniciado su Raspberry Pi, vuelva a conectar la ventana del terminal de su equipo host local
a su Raspberry Pi.
146
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

El software del sistema Raspberry Pi ya está configurado y está listo para continuarthe section called
“Instale las aplicaciones y bibliotecas necesarias” (p. 147).

Instale las aplicaciones y bibliotecas necesarias

Este procedimiento instala el software de la aplicación y las bibliotecas que utilizan los tutoriales
posteriores.

Si utiliza una Raspberry Pi o si puede compilar el software necesario en su dispositivo IoT, lleve a cabo
estos pasos en la ventana del terminal del equipo host local. Si debe compilar software para su dispositivo
IoT en el equipo host local, consulte la documentación de software de su dispositivo IoT para obtener
información sobre cómo realizar estos pasos en el dispositivo.

Para instalar el software de aplicación y las bibliotecas en su Raspberry Pi

1. Introduzca este comando para instalar el software de la aplicación y las bibliotecas.

sudo apt-get -y install build-essential libssl-dev cmake unzip git python3-pip

2. Introduzca estos comandos para confirmar que se ha instalado la versión correcta del software.

gcc --version
cmake --version
openssl version
git --version

3. Confirme que estas versiones del software de la aplicación están instaladas:

• gcc: 9.3.0 o posterior

• cmake: 3.10.x o posterior
• OpenSSL: 1.1.1 o posterior
• git: 2.20.1 o posterior

Si su Raspberry Pi tiene versiones aceptables del software de aplicación requerido, está listo para
continuarthe section called “(Opcional) Guardar la imagen de la tarjeta microSD” (p. 147).

(Opcional) Guardar la imagen de la tarjeta microSD

A lo largo de los tutoriales de esta ruta de aprendizaje, encontrará estos procedimientos para guardar
una copia de la imagen de la tarjeta microSD de Raspberry Pi en un archivo del equipo host local. Si bien
se les anima, no son tareas obligatorias. Al guardar la imagen de la tarjeta microSD donde se sugiere,
puede omitir los procedimientos que preceden al punto de guardado en esta ruta de aprendizaje, lo que
puede ahorrar tiempo si encuentra la necesidad de volver a intentar algo. La consecuencia de no guardar
periódicamente la imagen de la tarjeta microSD es que es posible que tenga que reiniciar los tutoriales en
la ruta de aprendizaje desde el principio si la tarjeta microSD está dañada o si configura accidentalmente
una aplicación o sus ajustes incorrectamente.

En este punto, la tarjeta microSD de su Raspberry Pi tiene un sistema operativo actualizado y el software
básico de aplicación cargado. Puede ahorrar el tiempo que le tomó completar los pasos anteriores
guardando ahora el contenido de la tarjeta microSD en un archivo. Tener la imagen actual de la imagen de
la tarjeta microSD de tu dispositivo te permite comenzar desde este punto para continuar o volver a intentar
un tutorial o procedimiento sin necesidad de instalar y actualizar el software desde cero.

Para guardar la imagen de la tarjeta microSD en un archivo

1. Introduzca este comando para apagar la Raspberry Pi.

147
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

sudo shutdown -h 0

2. Después de que la Raspberry Pi se apague por completo, elimine su potencia.

3. Retire la tarjeta microSD de la Raspberry Pi.
4. En el equipo host local:

a. Inserta la tarjeta microSD.

b. Con la herramienta de imagen de la tarjeta SD, guarda la imagen de la tarjeta microSD en un
archivo.
c. Una vez guardada la imagen de la tarjeta microSD, expulsa la tarjeta del equipo host local.
5. Con la alimentación desconectada de la Raspberry Pi, inserta la tarjeta microSD en la Raspberry Pi.
6. Aplique energía al Raspberry Pi.
7. Después de esperar aproximadamente un minuto, en el equipo host local, vuelva a conectar la
ventana del terminal del equipo host local que estaba conectado a Raspberry Pi. y, a continuación,
inicie sesión en Raspberry Pi.

Paso 3: Probar el dispositivo y guardar el certificado de CA de

Amazon
Los procedimientos de esta sección continúan desdela sección anterior (p. 145)para instalar elAWS
Command Line Interfacey el certificado de entidad de certificación utilizado para autenticar sus conexiones
conAWS IoT Core.

Después de completar esta sección, sabrá que su Raspberry Pi tiene el software del sistema necesario
para instalar elAWS IoTDevice Client y que tiene una conexión funcional a Internet.

Equipo requerido:

• Su entorno de pruebas y desarrollo local desdela sección anterior (p. 145)

• La Raspberry Pi que usaste enla sección anterior (p. 145)
• La tarjeta de memoria microSD dela sección anterior (p. 145)

Procedimientos de esta sección:

• Instalar la AWS Command Line Interface (p. 148)
• Configuración de sus credenciales de Cuenta de AWS (p. 149)
• Descargar el certificado de entidad de certificación Amazon Root (p. 150)
• (Opcional) Guardar la imagen de la tarjeta microSD (p. 151)

Instalar la AWS Command Line Interface

Este procedimiento instala elAWS CLIen su Raspberry Pi.

Si utiliza una Raspberry Pi o si puede compilar software en su dispositivo IoT, lleve a cabo estos pasos en
la ventana del terminal del equipo host local. Si debe compilar software para su dispositivo IoT en el equipo
host local, consulte la documentación de software de su dispositivo IoT para obtener información sobre las
bibliotecas que necesita.

Para instalar elAWS CLIen su Raspberry Pi

1. Ejecute estos comandos para descargar e instalar elAWS CLI.

148
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

export PATH=$PATH:~/.local/bin # configures the path to include the directory with the
AWS CLI
git clone https://github.com/aws/aws-cli.git # download the AWS CLI code from GitHub
cd aws-cli && git checkout v2 # go to the directory with the repo and checkout version
2
pip3 install -r requirements.txt # install the prerequisite software

2. Ejecute este comando para instalar elAWS CLI. Este comando puede tardar hasta 15 minutos en
completarse.

pip3 install . # install the AWS CLI

3. Ejecute este comando para confirmar que la versión correcta delAWS CLIse instaló.

aws --version

La versión delAWS CLIdebe ser 2.2 o posterior.

Si el archivo deAWS CLImuestra su versión actual, estará listo para continuarthe section called
“Configuración de sus credenciales de Cuenta de AWS” (p. 149).

Configuración de sus credenciales de Cuenta de AWS

En este procedimiento, obtendráCuenta de AWScredenciales y agréguelas para usarlas en su Raspberry
Pi.

Para añadirCuenta de AWScredenciales de tu dispositivo

1. Obtenga unAccess Key IDyClave de acceso secretadesde suCuenta de AWSpara autenticar elAWS
CLIen su dispositivo.

Si es la primera vez que usaAWSIAM,https://aws.amazon.com/premiumsupport/knowledge-

center/create-access-key/describe el proceso que se va a ejecutar en elAWSconsola para
crearAWSCredenciales de IAM para usar en el dispositivo.
2. En la ventana de terminal de su equipo host local que está conectado a su Raspberry Pi. y con
elAccess Key IDyClave de acceso secretacredenciales para tu dispositivo:

a. Ejecute laAWSconfigure app con este comando:

aws configure

b. Introduzca sus credenciales e información de configuración cuando se le solicite:

AWS Access Key ID: your Access Key ID

AWS Secret Access Key: your Secret Access Key
Default region name: your Región de AWS code
Default output format: json

3. Ejecute este comando para probar el acceso de tu dispositivo a tuCuenta de AWSyAWS IoT Core.

aws iot describe-endpoint --endpoint-type iot:Data-ATS

Debería devolver suCuenta de AWS-específicoAWS IoTpunto final de datos, como este ejemplo:

149
 AWS IoT Core Guía para desarrolladores
Preparación de los dispositivos para
elAWS IoTCliente del dispositivo

"endpointAddress": "a3EXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}

Si ves tuCuenta de AWS-específicoAWS IoTpunto final de datos, su Raspberry Pi tiene la conectividad y

los permisos para continuarthe section called “Descargar el certificado de entidad de certificación Amazon
Root” (p. 150).
Important

SusCuenta de AWSlas credenciales se almacenan ahora en la tarjeta microSD de su Raspberry

Pi. Si bien esto hace interacciones futuras conAWSfácil para ti y el software que crearás en estos
tutoriales, también se guardarán y duplicarán en cualquier imagen de tarjeta microSD que hagas
después de este paso de forma predeterminada.
Para proteger la seguridad de suCuenta de AWScredenciales, antes de guardar más imágenes
de tarjeta microSD, considere borrar las credenciales ejecutandoaws configurede nuevo e
introduciendo caracteres aleatorios para elAccess Key IDyClave de acceso secretapara evitar
suCuenta de AWScredenciales de comprometidas.
Si descubre que ha guardado suCuenta de AWScredenciales sin darse cuenta, puede
desactivarlas en elAWSConsola IAM.

Descargar el certificado de entidad de certificación Amazon Root

Este procedimiento descarga y guarda una copia de un certificado de la Autoridad de certificación raíz (CA)
de Amazon. Al descargar este certificado se guarda para utilizarlo en los tutoriales posteriores y también
prueba la conectividad de su dispositivo conAWSServicios de .

Para descargar y guardar el certificado de entidad de certificación de Amazon Root

1. Ejecute este comando para crear un directorio para el certificado.

mkdir ~/certs

2. Ejecute este comando para descargar el certificado de entidad de certificación de Amazon Root.

curl -o ~/certs/AmazonRootCA1.pem https://www.amazontrust.com/repository/

AmazonRootCA1.pem

3. Ejecute estos comandos para establecer el acceso al directorio de certificados y a su archivo.

chmod 745 ~
chmod 700 ~/certs
chmod 644 ~/certs/AmazonRootCA1.pem

4. Ejecute este comando para ver el archivo de certificado CA en el nuevo directorio.

ls -l ~/certs

Debería ver una entrada como esta. La fecha y la hora serán diferentes; sin embargo, el tamaño del
archivo y el resto de la información deben ser los mismos que se muestran aquí.

-rw-r--r-- 1 pi pi 1188 Oct 28 13:02 AmazonRootCA1.pem

Si el tamaño del archivo no es1188, consultecurlparámetros de comandos. Es posible que hayas

descargado un archivo incorrecto.

150
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

(Opcional) Guardar la imagen de la tarjeta microSD

En este punto, la tarjeta microSD de su Raspberry Pi tiene un sistema operativo actualizado y el software
básico de aplicación cargado.

Para guardar la imagen de la tarjeta microSD en un archivo

1. En la ventana del terminal del equipo host local, borre elAWSCredenciales de .

a. Ejecute laAWSconfigure app con este comando:

aws configure

b. Sustituya sus credenciales cuando se le solicite. Puedes irteNombre de región

predeterminadoyFormato de salida predeterminadotal como están presionandoEntrar.

AWS Access Key ID [****************YT2H]: XYXYXYXYX

AWS Secret Access Key [****************9plH]: XYXYXYXYX
Default region name [us-west-2]:
Default output format [json]:

2. Introduzca este comando para apagar la Raspberry Pi.

sudo shutdown -h 0

3. Después de que la Raspberry Pi se apague por completo, retire su conector de alimentación.

4. Retire la tarjeta microSD del dispositivo.
5. En el equipo host local:

a. Inserta la tarjeta microSD.

b. Con la herramienta de imagen de la tarjeta SD, guarda la imagen de la tarjeta microSD en un
archivo.
c. Una vez guardada la imagen de la tarjeta microSD, expulsa la tarjeta del equipo host local.
6. Con la alimentación desconectada de la Raspberry Pi, inserta la tarjeta microSD en la Raspberry Pi.
7. Aplique energía al dispositivo.
8. Después de un minuto, en el equipo host local, reinicie la sesión de la ventana de terminal e inicie
sesión en el dispositivo.

No vuelvas a ingresar tuCuenta de AWScredenciales todavía.

Después de reiniciar e iniciar sesión en su Raspberry Pi, estará listo para continuarthe section called
“Instalar y configurar elAWS IoTCliente del dispositivo” (p. 151).

Tutorial: Instalar y configurar elAWS IoTCliente del

dispositivo
Este tutorial le guía a través de la instalación y configuración deAWS IoTDevice Client y creación deAWS
IoTrecursos que utilizarás en esta y en otras demostraciones.

Para comenzar este tutorial:

• Haga que su equipo host local y Raspberry Pi deel tutorial anterior (p. 141)listo.

Este tutorial puede tardar hasta 90 minutos en completarse.

151
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

Cuando haya terminado de examinar este tema:

• El dispositivo IoT estará listo para usar en otrosAWS IoTDemostraciones del cliente de
• Habrás aprovisionado tu dispositivo IoT enAWS IoT Core.
• Habrás descargado e instalado elAWS IoTDevice Client en tu dispositivo.
• Habrás guardado una imagen de la tarjeta microSD de tu dispositivo que se puede utilizar en tutoriales
posteriores.

Equipo requerido:

• Su entorno de pruebas y desarrollo local desdela sección anterior (p. 148)

• La Raspberry Pi que usaste enla sección anterior (p. 148)
• La tarjeta de memoria microSD de la Raspberry Pi que usaste enla sección anterior (p. 148)

Procedimientos de este tutorial

• Paso 1: Descargue y guarde elAWS IoTCliente del dispositivo (p. 152)
• (Opcional) Guardar la imagen de la tarjeta microSD (p. 153)
• Paso 2: Aprovisione su Raspberry Pi enAWS IoT (p. 154)
• Paso 3: Configuración delAWS IoTCliente de dispositivo para probar la conectividad (p. 158)

Paso 1: Descargue y guarde elAWS IoTCliente del dispositivo

Los procedimientos de esta sección descargan elAWS IoTDevice Client, compílelo e instálelo en su
Raspberry Pi. Después de probar la instalación, puedes guardar la imagen de la tarjeta microSD de
Raspberry Pi para usarla más adelante cuando quieras volver a probar los tutoriales.

Procedimientos de esta sección:

• Descargue y compruebe elAWS IoTCliente del dispositivo (p. 152)
• Cree los directorios utilizados por los tutoriales (p. 153)

Descargue y compruebe elAWS IoTCliente del dispositivo

Este procedimiento instala elAWS IoTCliente de dispositivos en su Raspberry Pi.

Realice estos comandos en la ventana de terminal del equipo host local que está conectado a Raspberry
Pi.

Para instalar elAWS IoTCliente del dispositivo en Raspberry Pi

1. Introduzca estos comandos para descargar y compilar elAWS IoTCliente de dispositivos en su

Raspberry Pi.

cd ~
git clone https://github.com/awslabs/aws-iot-device-client aws-iot-device-client
mkdir ~/aws-iot-device-client/build && cd ~/aws-iot-device-client/build
cmake ../

2. Ejecute este comando para compilar elAWS IoTCliente del dispositivo. Este comando puede tardar
hasta 15 minutos en completarse.

cmake --build . --target aws-iot-device-client

152
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

Los mensajes de advertencia mostrados comoAWS IoTLas compilaciones de Device Client se pueden
ignorar.

Estos tutoriales se han probado con elAWS IoTCliente de dispositivo basado engcc, versión (Raspbian
10.2.1-6+rpi1) 10.2.1 20210110 en la versión 30 de octubre de 2021 de Raspberry Pi OS (bullseye)
engcc, versión (Raspbian 8.3.0-6+rpi1) 8.3.0 en la versión 7 de mayo de 2021 del sistema operativo
Raspberry Pi (buster).
3. Después delAWS IoTDevice Client finaliza la compilación, pruébalo ejecutando este comando.

./aws-iot-device-client --help

Si ve la ayuda de la línea de comandos deAWS IoTDevice Client, elAWS IoTDevice Client se ha creado
correctamente y está listo para su uso.

Cree los directorios utilizados por los tutoriales

Este procedimiento crea los directorios en Raspberry Pi que se utilizarán para almacenar los archivos
utilizados por los tutoriales en esta ruta de aprendizaje.

Para crear los directorios utilizados por los tutoriales en esta ruta de aprendizaje:

1. Ejecute estos comandos para crear los directorios necesarios.

mkdir ~/dc-configs
mkdir ~/policies
mkdir ~/messages
mkdir ~/certs/testconn
mkdir ~/certs/pubsub
mkdir ~/certs/jobs

2. Ejecute estos comandos para establecer los permisos de los nuevos directorios.

chmod 745 ~
chmod 700 ~/certs/testconn
chmod 700 ~/certs/pubsub
chmod 700 ~/certs/jobs

Después de crear estos directorios y establecer su permiso, continúe enthe section called “(Opcional)
Guardar la imagen de la tarjeta microSD” (p. 153).

(Opcional) Guardar la imagen de la tarjeta microSD

En este punto, la tarjeta microSD de su Raspberry Pi tiene un sistema operativo actualizado, el software
básico de aplicación y elAWS IoTCliente del dispositivo.

Si quieres volver a probar estos ejercicios y tutoriales, puedes omitir los procedimientos anteriores
escribiendo la imagen de la tarjeta microSD que guardas con este procedimiento en una nueva tarjeta
microSD y continuar con los tutoriales dethe section called “Paso 2: Aprovisione su Raspberry Pi enAWS
IoT” (p. 154).

Para guardar la imagen de la tarjeta microSD en un archivo:

En la ventana de terminal del equipo host local que está conectado a la Raspberry Pi:

1. Confirmar que suCuenta de AWSno se han almacenado las credenciales.

153
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

a. Ejecute laAWSconfigure app con este comando:

aws configure

b. Si se han almacenado sus credenciales (si se muestran en la solicitud), introduzca

laXYXYXYXYXcadena cuando se le solicite tal y como se muestra aquí. DejarNombre de región
predeterminadoyFormato de salida predeterminadoen blanco.

AWS Access Key ID [****************YXYX]: XYXYXYXYX

AWS Secret Access Key [****************YXYX]: XYXYXYXYX
Default region name:
Default output format:

2. Ingrese este comando para apagar el dispositivo Raspberry Pi.

sudo shutdown -h 0

3. Después de que la Raspberry Pi se apague por completo, retire su conector de alimentación.

4. Retire la tarjeta microSD del dispositivo.
5. En el equipo host local:

a. Inserta la tarjeta microSD.

b. Con la herramienta de imagen de la tarjeta SD, guarda la imagen de la tarjeta microSD en un
archivo.
c. Una vez guardada la imagen de la tarjeta microSD, expulsa la tarjeta del equipo host local.

Puedes continuar con esta tarjeta microSD enthe section called “Paso 2: Aprovisione su Raspberry Pi
enAWS IoT” (p. 154).

Paso 2: Aprovisione su Raspberry Pi enAWS IoT

Los procedimientos de esta sección comienzan con la imagen microSD guardada que tiene elAWS
CLIyAWS IoTDevice Client instalado y crea elAWS IoTrecursos y certificados de dispositivo que
aprovisionan su Raspberry Pi enAWS IoT.

Instale la tarjeta microSD en su Raspberry Pi

Este procedimiento instala la tarjeta microSD con el software necesario cargado y configurado en
Raspberry Pi y configura suCuenta de AWSpara que puedas continuar con los tutoriales de esta ruta de
aprendizaje.

Utilizar una tarjeta microSD desdethe section called “(Opcional) Guardar la imagen de la tarjeta
microSD” (p. 153)que cuenta con el software necesario para los ejercicios y tutoriales de esta trayectoria
de aprendizaje.

Para instalar la tarjeta microSD en su Raspberry Pi

1. Con la alimentación desconectada de la Raspberry Pi, inserta la tarjeta microSD en la Raspberry Pi.
2. Aplique energía al Raspberry Pi.
3. Después de un minuto, en el equipo host local, reinicie la sesión de la ventana de terminal e inicie
sesión en Raspberry Pi.
4. En el equipo host local, en la ventana de terminal y con elAccess Key IDyClave de acceso
secretacredenciales de su Raspberry Pi:

a. Ejecute laAWSconfigure app con este comando:

154
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

aws configure

b. Escriba suCuenta de AWScredenciales e información de configuración cuando se le solicite:

AWS Access Key ID [****************YXYX]: your Access Key ID

AWS Secret Access Key [****************YXYX]: your Secret Access Key
Default region name [us-west-2]: your Región de AWS code
Default output format [json]: json

Después de haber restaurado suCuenta de AWScredenciales, está listo para continuarthe section called
“Aprovisionamiento del dispositivo enAWS IoT Core” (p. 155).

Aprovisionamiento del dispositivo enAWS IoT Core

Los procedimientos de esta sección crean elAWS IoTrecursos que aprovisionan su Raspberry Pi enAWS
IoT. A medida que crees estos recursos, se te pedirá que registres varios datos. Esta información la utiliza
elAWS IoTConfiguración del cliente de dispositivos en el siguiente procedimiento.

Para que tu Raspberry Pi funcione conAWS IoT, debe aprovisionarse. El aprovisionamiento es el proceso
de creación y configuración delAWS IoTrecursos necesarios para admitir su Raspberry Pi como un
dispositivo de IoT.

Con la Raspberry Pi encendida y reiniciada, conecte la ventana del terminal de su equipo host local al
Raspberry Pi y complete estos procedimientos.

Procedimientos de esta sección:

• Crear y descargar archivos de certificado de dispositivo (p. 155)
• CrearAWS IoTrecursos (p. 156)

Crear y descargar archivos de certificado de dispositivo

Este procedimiento crea los archivos de certificado de dispositivo para esta demostración.

Para crear y descargar los archivos de certificado de dispositivo para su Raspberry Pi

1. En la ventana de terminal del equipo host local, introduzca estos comandos para crear los archivos de
certificado de dispositivo para su dispositivo.

mkdir ~/certs/testconn
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/testconn/device.pem.crt" \
--public-key-outfile "~/certs/testconn/public.pem.key" \
--private-key-outfile "~/certs/testconn/private.pem.key"

El comando devuelve una respuesta similar a la siguiente. Anote elcertificateArnvalor para un

uso posterior.

{
"certificateArn": "arn:aws:iot:us-
west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId":
"76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificatePem": "-----BEGIN CERTIFICATE-----
\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",

155
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

"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"
}
}

2. Introduzca los siguientes comandos para establecer los permisos en el directorio de certificados y sus
archivos.

chmod 745 ~
chmod 700 ~/certs/testconn
chmod 644 ~/certs/testconn/*
chmod 600 ~/certs/testconn/private.pem.key

3. Ejecute este comando para revisar los permisos de los directorios y archivos de certificados.

ls -l ~/certs/testconn

El resultado del comando debe ser el mismo que el que ve aquí, excepto que las fechas y horas del
archivo 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

En este punto, tiene instalados los archivos de certificado del dispositivo en su Raspberry Pi y puede
continuarthe section called “CrearAWS IoTrecursos” (p. 156).

CrearAWS IoTrecursos

Este procedimiento aprovisiona su dispositivo enAWS IoTcreando los recursos a los que necesita acceder
su dispositivoAWS IoTcaracterísticas y servicios.

Para aprovisionar el dispositivo enAWS IoT

1. En la ventana de terminal de su equipo host local, introduzca el siguiente comando para obtener la
dirección del punto final de datos del dispositivo para suCuenta de AWS.

aws iot describe-endpoint --endpoint-type IoT:Data-ATS

El comando de los pasos anteriores devuelve una respuesta similar a la siguiente. Anote
elendpointAddressvalor para un uso posterior.

{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}

2. Escriba este comando para crear unAWS IoTrecurso de cosa para su Raspberry Pi.

aws iot create-thing --thing-name "DevCliTestThing"

Si las recetasAWS IoTobjeto de recurso se creó, el comando devuelve una respuesta similar a esta.

156
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

"thingName": "DevCliTestThing",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/DevCliTestThing",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}

3. En la ventana de borna:

a. Abra un editor de texto, comonano.

b. Copie este documento de política JSON y péguelo en el editor de texto abierto.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Subscribe",
"iot:Receive",
"iot:Connect"
],
"Resource": [
"*"
]
}
]
}

Note

Este documento de política otorga generosamente permiso a todos los recursos para
conectarse, recibir, publicar y suscribirse. Normalmente, las políticas otorgan permiso
únicamente a recursos específicos para realizar acciones específicas. Sin embargo, para
la prueba de conectividad inicial de dispositivos, esta política excesivamente general y
permisiva se utiliza para minimizar la posibilidad de que se produzca un problema de
acceso durante esta prueba. En los tutoriales posteriores, se utilizarán documentos de
política con un alcance más limitado para demostrar mejores prácticas en el diseño de
políticas.
c. Guarde el archivo en el editor de texto como~/policies/
dev_cli_test_thing_policy.json.
4. Ejecute este comando para utilizar el documento de política de los pasos anteriores para crear unAWS
IoTpolítica.

aws iot create-policy \

--policy-name "DevCliTestThingPolicy" \
--policy-document "file://~/policies/dev_cli_test_thing_policy.json"

Si se crea la política, el comando devolverá una respuesta similar a esta.

{
"policyName": "DevCliTestThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/DevCliTestThingPolicy",
"policyDocument": "{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n
{\n \"Effect\": \"Allow\",\n \"Action\": [\n
\"iot:Publish\",\n \"iot:Subscribe\",\n \"iot:Receive\",
\n \"iot:Connect\"\n ],\n \"Resource\": [\n
\"*\"\n ]\n }\n ]\n}\n",
"policyVersionId": "1"
}

157
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

5. Ejecute este comando para asociar la política al certificado de dispositivo.

ReemplazarcertificateArnconcertificateArnvalor que guardaste anteriormente.

aws iot attach-policy \

--policy-name "DevCliTestThingPolicy" \
--target "certificateArn"

Si se ejecuta correctamente, este comando no devuelve nada.

6. Ejecute este comando para adjuntar el certificado de dispositivo alAWS IoTrecurso de objeto.
ReemplazarcertificateArnconcertificateArnvalor que guardaste anteriormente.

aws iot attach-thing-principal \

--thing-name "DevCliTestThing" \
--principal "certificateArn"

Si se ejecuta correctamente, este comando no devuelve nada.

Después de aprovisionar correctamente el dispositivo enAWS IoT, está listo para continuarthe section
called “Paso 3: Configuración delAWS IoTCliente de dispositivo para probar la conectividad” (p. 158).

Paso 3: Configuración delAWS IoTCliente de dispositivo para

probar la conectividad
Los procedimientos de esta sección configuran laAWS IoTDevice Client para publicar un mensaje de
MQTT desde su Raspberry Pi.

Procedimientos de esta sección:

• Crear el archivo de configuración (p. 158)
• Cliente de prueba MQTT abierto (p. 159)
• Ejecución deAWS IoTCliente del dispositivo (p. 160)

Crear el archivo de configuración

Este procedimiento crea el archivo de configuración para probar elAWS IoTCliente del dispositivo.

Para crear el archivo de configuración para probar elAWS IoTCliente del dispositivo

• En la ventana de terminal del equipo host local que está conectado a la Raspberry Pi:

a. Introduzca estos comandos para crear un directorio para los archivos de configuración y
establecer el permiso en el directorio:

mkdir ~/dc-configs
chmod 745 ~/dc-configs

b. Abra un editor de texto, comonano.

c. Copie este documento JSON y péguelo en el editor de texto abierto.

{
"endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
"cert": "~/certs/testconn/device.pem.crt",
"key": "~/certs/testconn/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "DevCliTestThing",

158
 AWS IoT Core Guía para desarrolladores
Instalar y configurar elAWS IoTCliente del dispositivo

"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": ""
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}

d. Sustituya elpunto de conexiónvalor con endpoint de datos de dispositivo para suCuenta

de AWSque encontraste enthe section called “Aprovisionamiento del dispositivo enAWS IoT
Core” (p. 155).
e. Guarde el archivo en el editor de texto como~/dc-configs/dc-testconn-config.json.
f. Ejecute este comando para establecer los permisos en el nuevo archivo de configuración.

chmod 644 ~/dc-configs/dc-testconn-config.json

Después de guardar el archivo, estará listo para continuarthe section called “Cliente de prueba MQTT
abierto” (p. 159).

Cliente de prueba MQTT abierto

Este procedimiento prepara elCliente de prueba MQTTen laAWS IoTconsola para suscribirse al mensaje
de MQTT de que elAWS IoTDevice Client se publica cuando se ejecuta.

159
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

Para preparar elCliente de prueba MQTTpara suscribirse a todos los mensajes MQTT

1. En el equipo host local, en elAWS IoTconsola, eligeCliente de prueba MQTT.

2. En el navegadorSuscripción a un temapestaña, enFiltro de temas, introduzca#(un signo de una libra) y
elijaSuscribirsepara suscribirse a todos los temas de MQTT.
3. Debajo delSuscripcionesetiqueta, confirma que ves#(un signo de una libra).

Deja la ventana con elCliente de prueba MQTTabierto a medida que continúasthe section called “Ejecución
deAWS IoTCliente del dispositivo” (p. 160).

Ejecución deAWS IoTCliente del dispositivo

Este procedimiento ejecuta elAWS IoTDevice Client para que publique un único mensaje MQTT que
indicaCliente de prueba MQTTrecibe y muestra.

Para enviar un mensaje MQTT desde elAWS IoTCliente del dispositivo

1. Asegúrese de que tanto la ventana de terminal conectada a su Raspberry Pi como la ventana con
elCliente de prueba MQTTestán visibles mientras realiza este procedimiento.
2. En la ventana de terminal, introduzca estos comandos para ejecutar elAWS IoTCliente de
dispositivo mediante el archivo de configuración creado enthe section called “Crear el archivo de
configuración” (p. 158).

cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-testconn-config.json

En una ventana de terminal, elAWS IoTDevice Client muestra mensajes de información y cualquier
error que se produzca cuando se ejecuta.

Si no se muestran errores en la ventana del terminal, revise elCliente de prueba MQTT.

3. En el navegadorCliente de prueba MQTT, en la ventana Suscripciones, consulte la¡Hello
World!mensaje enviado a latest/dc/pubtopictema de mensaje.
4. Si el archivo deAWS IoTDevice Client no muestra errores y verá¡Hello World!enviado atest/dc/
pubtopicmensaje en elCliente de prueba MQTT, ha demostrado una conexión correcta.
5. En una ventana de terminal, escriba^C(Ctrl-C) para detener elAWS IoTCliente del dispositivo.

Después de demostrar que elAWS IoTDevice Client se ejecuta correctamente en su Raspberry Pi y puede
comunicarse conAWS IoT, puede continuar hasta elthe section called “Demostrar la comunicación de
mensajes MQTT con elAWS IoTCliente del dispositivo” (p. 160).

Tutorial: Demostrar la comunicación de mensajes

MQTT con elAWS IoTCliente del dispositivo
En este tutorial se muestra cómo elAWS IoTDevice Client puede suscribirse y publicar mensajes MQTT,
que se utilizan habitualmente en soluciones de IoT.

Para comenzar este tutorial:

• Haga que su equipo host local y Raspberry Pi estén configurados como se utilizan ensección
anterior (p. 151).

Si ha guardado la imagen de la tarjeta microSD después de instalar elAWS IoTDevice Client, puedes
usar una tarjeta microSD con esa imagen con tu Raspberry Pi.

160
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

• Si ya has ejecutado esta demo antes, revisa??? (p. 186)para eliminar todoAWS IoTrecursos que creó
en ejecuciones anteriores para evitar errores de recursos duplicados.

Este tutorial tarda aproximadamente 45 minutos en completarse.

Cuando haya terminado de examinar este tema:

• Habrás demostrado diferentes formas en que tu dispositivo IoT puede suscribirse a mensajes MQTT
desdeAWS IoTy publicar mensajes MQTT enAWS IoT.

Equipo necesario:

• Su entorno de pruebas y desarrollo local desdesección anterior (p. 151)

• La Raspberry Pi que usaste ensección anterior (p. 151)
• La tarjeta de memoria microSD de la Raspberry Pi que usaste ensección anterior (p. 151)

Procedimientos de este tutorial

• Paso 1: Preparación de Raspberry Pi para demostrar la comunicación de los mensajes
MQTT (p. 161)
• Paso 2: Demostrar la publicación de mensajes con elAWS IoTCliente del dispositivo (p. 166)
• Paso 3: Demostrar suscribirse a mensajes con elAWS IoTCliente del dispositivo (p. 169)

Paso 1: Preparación de Raspberry Pi para demostrar la

comunicación de los mensajes MQTT
Este procedimiento crea los recursos enAWS IoTy en Raspberry Pi para demostrar la comunicación de
mensajes MQTT utilizando elAWS IoTCliente del dispositivo.

Procedimientos de esta sección:

• Cree los archivos de certificado para demostrar la comunicación MQTT (p. 161)
• Aprovisionamiento de su dispositivo para demostrar la comunicación MQTT (p. 162)
• Configuración delAWS IoTArchivo de configuración de Device Client y cliente de prueba MQTT para
demostrar la comunicación MQTT (p. 165)

Cree los archivos de certificado para demostrar la comunicación MQTT

Este procedimiento crea los archivos de certificado de dispositivo para esta demostración.

Para crear y descargar los archivos de certificado de dispositivo para su Raspberry Pi

1. En la ventana de terminal del equipo host local, introduzca el siguiente comando para crear los
archivos de certificado de dispositivo 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"

161
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

El comando devuelve una respuesta similar a la siguiente. Save thecertificateArnvalor para un

uso posterior.

{
"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"
}
}

2. Introduzca los siguientes comandos para establecer 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

3. Ejecute este comando para revisar los permisos de los directorios y archivos de certificados.

ls -l ~/certs/pubsub

El resultado del comando debe ser el mismo que el que ve aquí, excepto que las fechas y horas del
archivo 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

4. 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/*

Aprovisionamiento de su dispositivo para demostrar la comunicación MQTT

En esta sección se crea elAWS IoTrecursos que aprovisionan su Raspberry Pi enAWS IoT.

Para aprovisionar el dispositivo enAWS IoT:

1. En la ventana de terminal del equipo host local, introduzca el siguiente comando para obtener la
dirección del punto final de datos del dispositivo para suCuenta de AWS.

aws iot describe-endpoint --endpoint-type IoT:Data-ATS

162
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

El valor del endpoint no ha cambiado desde el momento en que ejecutó este comando para el tutorial
anterior. La ejecución de nuevo aquí se hace para facilitar la búsqueda y pegar el valor del extremo 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. Registre
elendpointAddressvalor para un uso posterior.

{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}

2. Escriba este comando para crear un nuevoAWS IoTrecurso de cosa para su Raspberry Pi.

aws iot create-thing --thing-name "PubSubTestThing"

Porque unAWS IoTcosa recurso es unvirtualrepresentación de su dispositivo en la nube, podemos

crear múltiples recursos enAWS IoTpara utilizar con fines diferentes. Todas ellas pueden ser utilizadas
por el mismo dispositivo IoT físico para representar diferentes aspectos del dispositivo.

Estos tutoriales solo usarán un recurso a la vez para representar la Raspberry Pi. De esta forma,
en estos tutoriales, representan las diferentes demostraciones para que después de crear elAWS
IoTrecursos para una demostración, puede volver atrás y repetir la demostración utilizando los
recursos que creó específicamente para cada uno.

Si las recetasAWS IoTse creó un recurso de la cosa, el comando devuelve una respuesta similar a
esta.

{
"thingName": "PubSubTestThing",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}

3. En la ventana de borna:

a. Abra un editor de texto, comonano.

b. 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:57EXAMPLE833:client/PubSubTestThing"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
]
},

163
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
]
}
]
}

c. En el editor, en cadaResourcesección del documento de política, sustitúyaseus-west - 2:57

EJEMPLO 833con tuRegión de AWS, un carácter de dos puntos (:) y tus 12 dígitosCuenta de
AWSnúmero.
d. Guarde el archivo en el editor de texto como~/policies/
pubsub_test_thing_policy.json.
4. Ejecute este comando para utilizar el documento de política de los pasos anteriores para crear unAWS
IoTpolí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 similar a 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"

5. Ejecute este comando para asociar la política al certificado de dispositivo.

ReemplazarcertificateArnconcertificateArnvalor que ha guardado anteriormente en esta
sección.

aws iot attach-policy \

--policy-name "PubSubTestThingPolicy" \
--target "certificateArn"

Si se ejecuta correctamente, este comando no devuelve nada.

164
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

6. Ejecute este comando para adjuntar el certificado de dispositivo alAWS IoTrecurso de cosa.
ReemplazarcertificateArnconcertificateArnvalor que ha guardado anteriormente en esta
sección.

aws iot attach-thing-principal \

--thing-name "PubSubTestThing" \
--principal "certificateArn"

Si se ejecuta correctamente, este comando no devuelve nada.

Después de aprovisionar correctamente el dispositivo enAWS IoT, ya está listo para seguirthe section
called “Configuración delAWS IoTArchivo de configuración de Device Client y cliente de prueba MQTT para
demostrar la comunicación MQTT” (p. 165).

Configuración delAWS IoTArchivo de configuración de Device Client y cliente de

prueba MQTT para demostrar la comunicación MQTT
Este procedimiento crea un archivo de configuración para probar elAWS IoTCliente del dispositivo.

Para crear el archivo de configuración para probar elAWS IoTCliente del dispositivo

1. En la ventana de terminal del equipo host local que está conectado a la Raspberry Pi:

a. Abra un editor de texto, comonano.

b. 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",

165
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

"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": ""
}
}

c. Reemplace elpunto de conexiónvalor con endpoint de datos de dispositivo para suCuenta

de AWSque encontraste enthe section called “Aprovisionamiento del dispositivo enAWS IoT
Core” (p. 155).
d. Guarde el archivo en el editor de texto como~/dc-configs/dc-pubsub-config.json.
e. Ejecute este comando para establecer los permisos en el nuevo archivo de configuración.

chmod 644 ~/dc-configs/dc-pubsub-config.json

2. Para preparar elCliente de prueba MQTTpara suscribirse a todos los mensajes MQTT:

a. En el equipo host local, en elAWS IoTconsola, eligeCliente de prueba MQTT.

b. En el navegadorSuscripción a un tema, enFiltro de temas, introduzca#(un signo de una libra) y
elijaSuscribirse.
c. Debajo de lasSuscripcionesetiqueta, confirma que ves#(un signo de una libra).

Deje la ventana con elCliente de prueba MQTTabrir mientras continúas con este tutorial.

Después de guardar el archivo y configurar elCliente de prueba MQTT, ya está listo para seguirthe section
called “Paso 2: Demostrar la publicación de mensajes con elAWS IoTCliente del dispositivo” (p. 166).

Paso 2: Demostrar la publicación de mensajes con elAWS

IoTCliente del dispositivo
Los procedimientos de esta sección demuestran cómo laAWS IoTDevice Client puede enviar mensajes
MQTT predeterminados y personalizados.

Estas declaraciones de política de la política que ha creado en el paso anterior para estos ejercicios dan
permiso a Raspberry Pi para ejecutar estas acciones:

• iot:Connect

Da nombre al clientePubSubTestThing, su Raspberry Pi ejecutando elAWS IoTCliente de dispositivo,

para conectarse.

{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing"

166
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

]
}

• iot:Publish

Otorga permiso a Raspberry Pi para publicar mensajes con un tema MQTT detest/dc/pubtopic.

{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
]
}

Laiot:Publishaction da permiso para publicar en los temas MQTT enumerados en la matriz de

recursos. Lacontenidode esos mensajes no está controlado por la declaración de política.

Publicar el mensaje predeterminado mediante elAWS IoTCliente del dispositivo

En este procedimiento se ejecuta elAWS IoTDevice Client para que publique un único mensaje MQTT
predeterminado que indica que elCliente de prueba MQTTrecibe y muestra.

Para enviar el mensaje MQTT predeterminado desde elAWS IoTCliente del dispositivo

1. Asegúrese de que tanto la ventana del terminal del equipo host local que esté conectado a Raspberry
Pi como la ventana con elCliente de prueba MQTTestán visibles mientras realiza este procedimiento.
2. En una ventana de terminal, escriba estos comandos para ejecutar laAWS IoTCliente de
dispositivo mediante el archivo de configuración creado enthe section called “Crear el archivo de
configuración” (p. 158).

cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json

En una ventana de terminal,AWS IoTDevice Client muestra mensajes de información y cualquier error
que se produzca cuando se ejecuta.

Si no aparece ningún error en la ventana de la terminal, consulte laCliente de prueba MQTT.

3. En el navegadorCliente de prueba MQTT, en elSuscripcionesventana, vea laHello World!mensaje
enviado a latest/dc/pubtopictema de mensaje.
4. Si el archivo deAWS IoTDevice Client no muestra errores y veráHello World!enviado altest/dc/
pubtopicmessage en elCliente de prueba MQTT, ha demostrado una conexión correcta.
5. En una ventana de terminal, escriba^C(Ctrl-C) para detener elAWS IoTCliente del dispositivo.

Después de demostrar que elAWS IoTDevice Client publicó el mensaje MQTT predeterminado, puede
continuar con lathe section called “Publicar un mensaje personalizado mediante elAWS IoTCliente del
dispositivo.” (p. 167).

Publicar un mensaje personalizado mediante elAWS IoTCliente del dispositivo.

Los procedimientos de esta sección crean un mensaje MQTT personalizado y luego ejecutan elAWS
IoTDevice Client para que publique el mensaje MQTT personalizado una vez para elCliente de prueba
MQTTpara recibir y mostrar.

167
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

Cree un mensaje MQTT personalizado para elAWS IoTCliente del dispositivo

Realice estos pasos en la ventana del terminal del equipo host local que está conectado a Raspberry Pi.

Para crear un mensaje personalizado para elAWS IoTCliente de dispositivo para publicar

1. En una ventana de terminal, abra un editor de texto, comonano.

2. En el editor de texto, copie y pegue el siguiente documento JSON. Esta será la carga útil del mensaje
MQTT que elAWS IoTDevice Client publica.

{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}

3. Guarde el contenido del editor de texto como~/messages/sample-ws-message.json.

4. Escriba el siguiente comando para establecer los permisos del archivo de mensaje que acaba de
crear.

chmod 600 ~/messages/*

Para crear un archivo de configuración para elAWS IoTCliente de dispositivo que se utilizará para
enviar el mensaje personalizado

1. En la ventana de borna, en un editor de texto comonano, abra el existenteAWS IoTArchivo de

configuración de Cliente de dispositivos:~/dc-configs/dc-pubsub-config.json.
2. Editar elsamplestenga un aspecto similar al siguiente. No es necesario cambiar ninguna otra parte de
este archivo.

"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"

3. Guarde el contenido del editor de texto como~/dc-configs/dc-pubsub-custom-config.json.

4. Ejecute este comando para establecer los permisos en el nuevo archivo de configuración.

chmod 644 ~/dc-configs/dc-pubsub-custom-config.json

Publicar el mensaje MQTT personalizado mediante elAWS IoTCliente del dispositivo

Este cambio solo afecta acontenidode la carga útil de mensajes MQTT, por lo que la política actual seguirá
funcionando. Sin embargo, si lasTema MQTT(tal como lo define elpublish-topicValor en~/dc-
configs/dc-pubsub-custom-config.json) se ha cambiado, eliot::PublishTambién tendría que
modificarse para permitir que Raspberry Pi publique en el nuevo tema MQTT.

168
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

Para enviar el mensaje MQTT desde elAWS IoTCliente del dispositivo

1. Asegúrese de que tanto la ventana de terminal como la ventana con elCliente de prueba MQTTestán
visibles mientras realiza este procedimiento. Además, asegúrese de que suCliente de prueba
MQTTsigue suscrito al#filtro de temas. Si no es así, suscríbase al#filtro de tema de nuevo.
2. En una ventana de terminal, escriba estos comandos para ejecutar laAWS IoTCliente de
dispositivo mediante el archivo de configuración creado enthe section called “Crear el archivo de
configuración” (p. 158).

cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json

En una ventana de terminal,AWS IoTDevice Client muestra mensajes de información y cualquier error
que se produzca cuando se ejecuta.

Si no se muestran errores en la ventana del terminal, revise el cliente de prueba MQTT.

3. En el navegadorCliente de prueba MQTT, en elSuscripciones, consulte la carga útil de mensajes
personalizados enviada a latest/dc/pubtopictema de mensaje.
4. Si el archivo deAWS IoTDevice Client no muestra errores y ve la carga útil de mensajes
personalizados que publicó en eltest/dc/pubtopicmessage en elCliente de prueba MQTT, ha
publicado correctamente un mensaje personalizado.
5. En una ventana de terminal, escriba^C(Ctrl-C) para detener elAWS IoTCliente del dispositivo.

Después de demostrar que elAWS IoTDevice Client publicó una carga útil de mensajes personalizados,
puede continuarthe section called “Paso 3: Demostrar suscribirse a mensajes con elAWS IoTCliente del
dispositivo” (p. 169).

Paso 3: Demostrar suscribirse a mensajes con elAWS IoTCliente

del dispositivo
En esta sección, demostrará dos tipos de suscripciones a los mensajes:

• Suscripción de un solo tema

• Suscripción a temas comodín

Estas declaraciones de política de la política creada para estos ejercicios otorgan permiso a Raspberry Pi
para realizar estas acciones:

• iot:Receive

Otorga elAWS IoTPermiso de cliente de dispositivo para recibir temas MQTT que coinciden con los
mencionados en elResourceobjeto.

{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
]
}

• iot:Subscribe

169
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

Otorga elAWS IoTPermiso de cliente de dispositivo para suscribirse a filtros de temas MQTT que
coinciden con los mencionados en elResourceobjeto.

{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
]
}

Suscribirse a un solo tema de mensaje MQTT

Este procedimiento muestra cómo elAWS IoTDevice Client puede suscribirse y registrar mensajes MQTT.

En la ventana de terminal del equipo host local que está conectado a la Raspberry Pi, enumere el
contenido de~/dc-configs/dc-pubsub-custom-config.jsono abra el archivo en un editor de texto
para revisar su contenido. Busque el complementosamplesobjeto, que debería tener un aspecto similar a
este.

"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"

Tenga en cuenta quesubscribe-topicvalue es el tema de MQTT al que elAWS IoTDevice Client se

suscribirá cuando se ejecute. LaAWS IoTDevice Client escribe las cargas útiles de mensajes que recibe de
esta suscripción en el archivo denominado en elsubscribe-fileValor .

Para suscribirse a un tema de mensaje MQTT desde elAWS IoTCliente del dispositivo

1. Asegúrese de que tanto la ventana de terminal como la ventana con el cliente de prueba MQTT
estén visibles mientras realiza este procedimiento. Además, asegúrese de que suCliente de prueba
MQTTsigue suscrito al#filtro de temas. Si no es así, suscríbase al#filtro de tema de nuevo.
2. En una ventana de terminal, escriba estos comandos para ejecutar laAWS IoTCliente de
dispositivo mediante el archivo de configuración creado enthe section called “Crear el archivo de
configuración” (p. 158).

cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json

En una ventana de terminal,AWS IoTDevice Client muestra mensajes de información y cualquier error
que se produzca cuando se ejecuta.

Si no aparece ningún error en la ventana de terminal, continúe en laAWS IoTconsola de .

3. En el navegadorAWS IoTConsola de, en elCliente de prueba MQTT, elige elPublicación de un
temapestaña.
4. EnNombre del tema, introduzcatest/dc/subtopic
5. EnCarga de mensaje, revisa el contenido del mensaje.
6. ElegirPublicaciónpara publicar el mensaje MQTT.

170
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

7. En una ventana de terminal, tenga en cuenta lamensaje recibidoentrada desde elAWS IoTCliente de
dispositivo que tiene un aspecto similar a este.

2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on

subscribe topic, size: 45 bytes

8. Después de ver elmensaje recibidoentrada que muestra el mensaje recibido, introduzca^C(Ctrl-C)

para detener elAWS IoTCliente del dispositivo.
9. Introduzca este comando para ver el final del archivo de registro de mensajes y ver el mensaje que
publicó desde elCliente de prueba MQTT.

tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log

Al ver el mensaje en el archivo de registro, ha demostrado que elAWS IoTDevice Client recibió el mensaje
que publicó desde el cliente de prueba MQTT.

Suscribirse a varios temas de mensajes MQTT utilizando caracteres comodín

Estos procedimientos demuestran cómo elAWS IoTDevice Client puede suscribirse y registrar mensajes
MQTT utilizando caracteres comodín. Para ello, harás lo siguiente:

1. Actualice el filtro de temas que elAWS IoTDevice Client utiliza para suscribirse a temas de MQTT.
2. Actualice la política utilizada por el dispositivo para permitir las nuevas suscripciones.
3. Ejecute laAWS IoTDevice Client y publica mensajes desde la consola de pruebas MQTT.

Para crear un archivo de configuración para suscribirse a varios temas de mensajes MQTT
mediante un filtro de temas MQTT comodín

1. En la ventana de terminal del equipo host local que está conectado a la Raspberry Pi, abra~/dc-
configs/dc-pubsub-custom-config.jsonpara editar y localizar elsamplesobjeto.
2. En el editor de texto, busque elsamplesobjeto y actualiza elsubscribe-topictenga un aspecto
similar al siguiente.

"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/#",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"

El nuevosubscribe-topicValue es unFiltro de temas MQTT (p. 114)con un comodín MQTT al final.

Esto describe una suscripción a todos los temas de MQTT que empiezan portest/dc/. LaAWS
IoTDevice Client escribe las cargas útiles de mensajes que recibe de esta suscripción en el archivo
denominado ensubscribe-file.
3. Guarde el archivo de configuración modificado como~/dc-configs/dc-pubsub-wild-
config.jsony salga del editor.

Para modificar la política utilizada por su Raspberry Pi para permitir suscribirse y recibir varios
temas de mensajes MQTT

1. En la ventana de terminal del equipo host local que está conectado a Raspberry Pi, en su editor de
texto favorito, abra~/policies/pubsub_test_thing_policy.jsonpara editar y, a continuación,
busque eliot::Subscribeyiot::Receivedeclaraciones de política en el archivo.

171
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

2. En el navegadoriot::Subscribedirectiva, actualice la cadena del objeto Resource para

reemplazarsubtopiccon*, para que tenga el siguiente aspecto.

{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*"
]
}

Note

LaCaracteres comodín del filtro de temas MQTT (p. 114)son los+(signo más) y#(signo de
libra). Solicitud de suscripción con un#al final se suscribe a todos los temas que empiezan
por la cadena que precede al#carácter (por ejemplo,test/dc/en este caso).
Sin embargo, el valor del recurso de la declaración de política que autoriza esta suscripción
debe utilizar un*(un asterisco) en lugar del#(un signo de libra) en el filtro de temas ARN. Esto
se debe a que el procesador de políticas utiliza un carácter comodín diferente al que utiliza
MQTT.
Para obtener más información sobre el uso de caracteres comodín para temas y filtros
de temas en las políticas, consulteUsar caracteres de comodín a MQTT aAWS IoT
Corepolíticas (p. 370).
3. En el navegadoriot::Receivedirectiva, actualice la cadena del objeto Resource para
reemplazarsubtopiccon*, para que tenga el siguiente aspecto.

{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*"
]
}

4. Guarde el documento de política actualizado como~/policies/

pubsub_wild_test_thing_policy.jsony salga del editor.
5. Introduzca este comando para actualizar la política de este tutorial y utilizar las nuevas definiciones de
recursos.

aws iot create-policy-version \

--set-as-default \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_wild_test_thing_policy.json"

Si el comando se ejecuta correctamente, devuelve una respuesta similar a esta. Observe

quepolicyVersionIdahora es2, lo que indica que es la segunda versión de esta política.

Si ha actualizado correctamente la política, puede continuar con el siguiente procedimiento.

{
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n \"Version\": \"2012-10-17\",\n \"Statement\": [\n {\n
\"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Connect\"\n ],\n
\"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing

172
 AWS IoT Core Guía para desarrolladores
Demostrar la comunicación de mensajes
MQTT con elAWS IoTCliente del dispositivo

\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n

\"iot:Publish\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-
west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n ]\n },\n {\n \"Effect
\": \"Allow\",\n \"Action\": [\n \"iot:Subscribe\"\n ],\n
\"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/
*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n
\"iot:Receive\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-
west-2:57EXAMPLE833:topic/test/dc/*\"\n ]\n }\n ]\n}\n",
"policyVersionId": "2",
"isDefaultVersion": true
}

Si aparece un error de que hay demasiadas versiones de directivas para guardar una nueva,
introduzca este comando para enumerar las versiones actuales de la política. Revise la lista que
devuelve este comando para encontrar una versión de directiva que pueda eliminar.

aws iot list-policy-versions --policy-name "PubSubTestThingPolicy"

Escriba este comando para eliminar una versión que ya no necesita. Tenga en cuenta que no puede
eliminar la versión de la política predeterminada. La versión predeterminada de la política es la que
tieneisDefaultVersionValor detrue.

aws iot delete-policy-version \

--policy-name "PubSubTestThingPolicy" \
--policy-version-id policyId

Tras eliminar una versión de directiva, vuelva a intentar este paso.

Con el archivo de configuración y la política actualizados, está listo para demostrar las suscripciones de
comodín con elAWS IoTCliente del dispositivo.

Para demostrar cómo elAWS IoTDevice Client se suscribe y recibe varios temas de mensajes
MQTT

1. En el navegadorCliente de prueba MQTT, revisa las suscripciones. Si el archivo deCliente de prueba

MQTTestá suscrito a la en el#filtro de temas, continúe con el paso siguiente. Si no, en elCliente de
prueba MQTT, enSuscripción a un tema, enFiltro de temas, introduzca#(un carácter de signo de libra)
y, a continuación, elijaSuscribirsepara suscribirse a él.
2. En la ventana de terminal del equipo host local que está conectado a la Raspberry Pi, introduzca estos
comandos para iniciar elAWS IoTCliente del dispositivo.

cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json

3. Mientras veía elAWS IoTSalida de Device Client en la ventana de terminal del equipo host local,
vuelva alCliente de prueba MQTT. En el navegadorPublicación de un tema, enNombre del tema,
introduzcatest/dc/subtopicy luego seleccionePublicación.
4. En la ventana del terminal, confirme que el mensaje se ha recibido buscando un mensaje como:

2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on

subscribe topic, size: 76 bytes

5. Mientras veía elAWS IoTSalida de Device Client en la ventana de terminal del equipo host local,
vuelva alCliente de prueba MQTT. En el navegadorPublicación de un tema, enNombre del tema,
introduzcatest/dc/subtopic2y luego seleccionePublicación.
6. En la ventana del terminal, confirme que el mensaje se ha recibido buscando un mensaje como:

173
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on

subscribe topic, size: 77 bytes

7. Después de ver los mensajes que confirman que se han recibido ambos mensajes, introduzca^C(Ctrl-
C) para detener elAWS IoTCliente del dispositivo.
8. Introduzca este comando para ver el final del archivo de registro de mensajes y ver el mensaje que
publicó desde elCliente de prueba MQTT.

tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log

Note

El archivo de registro de contiene solo las cargas útiles de los mensajes. Los temas de
mensajes no se graban en el archivo de registro de mensajes recibido.
También podría aparecer el mensaje publicado por elAWS IoTCliente de dispositivo en el
registro recibido. Esto se debe a que el filtro de temas comodín incluye ese tema del mensaje
y, a veces, el agente de mensajes puede procesar la solicitud de suscripción antes de enviar
el mensaje publicado a los suscriptores.

Las entradas del archivo de registro demuestran que se han recibido los mensajes. Puede repetir este
procedimiento utilizando otros nombres de temas. Todos los mensajes que tienen un nombre de tema que
comienza portest/dc/deben recibirse y registrarse. Los mensajes con nombres de temas que empiezan
por cualquier otro texto se ignoran.

Después de demostrar cómo elAWS IoTDevice Client puede publicar mensajes MQTT y suscribirse a ellos,
continuarTutorial: Demuestre acciones remotas (trabajos) con elAWS IoTDispositivo de cliente (p. 174).

Tutorial: Demuestre acciones remotas (trabajos) con

elAWS IoTDispositivo de cliente
En estos tutoriales, configurará e implementará trabajos en su Raspberry Pi para demostrar cómo puede
enviar operaciones remotas a sus dispositivos IoT.

Para empezar este tutorial:

• Configure una Raspberry Pi en su equipo host local como se usa enla sección anterior (p. 160).
• Si no has completado el tutorial de la sección anterior, puedes probar este tutorial usando la Raspberry
Pi con una tarjeta microSD que tenga la imagen que guardaste después de instalar elAWS IoTDevice
Client en(Opcional) Guardar la imagen de la tarjeta microSD (p. 153).
• Si ya ha ejecutado esta demostración anteriormente, revise??? (p. 186)eliminar todoAWS IoTrecursos
que creó en ejecuciones anteriores para evitar errores de recursos duplicados.

Este tutorial tarda aproximadamente 45 minutos en completarse.

Cuando haya terminado con este tema:

• Habrás demostrado diferentes maneras en las que tu dispositivo IoT puede usar elAWS IoT Corepara
ejecutar operaciones remotas gestionadas porAWS IoT.

Equipo requerido:

• El entorno local de desarrollo y pruebas que probó enuna sección anterior (p. 151)

174
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

• La Raspberry Pi que probaste enuna sección anterior (p. 151)

• La tarjeta de memoria microSD de la Raspberry Pi que probaste enuna sección anterior (p. 151)

Procedimientos en este tutorial

• Paso 1: Preparar la Raspberry Pi para ejecutar trabajos (p. 175)
• Paso 2: Crear y ejecutar el trabajo enAWS IoT (p. 181)

Paso 1: Preparar la Raspberry Pi para ejecutar trabajos

En los procedimientos de esta sección, se describe cómo preparar su Raspberry Pi para ejecutar trabajos
medianteAWS IoTDispositivo de cliente.
Note
Estos procedimientos son específicos del dispositivo. Si desea realizar los procedimientos de
esta sección con más de un dispositivo al mismo tiempo, cada dispositivo necesitará su propia
política y un certificado y un nombre de cosa únicos y específicos del dispositivo. Para dar a cada
dispositivo sus recursos únicos, realice este procedimiento una vez para cada dispositivo mientras
cambia los elementos específicos del dispositivo como se describe en los procedimientos.

Procedimientos en este tutorial

• Aprovisione su Raspberry Pi para demostrar (p. 175)
• Configura elAWS IoTDevice Client para ejecutar el agente de trabajos (p. 179)

Aprovisione su Raspberry Pi para demostrar

Los procedimientos de esta sección aprovisionan su Raspberry Pi enAWS IoTmediante la creaciónAWS
IoTcertificados de recursos y dispositivos para ello.

Cree y descargue archivos de certificados de dispositivos para realizar una demostraciónAWS

IoTTrabajos
Este procedimiento crea los archivos de certificado de dispositivo para esta demostración.

Si está preparando más de un dispositivo, este procedimiento debe realizarse en cada uno de ellos.

Para crear y descargar los archivos de certificado de dispositivo para tu Raspberry Pi:
En la ventana del terminal del equipo host local que está conectado a la Raspberry Pi, introduce estos
comandos.

1. Ingresa el siguiente comando para crear los archivos de certificado de dispositivo para tu dispositivo.

aws iot create-keys-and-certificate \

--set-as-active \
--certificate-pem-outfile "~/certs/jobs/device.pem.crt" \
--public-key-outfile "~/certs/jobs/public.pem.key" \
--private-key-outfile "~/certs/jobs/private.pem.key"

El comando devuelve una respuesta similar a la siguiente. GuardecertificateArnvalor para un uso

posterior.

{
"certificateArn": "arn:aws:iot:us-
west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",

175
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

"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"
}
}

2. Introduzca los siguientes comandos para establecer los permisos en el directorio de certificados y sus
archivos.

chmod 700 ~/certs/jobs

chmod 644 ~/certs/jobs/*
chmod 600 ~/certs/jobs/private.pem.key

3. Ejecute este comando para revisar los permisos de los directorios y archivos de certificados.

ls -l ~/certs/jobs

La salida del comando debe ser la misma que la que se ve aquí, excepto que las fechas y horas del
archivo 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

Una vez que hayas descargado los archivos del certificado del dispositivo en tu Raspberry Pi, estarás listo
para continuarthe section called “Aprovisione su Raspberry Pi para demostrar” (p. 175).

CrearAWS IoTrecursos para demostrarAWS IoTTrabajos

Crear elAWS IoTrecursos para este dispositivo.

Si está preparando más de un dispositivo, este procedimiento debe realizarse para cada dispositivo.

Para aprovisionar el dispositivo enAWS IoT:

En la ventana del terminal de tu ordenador host local que está conectado a tu Raspberry Pi:

1. Escriba el siguiente comando para obtener la dirección del punto de enlace de datos delCuenta de
AWS.

aws iot describe-endpoint --endpoint-type IoT:Data-ATS

El valor del punto final no ha cambiado desde la última vez que ejecutó este comando. La ejecución
del comando de nuevo aquí facilita la búsqueda y el pegado del valor del punto final de datos en el
archivo de configuración utilizado en este tutorial.

Ladescribe-endpointdevuelve una respuesta similar a la siguiente. Grabar elendpointAddressvalor

para un uso posterior.

{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}

176
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

2. SustituiruniqueThingNamecon un nombre exclusivo para su dispositivo. Si desea realizar

este tutorial con varios dispositivos, asigne a cada dispositivo su propio nombre. Por
ejemplo,TestDevice01,TestDevice02, etc.

Escriba este comando para crear unAWS IoTrecurso thing para tu Raspberry Pi.

aws iot create-thing --thing-name "uniqueThingName"

Porque unAWS IoTthing resource es unvirtualrepresentación de su dispositivo en la nube, podemos

crear varios recursos de cosas enAWS IoTpara usar con diferentes fines. Todos pueden ser utilizados
por el mismo dispositivo IoT físico para representar diferentes aspectos del dispositivo.
Note

Si desea proteger la política para varios dispositivos, puede

usar${iot:Thing.ThingName}en lugar del nombre de la cosa
estática,uniqueThingName.

Estos tutoriales solo usarán un recurso de cosa a la vez por dispositivo. De esta manera, en estos
tutoriales, representan las diferentes demos para que después de crear elAWS IoTrecursos para
una demostración, puede volver atrás y repetir las demostraciones utilizando los recursos que creó
específicamente para cada una.

Si tuAWS IoTthing resource, el comando devuelve una respuesta similar a esta. Grabar
elthingArnpara usarlo más adelante cuando cree el trabajo para ejecutarlo en este dispositivo.

{
"thingName": "uniqueThingName",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/uniqueThingName",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}

3. En la ventana de la terminal:

a. Abra un editor de texto, comonano.

b. Copia este documento JSON y pégalo en tu editor de texto abierto.

{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:client/uniqueThingName"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic",
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/events/job/*",
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/events/jobExecution/*",
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/things/uniqueThingName/jobs/
*"
]

177
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic",
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/events/jobExecution/*",
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/$aws/
things/uniqueThingName/jobs/*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic",
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/things/uniqueThingName/jobs/
*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:DescribeJobExecution",
"iot:GetPendingJobExecutions",
"iot:StartNextPendingJobExecution",
"iot:UpdateJobExecution"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/$aws/things/uniqueThingName"
]
}
]
}

c. En el editor, en elResourcede cada declaración de política, sustituirus-west- 2:57 EJEMPLO

833con tuRegión de AWS, un carácter de dos puntos (:) y los 12 dígitosCuenta de AWSNúmero
de.
d. En el editor, en cada declaración de política, sustituyauniqueThingNamecon el nombre de cosa
que le diste a este recurso de cosa.
e. Guarde el archivo en el editor de texto como~/policies/jobs_test_thing_policy.json.

Si ejecuta este procedimiento para varios dispositivos, guarde el archivo con este nombre de
archivo en cada dispositivo.
4. SustituiruniqueThingNamecon el nombre de cosa del dispositivo y, a continuación, ejecute este
comando para crear unAWS IoTpolítica que se adapta a ese dispositivo.

aws iot create-policy \

--policy-name "JobTestPolicyForuniqueThingName" \
--policy-document "file://~/policies/jobs_test_thing_policy.json"

Si se crea la política, el comando devuelve una respuesta como esta.

{
"policyName": "JobTestPolicyForuniqueThingName",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/
JobTestPolicyForuniqueThingName",

178
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

"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"

5. SustituiruniqueThingNamecon el nombre de la cosa para el dispositivo ycertificateArncon

elcertificateArnque guardó anteriormente en esta sección para este dispositivo y, a continuación,
ejecute este comando para adjuntar la política al certificado del dispositivo.

aws iot attach-policy \

--policy-name "JobTestPolicyForuniqueThingName" \
--target "certificateArn"

Si se ejecuta correctamente, este comando no devuelve nada.

6. SustituiruniqueThingNamepor el nombre de la cosa del dispositivo, sustituyacertificateArncon
elcertificateArnque guardó anteriormente en esta sección y, a continuación, ejecute este
comando para adjuntar el certificado de dispositivo alAWS IoTrecurso thing.

aws iot attach-thing-principal \

--thing-name "uniqueThingName" \
--principal "certificateArn"

Si se ejecuta correctamente, este comando no devuelve nada.

Después de aprovisionar correctamente la Raspberry Pi, estará listo para repetir esta sección para otra
Raspberry Pi en la prueba o, si se han aprovisionado todos los dispositivos, continuarthe section called
“Configura elAWS IoTDevice Client para ejecutar el agente de trabajos” (p. 179).

Configura elAWS IoTDevice Client para ejecutar el agente de trabajos

Con este procedimiento, se crea un archivo de configuración paraAWS IoTDevice Client para ejecutar el
agente de trabajos:.

Nota: si está preparando más de un dispositivo, este procedimiento debe realizarse en cada uno de ellos.

Para crear el archivo de configuración para probarAWS IoTDispositivo de cliente:

1. En la ventana del terminal de tu ordenador host local que está conectado a tu Raspberry Pi:

a. Abra un editor de texto, comonano.

b. Copia este documento JSON y pégalo en tu editor de texto abierto.

{
"endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
"cert": "~/certs/jobs/device.pem.crt",
"key": "~/certs/jobs/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "uniqueThingName",
"logging": {
"enable-sdk-logging": true,
"level": "DEBUG",
"type": "STDOUT",

179
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

"file": ""
},
"jobs": {
"enabled": true,
"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": false,
"publish-topic": "",
"publish-file": "",
"subscribe-topic": "",
"subscribe-file": ""
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}

c. Sustituya elPunto de enlace devalor de punto final de datos del dispositivo para suCuenta
de AWSque encontraste enthe section called “Aprovisionamiento del dispositivo enAWS IoT
Core” (p. 155).
d. SustituiruniqueThingNamecon el nombre de cosa que utilizaste para este dispositivo.
e. Guarde el archivo en el editor de texto como~/dc-configs/dc-jobs-config.json.
2. Ejecute este comando para establecer los permisos de archivo del nuevo archivo de configuración.

chmod 644 ~/dc-configs/dc-jobs-config.json

No usarás elCliente de pruebas de MQTTpara esta prueba. Si bien el dispositivo intercambiará mensajes
MQTT relacionados con los trabajos conAWS IoT, los mensajes de progreso del trabajo solo se
intercambian con el dispositivo que ejecuta el trabajo. Dado que los mensajes de progreso del trabajo
solo se intercambian con el dispositivo que ejecuta el trabajo, no puede suscribirse a ellos desde otro
dispositivo, como elAWS IoTConsola de.

Después de guardar el archivo de configuración, está listo para continuarthe section called “Paso 2: Crear
y ejecutar el trabajo enAWS IoT” (p. 181).

180
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

Paso 2: Crear y ejecutar el trabajo enAWS IoT

Los procedimientos de esta sección crean un documento de trabajo y unAWS IoTrecurso de trabajo. Tras
crear el recurso de trabajo,AWS IoTenvía el documento de trabajo a los destinos de trabajo especificados
en los que un agente de trabajos aplica el documento de trabajo al dispositivo o cliente.

Procedimientos de esta sección

• Crear y almacenar el documento de trabajo del trabajo (p. 181)
• Ejecutar un trabajo enAWS IoTpara un dispositivo IoT (p. 182)

Crear y almacenar el documento de trabajo del trabajo

Este procedimiento crea un documento de trabajo simple para incluirlo en unAWS IoTrecurso de trabajo.
Este documento de trabajo muestra «¡Hola mundo!» en el objetivo del trabajo.

Para crear y almacenar un documento de trabajo:

1. Seleccione el depósito de Amazon S3 en el que guardará el documento de trabajo. Si no tiene un

bucket de Simple Storage (Amazon S3) para usar con esto, debe crear uno. Para obtener información
acerca de cómo crear buckets de Simple Storage (Amazon S3), consulte los temas enIntroducción a
Amazon S3.
2. Crear y guardar el documento de trabajo correspondiente a este trabajo

a. En el equipo host local, abra un editor de texto.

b. Copie y pegue el texto en el editor.

{
"operation": "echo",
"args": ["Hello world!"]
}

c. En el equipo host local, guarde el contenido del editor en un archivo denominadohello-world-

job.json.
d. Confirme que el archivo se guardó correctamente. Algunos editores de texto añaden
automáticamente.txtal nombre del archivo cuando guardan un archivo de texto. Si su editor
anexó.txtal nombre del archivo, corrija el nombre del archivo antes de continuar.
3. Sustituya elruta_al_filecon el camino ahello-world-job.json, si no está en el directorio
actual, sustituyas3_nombre_cubocon la ruta del depósito de Amazon S3 al depósito que seleccionó
y, a continuación, ejecute este comando para colocar el documento de trabajo en el depósito de
Amazon S3.

aws s3api put-object \

--key hello-world-job.json \
--body path_to_file/hello-world-job.json --bucket s3_bucket_name

La URL del documento de trabajo que identifica el documento de trabajo que ha almacenado en
Amazon S3 se determina sustituyendo els3_nombre_cuboyAWS_regiónen la siguiente dirección
URL. Registre la URL resultante para usarla más adelante comoruta_document_trabajo

https://s3_bucket_name.s3.AWS_Region.amazonaws.com/hello-world-job.json

Note
AWSseguridad impide que puedas abrir esta URL fuera de tuCuenta de AWS, por ejemplo,
mediante un navegador. La URL es utilizada por elAWS IoTjobs engine, que tiene acceso

181
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

al archivo, de forma predeterminada. En un entorno de producción, tendrá que asegurarse

de queAWS IoTlos servicios tienen permiso de acceso a los documentos de trabajo
almacenados en Amazon S3.

Después de guardar la URL del documento de trabajo, continúe conthe section called “Ejecutar un trabajo
enAWS IoTpara un dispositivo IoT” (p. 182).

Ejecutar un trabajo enAWS IoTpara un dispositivo IoT

Los procedimientos de esta sección inician elAWS IoTDevice Client en su Raspberry Pi para ejecutar el
agente de trabajos en el dispositivo y esperar a que se ejecuten los trabajos. También crea un recurso de
trabajo enAWS IoT, que enviará el trabajo y se ejecutará en el dispositivo IoT.
Note

Este procedimiento ejecuta un trabajo en un único dispositivo.

Para iniciar el agente de trabajos en tu Raspberry Pi:

1. En la ventana del terminal del equipo host local que está conectado a la Raspberry Pi, ejecuta este
comando para iniciar elAWS IoTDispositivo de cliente.

cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-jobs-config.json

2. En una ventana de terminal, confirme queAWS IoTDevice Client y muestra estos mensajes

2021-11-15T18:45:56.708Z [INFO] {Main.cpp}: Jobs is enabled

.
.
.
2021-11-15T18:45:56.708Z [INFO] {Main.cpp}: Client base has been notified that Jobs
has started
2021-11-15T18:45:56.708Z [INFO] {JobsFeature.cpp}: Running Jobs!
2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to
startNextPendingJobExecution accepted and rejected
2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to
nextJobChanged events
2021-11-15T18:45:56.708Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to
updateJobExecutionStatusAccepted for jobId +
2021-11-15T18:45:56.738Z [DEBUG] {JobsFeature.cpp}: Ack received for
SubscribeToUpdateJobExecutionAccepted with code {0}
2021-11-15T18:45:56.739Z [DEBUG] {JobsFeature.cpp}: Attempting to subscribe to
updateJobExecutionStatusRejected for jobId +
2021-11-15T18:45:56.753Z [DEBUG] {JobsFeature.cpp}: Ack received for
SubscribeToNextJobChanged with code {0}
2021-11-15T18:45:56.760Z [DEBUG] {JobsFeature.cpp}: Ack received for
SubscribeToStartNextJobRejected with code {0}
2021-11-15T18:45:56.776Z [DEBUG] {JobsFeature.cpp}: Ack received for
SubscribeToStartNextJobAccepted with code {0}
2021-11-15T18:45:56.776Z [DEBUG] {JobsFeature.cpp}: Ack received for
SubscribeToUpdateJobExecutionRejected with code {0}
2021-11-15T18:45:56.777Z [DEBUG] {JobsFeature.cpp}: Publishing
startNextPendingJobExecutionRequest
2021-11-15T18:45:56.785Z [DEBUG] {JobsFeature.cpp}: Ack received for
StartNextPendingJobPub with code {0}
2021-11-15T18:45:56.785Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled,
waiting for the next incoming job

3. En la ventana de la terminal, cuando vea este mensaje, continúe con el siguiente procedimiento y cree
el recurso de trabajo. Tenga en cuenta que puede que no sea la última entrada de la lista.

182
 AWS IoT Core Guía para desarrolladores
Demuestre acciones remotas (trabajos)
con elAWS IoTDispositivo de cliente

2021-11-15T18:45:56.785Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled,

waiting for the next incoming job

Para crear unAWS IoTrecurso de trabajo

1. En el equipo host local:

a. Sustituirtrabajo_document_urlcon la URL del documento de trabajo dethe section called

“Crear y almacenar el documento de trabajo del trabajo” (p. 181).
b. Sustituirthing_arncon el ARN del recurso thing que creaste para tu dispositivo y, a
continuación, ejecuta este comando.

aws iot create-job \

--job-id hello-world-job-1 \
--document-source "job_document_url" \
--targets "thing_arn" \
--target-selection SNAPSHOT

Si se ejecuta correctamente, el comando devuelve un resultado similar a este.

{
"jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-1",
"jobId": "hello-world-job-1"
}

2. En una ventana de terminal, debería ver el resultado delAWS IoTDevice Client como este.

2021-11-15T18:02:26.688Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled,

waiting for the next incoming job
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Job ids differ
2021-11-15T18:10:24.890Z [INFO] {JobsFeature.cpp}: Executing job: hello-world-job-1
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Attempting to update job execution
status!
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Not including stdout with the
status details
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Not including stderr with the
status details
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Assuming executable is in PATH
2021-11-15T18:10:24.890Z [INFO] {JobsFeature.cpp}: About to execute: echo Hello world!
2021-11-15T18:10:24.890Z [DEBUG] {Retry.cpp}: Retryable function starting, it will
retry until success
2021-11-15T18:10:24.890Z [DEBUG] {JobsFeature.cpp}: Created EphermalPromise for
ClientToken 3TEWba9Xj6 in the updateJobExecution promises map
2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Child process now running
2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Child process about to call execvp
2021-11-15T18:10:24.890Z [DEBUG] {JobEngine.cpp}: Parent process now running, child PID
is 16737
2021-11-15T18:10:24.891Z [DEBUG] {16737}: Hello world!
2021-11-15T18:10:24.891Z [DEBUG] {JobEngine.cpp}: JobEngine finished waiting for child
process, returning 0
2021-11-15T18:10:24.891Z [INFO] {JobsFeature.cpp}: Job exited with status: 0
2021-11-15T18:10:24.891Z [INFO] {JobsFeature.cpp}: Job executed successfully!
2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Attempting to update job execution
status!
2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Not including stdout with the
status details
2021-11-15T18:10:24.891Z [DEBUG] {JobsFeature.cpp}: Not including stderr with the
status details

183
 AWS IoT Core Guía para desarrolladores
Limpieza

2021-11-15T18:10:24.892Z [DEBUG] {Retry.cpp}: Retryable function starting, it will

retry until success
2021-11-15T18:10:24.892Z [DEBUG] {JobsFeature.cpp}: Created EphermalPromise for
ClientToken GmQ0HTzWGg in the updateJobExecution promises map
2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Ack received for
PublishUpdateJobExecutionStatus with code {0}
2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Removing ClientToken 3TEWba9Xj6
from the updateJobExecution promises map
2021-11-15T18:10:24.905Z [DEBUG] {JobsFeature.cpp}: Success response after
UpdateJobExecution for job hello-world-job-1
2021-11-15T18:10:24.917Z [DEBUG] {JobsFeature.cpp}: Ack received for
PublishUpdateJobExecutionStatus with code {0}
2021-11-15T18:10:24.918Z [DEBUG] {JobsFeature.cpp}: Removing ClientToken GmQ0HTzWGg
from the updateJobExecution promises map
2021-11-15T18:10:24.918Z [DEBUG] {JobsFeature.cpp}: Success response after
UpdateJobExecution for job hello-world-job-1
2021-11-15T18:10:25.861Z [INFO] {JobsFeature.cpp}: No pending jobs are scheduled,
waiting for the next incoming job

3. Si bien elAWS IoTDevice Client se está ejecutando y está esperando un trabajo, puede enviar otro
trabajo cambiando eljob-idValor y volver a ejecutarcreate-jobdesde el Paso 1.

Cuando haya terminado de ejecutar los trabajos, en la ventana de la terminal, introduzca^C(Control-c) para
detener elAWS IoTDispositivo de cliente.

Tutorial: Cómo limpiar después de ejecutar los

tutoriales de AWS IoT Device Client
Los procedimientos de este tutorial le muestran cómo eliminar los archivos y los recursos que creó al
completar los tutoriales de esta ruta de aprendizaje.

Procedimientos de este tutorial

• Paso 1: Limpiar los dispositivos después de crear demostraciones con el AWS IoT Device
Client (p. 184)
• Paso 2: Limpiar las demostraciones Cuenta de AWS posteriores a la creación con el AWS IoT Device
Client (p. 186)

Paso 1: Limpiar los dispositivos después de crear

demostraciones con el AWS IoT Device Client
Este tutorial describe dos opciones para limpiar la tarjeta microSD después de crear las demostraciones de
esta ruta de aprendizaje. Elija la opción que proporcione el nivel de seguridad que necesita.

Ten en cuenta que limpiar la tarjeta microSD del dispositivo no elimina ningún AWS IoT recurso que hayas
creado. Para limpiar los AWS IoT recursos después de limpiar la tarjeta microSD del dispositivo, consulte
el tutorial sobrethe section called “Limpieza después de crear demostraciones con el AWS IoT Device
Client” (p. 186).

Opción 1: Limpiar reescribiendo la tarjeta microSD

La forma más sencilla y completa de limpiar la tarjeta microSD después de completar los tutoriales de esta
ruta de aprendizaje consiste en sobrescribir la tarjeta microSD con un archivo de imagen guardado que
creaste al preparar el dispositivo por primera vez.

Este procedimiento utiliza la computadora host local para escribir una imagen de tarjeta microSD guardada
en una tarjeta microSD.

184
 AWS IoT Core Guía para desarrolladores
Limpieza

Note

Si el dispositivo no utiliza un medio de almacenamiento extraíble para su sistema operativo,

consulte el procedimiento correspondiente a ese dispositivo.

Para escribir una imagen nueva en la tarjeta microSD

1. En el ordenador host local, busque la imagen de la tarjeta microSD guardada que desea grabar en la
tarjeta microSD.
2. Inserte la tarjeta microSD en la computadora host local.
3. Con una herramienta de procesamiento de imágenes de tarjetas SD, escriba el archivo de imagen
seleccionado en la tarjeta microSD.
4. Después de escribir la imagen del sistema operativo Raspberry Pi en la tarjeta microSD, extraiga la
tarjeta microSD y extráigala de forma segura de la computadora host local.

La tarjeta microSD está lista para usarse.

Opción 2: Limpiar mediante la eliminación de directorios de usuario

Para limpiar la tarjeta microSD después de completar los tutoriales sin volver a escribir la imagen de la
tarjeta microSD, puede eliminar los directorios de usuario de forma individual. Esto no es tan exhaustivo
como volver a escribir la tarjeta microSD a partir de una imagen guardada, ya que no elimina ningún
archivo del sistema que pueda haberse instalado.

Si la eliminación de los directorios de usuario es lo suficientemente exhaustiva para sus necesidades,

puede seguir este procedimiento.

Para eliminar los directorios de usuario de esta ruta de aprendizaje de su dispositivo

1. Ejecute estos comandos para eliminar los directorios, subdirectorios y todos sus archivos de usuario
que se crearon en esta ruta de aprendizaje, en la ventana de terminal conectada a su dispositivo.
Note

Tras eliminar estos directorios y archivos, no podrá ejecutar las demostraciones sin volver a
completar los tutoriales.

rm -Rf ~/dc-configs
rm -Rf ~/policies
rm -Rf ~/messages
rm -Rf ~/certs
rm -Rf ~/.aws-iot-device-client

2. Ejecute estos comandos para eliminar los directorios y archivos de origen de la aplicación, en la
ventana del terminal conectada al dispositivo.
Note

Estos comandos no desinstalan ningún programa. Solo eliminan los archivos fuente utilizados
para crearlos e instalarlos. Después de eliminar estos archivos, es posible que el AWS CLI y
el AWS IoT Device Client no funcionen.

rm -Rf ~/aws-cli
rm -Rf ~/aws
rm -Rf ~/aws-iot-device-client

185
 AWS IoT Core Guía para desarrolladores
Limpieza

Paso 2: Limpiar las demostraciones Cuenta de AWS posteriores

a la creación con el AWS IoT Device Client
Estos procedimientos le ayudan a identificar y eliminar los AWS recursos que creó al completar los
tutoriales de esta ruta de aprendizaje.

Limpiar AWS IoT los recursos

Este procedimiento le ayuda a identificar y eliminar los AWS IoT recursos que creó al completar los
tutoriales de esta ruta de aprendizaje.

AWS IoTrecursos creados en esta ruta de aprendizaje

Tutorial Recurso de cosas Recurso de políticas

the section called “Instalar y DevCliTestThing DevCliTestThingPolicy

configurar elAWS IoTCliente del
dispositivo” (p. 151)

the section called “Demostrar PubSubTestThing PubSubTestThingPolicy

la comunicación de mensajes
MQTT con elAWS IoTCliente del
dispositivo” (p. 160)

the section called “Demuestre definido por el usuario (puede definido por el usuario (puede
acciones remotas (trabajos) haber más de uno) haber más de uno)
con elAWS IoTDispositivo de
cliente” (p. 174)

Para eliminar los AWS IoT recursos, siga este procedimiento para cada recurso que haya creado.

1. thing_nameSustitúyalo por el nombre del recurso de la cosa que desea eliminar y, a continuación,
ejecute este comando para enumerar los certificados adjuntos al recurso de la cosa desde la
computadora host local.

aws iot list-thing-principals --thing-name thing_name

Este comando devuelve una respuesta como esta que enumera los certificados a los que se
adjuntanthing_name. En la mayoría de los casos, solo habrá un certificado en la lista.

{
"principals": [
"arn:aws:iot:us-
west-2:57EXAMPLE833:cert/23853eea3cf0edc7f8a69c74abeafa27b2b52823cab5b3e156295e94b26ae8ac"
]
}

2. Para cada certificado enumerado en el comando anterior:

a. certificate_IDSustitúyalo por el ID del certificado del comando anterior. El identificador del

certificado son los caracteres alfanuméricos que aparecen a continuación cert/ en el ARN
devuelto por el comando anterior. A continuación, ejecute este comando para desactivar el
certificado.

aws iot update-certificate --new-status INACTIVE --certificate-id certificate_ID

186
 AWS IoT Core Guía para desarrolladores
Limpieza

Si se ejecuta correctamente, este comando no devuelve nada.

b. certificate_ARNSustitúyalo por el ARN del certificado de la lista de certificados devueltos
anteriormente y, a continuación, ejecute este comando para mostrar las políticas adjuntas a este
certificado.

aws iot list-attached-policies --target certificate_ARN

Este comando devuelve una respuesta como esta que enumera las políticas adjuntas al
certificado. En la mayoría de los casos, solo habrá una política en la lista.

{
"policies": [
{
"policyName": "DevCliTestThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/
DevCliTestThingPolicy"
}
]
}

c. Para cada política adjunta al certificado:

i. policy_nameSustitúyalo por el policyName valor del comando anterior,

certificate_ARN sustitúyalo por el ARN del certificado y, a continuación, ejecute este
comando para separar la política del certificado.

aws iot detach-policy --policy-name policy_name --target certificate_ARN

Si se ejecuta correctamente, este comando no devuelve nada.

ii. policy_nameSustitúyalo por el policyName valor y, a continuación, ejecute este comando
para comprobar si la política está adjunta a algún otro certificado.

aws iot list-targets-for-policy --policy-name policy_name

Si el comando devuelve una lista vacía como esta, la política no se adjunta a ningún
certificado y usted continúa enumerando las versiones de la política. Si aún hay certificados
adjuntos a la política, continúe con el detach-thing-principal paso.

{
"targets": []
}

iii. policy_nameSustitúyalo por el policyName valor y, a continuación, ejecute este comando

para comprobar las versiones de la política. Para eliminar la política, solo debe tener una
versión.

aws iot list-policy-versions --policy-name policy_name

Si la política solo tiene una versión, como en este ejemplo, puede ir directamente al delete-
policy paso y eliminarla ahora.

{
"policyVersions": [
{
"versionId": "1",

187
 AWS IoT Core Guía para desarrolladores
Limpieza

"isDefaultVersion": true,
"createDate": "2021-11-18T01:02:46.778000+00:00"
}
]
}

Si la política tiene más de una versión, como en este ejemplo, las versiones de la política
con un isDefaultVersion valor de se false deben eliminar antes de poder eliminar la
política.

{
"policyVersions": [
{
"versionId": "2",
"isDefaultVersion": true,
"createDate": "2021-11-18T01:52:04.423000+00:00"
},
{
"versionId": "1",
"isDefaultVersion": false,
"createDate": "2021-11-18T01:30:18.083000+00:00"
}
]
}

Si necesita eliminar una versión de política, sustitúyala por policy_name el policyName

valor, version_ID sustitúyala por el versionId valor del comando anterior y, a
continuación, ejecute este comando para eliminar una versión de política.

aws iot delete-policy-version --policy-name policy_name --policy-version-

id version_ID

Si se ejecuta correctamente, este comando no devuelve nada.

Después de eliminar una versión de la política, repita este paso hasta que la política tenga
solo una versión de la política.
iv. policy_nameSustitúyalo por el policyName valor y, a continuación, ejecute este comando
para eliminar la política.

aws iot delete-policy --policy-name policy_name

d. thing_nameReemplace por el nombre de la cosa, certificate_ARN reemplácela por el ARN

del certificado y, a continuación, ejecute este comando para separar el certificado del recurso de
la cosa.

aws iot detach-thing-principal --thing-name thing_name --principal certificate_ARN

Si se ejecuta correctamente, este comando no devuelve nada.

e. certificate_IDSustitúyalo por el ID del certificado del comando anterior. El identificador del
certificado son los caracteres alfanuméricos que aparecen a continuación cert/ en el ARN
devuelto por el comando anterior. A continuación, ejecute este comando para eliminar el recurso
de certificado.

aws iot delete-certificate --certificate-id certificate_ID

Si se ejecuta correctamente, este comando no devuelve nada.

188
 AWS IoT Core Guía para desarrolladores
Limpieza

3. thing_nameReemplácelo por el nombre de la cosa y, a continuación, ejecute este comando para

eliminarla.

aws iot delete-thing --thing-name thing_name

Si se ejecuta correctamente, este comando no devuelve nada.

Limpiar AWS los recursos

Este procedimiento le ayuda a identificar y eliminar otros AWS recursos que haya creado al completar los
tutoriales de esta ruta de aprendizaje.

Otros AWS recursos creados en esta ruta de aprendizaje

Tutorial Tipo de recurso Nombre o ID del recurso

the section called “Demuestre Objeto Amazon S3 hello-world-job.json

acciones remotas (trabajos)
con elAWS IoTDispositivo de
cliente” (p. 174)

the section called “Demuestre AWS IoTrecursos laborales definido por el usuario
acciones remotas (trabajos)
con elAWS IoTDispositivo de
cliente” (p. 174)

Para eliminar los AWS recursos creados en esta ruta de aprendizaje

1. Para eliminar los trabajos creados en esta ruta de aprendizaje

a. Ejecute este comando para enumerar los trabajos de suCuenta de AWS.

aws iot list-jobs

El comando devuelve una lista de los AWS IoT trabajos Región de AWS que tiene Cuenta de
AWS y tiene este aspecto.

{
"jobs": [
{
"jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-2",
"jobId": "hello-world-job-2",
"targetSelection": "SNAPSHOT",
"status": "COMPLETED",
"createdAt": "2021-11-16T23:40:36.825000+00:00",
"lastUpdatedAt": "2021-11-16T23:40:41.375000+00:00",
"completedAt": "2021-11-16T23:40:41.375000+00:00"
},
{
"jobArn": "arn:aws:iot:us-west-2:57EXAMPLE833:job/hello-world-job-1",
"jobId": "hello-world-job-1",
"targetSelection": "SNAPSHOT",
"status": "COMPLETED",
"createdAt": "2021-11-16T23:35:26.381000+00:00",
"lastUpdatedAt": "2021-11-16T23:35:29.239000+00:00",
"completedAt": "2021-11-16T23:35:29.239000+00:00"
}

189
 AWS IoT Core Guía para desarrolladores
Limpieza

]
}

b. Para cada trabajo que reconozca de la lista como un trabajo creado en esta ruta de aprendizaje,
sustitúyalo por jobId el jobId valor del trabajo que se va a eliminar y, a continuación, ejecute
este comando para eliminar un AWS IoT trabajo.

aws iot delete-job --job-id jobId

Si el comando se ejecuta correctamente, no devuelve nada.

2. Para eliminar los documentos de trabajo que almacenó en un bucket de Amazon S3 en esta ruta de
aprendizaje.

a. bucketSustitúyalo por el nombre del depósito que utilizaste y, a continuación, ejecuta este
comando para enumerar los objetos del depósito de Amazon S3 que utilizaste.

aws s3api list-objects --bucket bucket

El comando devuelve una lista de los objetos de Amazon S3 del bucket con este aspecto.

{
"Contents": [
{
"Key": "hello-world-job.json",
"LastModified": "2021-11-18T03:02:12+00:00",
"ETag": "\"868c8bc3f56b5787964764d4b18ed5ef\"",
"Size": 54,
"StorageClass": "STANDARD",
"Owner": {
"DisplayName": "EXAMPLE",
"ID":
"e9e3d6ec1EXAMPLEf5bfb5e6bd0a2b6ed03884d1ed392a82ad011c144736a4ee"
}
},
{
"Key": "iot_job_firmware_update.json",
"LastModified": "2021-04-13T21:57:07+00:00",
"ETag": "\"7c68c591949391791ecf625253658c61\"",
"Size": 66,
"StorageClass": "STANDARD",
"Owner": {
"DisplayName": "EXAMPLE",
"ID":
"e9e3d6ec1EXAMPLEf5bfb5e6bd0a2b6ed03884d1ed392a82ad011c144736a4ee"
}
},
{
"Key": "order66.json",
"LastModified": "2021-04-13T21:57:07+00:00",
"ETag": "\"bca60d5380b88e1a70cc27d321caba72\"",
"Size": 29,
"StorageClass": "STANDARD",
"Owner": {
"DisplayName": "EXAMPLE",
"ID":
"e9e3d6ec1EXAMPLEf5bfb5e6bd0a2b6ed03884d1ed392a82ad011c144736a4ee"
}
}
]
}

190
 AWS IoT Core Guía para desarrolladores
Creación de soluciones con elAWS IoTSDKs de dispositivos

b. Para cada objeto que reconozca de la lista como un objeto que creó en esta ruta de aprendizaje,
bucket sustitúyalo por el nombre del bucket y key por el valor clave del objeto que desea
eliminar y, a continuación, ejecute este comando para eliminar un objeto de Amazon S3.

aws s3api delete-object --bucket bucket --key key

Si el comando se ejecuta correctamente, no devuelve nada.

Después de eliminar todos los AWS recursos y objetos que creó al completar esta ruta de aprendizaje,
puede volver a empezar y repetir los tutoriales.

Creación de soluciones con elAWS IoTSDKs de

dispositivos
Los tutoriales de esta sección le ayudan a explicar los pasos para desarrollar una solución de IoT que se
puede implementar en un entorno de producción medianteAWS IoT.

Estos tutoriales pueden tardar más tiempo en completarse que los de la sección sobrethe section called
“Creación de demostraciones con elAWS IoTCliente del dispositivo” (p. 139)porque utilizan elAWS
IoTSDK de dispositivos y explique los conceptos que se están aplicando con más detalle para ayudarlo a
crear soluciones seguras y fiables.

Comience a crear soluciones con elAWS IoTSDKs de

dispositivos
Estos tutoriales te guían a través de diferentesAWS IoTescenarios de. En su caso, en los tutoriales se
utiliza laAWS IoTSDKs de dispositivos.

Temas
• Tutorial: Conectar un dispositivo aAWS IoT Core mediante el SDK deAWS IoT dispositivos (p. 191)
• CreandoAWS IoTreglas para enrutar los datos del dispositivo a otros servicios (p. 208)
• Conservación del estado del dispositivo mientras el dispositivo está desconectado con Device
Shadows (p. 238)
• Tutorial: Crear un autorizador personalizado para AWS IoT Core (p. 259)
• Tutorial: Monitorear la humedad del suelo con unaAWS IoT Raspberry Pi (p. 271)

Tutorial: Conectar un dispositivo aAWS IoT Core

mediante el SDK deAWS IoT dispositivos
Este tutorial muestra cómo conectar un dispositivo para queAWS IoT Core pueda enviar y recibir datos
desde y haciaAWS IoT. Tras completar este tutorial, tu dispositivo se configurará para conectarseAWS IoT
Core y entenderás cómo se comunican los dispositivos conAWS IoT.

En este tutorial, podrás:

1. the section called “Prepara tu dispositivo paraAWS IoT” (p. 192)

191
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

2. the section called “Revise el protocolo MQTT” (p. 193)

3. the section called “Revise la aplicación de ejemplo del SDK para dispositivos pubsub.py” (p. 193)
4. the section called “Connect tu dispositivo y comunícate conAWS IoT Core” (p. 199)
5. the section called “Revise los resultados” (p. 204)

Para completar este tutorial se necesita aproximadamente una hora.

Antes de comenzar este tutorial, asegúrese de tener:

• FinalizadoIntroducción a AWS IoT Core (p. 18)

En la sección de ese tutorial donde debe hacerlothe section called “Configuración del dispositivo” (p. 42),
seleccione lathe section called “Conecta una Raspberry Pi u otro dispositivo” (p. 60) opción para su
dispositivo y utilice las opciones del lenguaje Python para configurar su dispositivo.

Mantén abierta la ventana de terminal que usas en ese tutorial porque también la usarás en este tutorial.
• Un dispositivo que puede ejecutar el SDK deAWS IoT dispositivos v2 para Python.

Este tutorial muestra cómo conectar un dispositivo a travésAWS IoT Core de ejemplos de código Python,
que requieren un dispositivo relativamente potente.

Si trabaja con dispositivos con recursos limitados, es posible que estos ejemplos de código no funcionen
en ellos. En ese caso, es posible que tenga más éxito con elthe section called “Mediante AWS IoT
Device SDK para Embedded C” (p. 205) tutorial.

Prepara tu dispositivo paraAWS IoT

EnIntroducción a AWS IoT Core (p. 18), preparaste tu dispositivo y tuAWS cuenta para que pudieran
comunicarse. En esta sección se revisan los aspectos de esa preparación que se aplican a cualquier
conexión de dispositivo conAWS IoT Core.

Para conectar un dispositivo aAWS IoT Core:

1. Debe tener una Cuenta de AWS.

El procedimiento que seConfigura tuCuenta de AWS (p. 19) describe cómo crear unCuenta de AWS si
aún no dispone de uno.
2. En esa cuenta, debe tener definidos los siguientes AWS IoTrecursos para el dispositivo de su
regiónCuenta de AWS y región.

El procedimiento descritoCrearAWS IoTrecursos (p. 39) describe cómo crear estos recursos para el
dispositivo en su regiónCuenta de AWS y en su región.
• Un certificado de dispositivo registradoAWS IoT y activado para autenticar el dispositivo.

El certificado a menudo se crea con un objeto deAWS IoT cosa y se adjunta a él. Si bien no se
requiere un objeto objeto para conectarse a un dispositivoAWS IoT, hace queAWS IoT las funciones
adicionales estén disponibles para el dispositivo.
• Una política adjunta al certificado del dispositivo que lo autoriza a conectarseAWS IoT Core y a
realizar todas las acciones que desee realizar.
3. Una conexión a Internet que pueda acceder a los terminalesCuenta de AWS de tu dispositivo.

Los terminales del dispositivo se describenAWS IoTpuntos finales de servicio y datos del
dispositivo (p. 83) y se pueden ver en la página de configuración de laAWS IoT consola.
4. Software de comunicación, como los SDK deAWS IoT dispositivos que proporcionan. Este tutorial usa el
SDK deAWS IoT dispositivos v2 para Python.

192
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

Revise el protocolo MQTT

Antes de hablar de la aplicación de ejemplo, es útil entender el protocolo MQTT. El protocolo MQTT ofrece
algunas ventajas sobre otros protocolos de comunicación de red, como HTTP, lo que lo convierte en
una opción popular para los dispositivos de IoT. Esta sección revisa los aspectos clave de MQTT que se
aplican a este tutorial. Para obtener información sobre cómo se compara MQTT con HTTP, consulteElegir
un protocolo para la comunicación del dispositivo (p. 88).

MQTT utiliza un modelo de comunicación de publicación/suscripción

El protocolo MQTT utiliza un modelo de comunicación de publicación/suscripción con su anfitrión. Este

modelo difiere del modelo de solicitud/respuesta que usa HTTP. Con MQTT, los dispositivos establecen
una sesión con el host que se identifica mediante un ID de cliente único. Para enviar datos, los dispositivos
publican los mensajes identificados por temas en un intermediario de mensajes del host. Para recibir
mensajes del agente de mensajes, los dispositivos se suscriben a los temas enviando filtros de temas en
las solicitudes de suscripción al agente de mensajes.

MQTT admite sesiones persistentes

El agente de mensajes recibe mensajes de los dispositivos y los publica en los dispositivos que se han
suscrito a ellos. Con las sesiones persistentes (p. 92) (sesiones que permanecen activas incluso cuando el
dispositivo iniciador está desconectado), los dispositivos pueden recuperar los mensajes que se publicaron
mientras estaban desconectados. En cuanto al dispositivo, MQTT admite niveles de calidad de servicio
(QoS (p. 92)) que garantizan que el host reciba los mensajes enviados por el dispositivo.

Revise la aplicación de ejemplo del SDK para dispositivos

pubsub.py
En esta sección se analiza la aplicación depubsub.py ejemplo del AWS IoTDevice SDK v2 para
Python que se utiliza en este tutorial. A continuación, analizaremos cómo se conecta para publicar y
suscribirseAWS IoT Core a los mensajes de MQTT. La siguiente sección presenta algunos ejercicios que
le ayudarán a explorar cómo se conecta un dispositivo y se comunica con élAWS IoT Core.

La aplicaciónpubsub.py de ejemplo muestra estos aspectos de una conexión MQTT conAWS IoT Core:
• Protocolos de comunicación (p. 193)
• Sesiones persistentes (p. 196)
• Calidad de servicio (p. 196)
• Publicación de mensajes (p. 197)
• Suscribirse a mensajes (p. 198)
• Desconexión y reconexión del dispositivo (p. 199)

Protocolos de comunicación
Elpubsub.py ejemplo muestra una conexión MQTT que utiliza los protocolos MQTT y MQTT sobre WSS.
La biblioteca AWSCommon Runtime (AWSCRT) proporciona soporte para protocolos de comunicación de
bajo nivel y se incluye en elAWS IoT Device SDK v2 para Python.

MQTT

Elpubsub.py ejemplo de llamadasmtls_from_path (que se muestra aquí) se encuentra en el

mqtt_connection_builderpara establecer una conexiónAWS IoT Core mediante el protocolo MQTT.
mtls_from_pathusa certificados X.509 y TLS v1.2 para autenticar el dispositivo. La bibliotecaAWS CRT
gestiona los detalles de nivel inferior de esa conexión.

193
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)

endpoint

El punto finalCuenta de AWS de su dispositivo de IoT

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

cert_filepath

La ruta al archivo de certificado del dispositivo

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

pri_key_filepath

La ruta al archivo de clave privada del dispositivo que se creó con su archivo de certificado

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

ca_filepath

La ruta al archivo CA raíz. Solo es obligatorio si el servidor MQTT usa un certificado que no esté ya en
su almacén de confianza.

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

client_bootstrap

El objeto de ejecución común que gestiona las actividades de comunicación de sockets

En la aplicación de ejemplo, este objeto se crea una instancia antes de la llamada

amqtt_connection_builder.mtls_from_path.
on_connection_interrupted, on_connection_resumed

Las funciones de devolución de llamada permiten llamar cuando la conexión del dispositivo se
interrumpe y se reanuda
client_id

El identificador que identifica de forma exclusiva este dispositivo en elRegión de AWS

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

clean_session

Si se debe iniciar una nueva sesión persistente o, si hay una, volver a conectarse a una existente
keep_alive_secs

El valor de mantener vivo, en segundos, para enviar laCONNECT solicitud. Se enviará automáticamente
un ping en este intervalo. Si el servidor no recibe un ping después de 1,5 veces este valor, asume que
la conexión se ha perdido.

194
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

MQTT a través de WSS

Elpubsub.py ejemplo de llamadaswebsockets_with_default_aws_signing (que se muestra aquí)

es mqtt_connection_builderpara establecer una conexión con elAWS IoT Core uso del protocolo
MQTT a través de WSS. websockets_with_default_aws_signingcrea una conexión MQTT a través
de WSS mediante Signature V4 para autenticar el dispositivo.

mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
endpoint=args.endpoint,
client_bootstrap=client_bootstrap,
region=args.signing_region,
credentials_provider=credentials_provider,
websocket_proxy_options=proxy_options,
ca_filepath=args.ca_file,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)

endpoint

El punto finalCuenta de AWS de su dispositivo de IoT

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

client_bootstrap

El objeto de ejecución común que gestiona las actividades de comunicación de sockets

En la aplicación de ejemplo, este objeto se crea una instancia antes de la llamada

amqtt_connection_builder.websockets_with_default_aws_signing.
region

La región deAWS firma utilizada por la autenticación Signature V4. Enpubsub.py, pasa el parámetro
introducido en la línea de comando.

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

credentials_provider

LasAWS credenciales proporcionadas para su uso en la autenticación

En la aplicación de ejemplo, este objeto se crea una instancia antes de la llamada

amqtt_connection_builder.websockets_with_default_aws_signing.
websocket_proxy_options

Opciones de proxy HTTP, si se utiliza un host proxy

En la aplicación de ejemplo, este valor se inicializa antes de la llamada

amqtt_connection_builder.websockets_with_default_aws_signing.
ca_filepath

La ruta al archivo CA raíz. Solo es obligatorio si el servidor MQTT usa un certificado que no esté ya en
su almacén de confianza.

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

195
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

on_connection_interrupted, on_connection_resumed

Las funciones de devolución de llamada permiten llamar cuando la conexión del dispositivo se
interrumpe y se reanuda
client_id

El identificador que identifica de forma exclusiva este dispositivo enRegión de AWS.

En la aplicación de ejemplo, este valor se transfiere desde la línea de comandos.

clean_session

Si se debe iniciar una nueva sesión persistente o, si hay una, volver a conectarse a una existente
keep_alive_secs

El valor de mantener vivo, en segundos, para enviar laCONNECT solicitud. Se enviará automáticamente
un ping en este intervalo. Si el servidor no recibe un ping después de 1,5 veces este valor, asume que
la conexión se ha perdido.

HTTPS

¿Qué pasa con HTTPS? AWS IoT Coreadmite dispositivos que publican solicitudes HTTPS. Desde el
punto de vista de la programación, los dispositivos envían solicitudes HTTPSAWS IoT Core como lo haría
cualquier otra aplicación. Para ver un ejemplo de un programa de Python que envía un mensaje HTTP
desde un dispositivo, consulta el ejemplo de código HTTPS (p. 110) con larequests biblioteca de Python.
En este ejemplo se envía un mensaje aAWS IoT Core través de HTTPS, que loAWS IoT Core interpreta
como un mensaje MQTT.

Si bienAWS IoT Core admite las solicitudes HTTPS de los dispositivos, asegúrese de revisar la
informaciónElegir un protocolo para la comunicación del dispositivo (p. 88) para poder tomar una decisión
informada sobre qué protocolo utilizar para las comunicaciones de su dispositivo.

Sesiones persistentes
En la aplicación de ejemplo, si se establece elclean_session parámetro en, seFalse indica que la
conexión debe ser persistente. En la práctica, esto significa que la conexión abierta por esta llamada se
vuelve a conectar a una sesión persistente existente, si existe. De lo contrario, crea una nueva sesión
persistente y se conecta a ella.

Con una sesión persistente, el agente de mensajes almacena los mensajes que se envían al dispositivo
mientras el dispositivo no está conectado. Cuando un dispositivo se vuelve a conectar a una sesión
persistente, el agente de mensajes envía al dispositivo todos los mensajes almacenados a los que se haya
suscrito.

Sin una sesión persistente, el dispositivo no recibirá los mensajes que se envíen mientras el dispositivo
no esté conectado. La opción que se utilice depende de la aplicación y de si se deben comunicar los
mensajes que se producen mientras el dispositivo no está conectado. Para obtener más información,
consulte Sesiones persistentes de MQTT (p. 92).

Calidad de servicio
Cuando el dispositivo publica mensajes y se suscribe a ellos, se puede configurar la calidad de servicio
(QoS) preferida. AWS IoTadmite los niveles de QoS 0 y 1 para las operaciones de publicación y
suscripción. Para obtener más información sobre los niveles de QoS enAWS IoT, consulteOpciones de
calidad de servicio (QoS) de MQTT (p. 92).

El tiempo de ejecución deAWS CRT para Python define estas constantes para los niveles de QoS que
admite:

196
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

Niveles de calidad de servicio de Python

Nivel de QoS de MQTT Valor simbólico de Python Descripción

utilizado por el SDK

Nivel de QoS 0 mqtt.QoS.AT_MOST_ONCE Solo se realizará un intento de

enviar el mensaje, tanto si se
recibe como si no. Es posible
que el mensaje no se envíe
en absoluto, por ejemplo, si el
dispositivo no está conectado o si
hay un error de red.

Nivel 1 de QoS mqtt.QoS.AT_LEAST_ONCE El mensaje se envía

repetidamente hasta que se
reciba unPUBACK acuse de
recibo.

En la aplicación de ejemplo, las solicitudes de publicación y suscripción se realizan con un nivel de QoS de
1 (mqtt.QoS.AT_LEAST_ONCE).

• QoS al publicar

Cuando un dispositivo publica un mensaje con el nivel 1 de QoS, lo envía repetidamente hasta que
recibe unaPUBACK respuesta del intermediario de mensajes. Si el dispositivo no está conectado, el
mensaje se pone en cola para enviarse cuando se vuelva a conectar.
• QoS al suscribirse

Cuando un dispositivo se suscribe a un mensaje con el nivel 1 de QoS, el agente de mensajes

guarda los mensajes a los que está suscrito el dispositivo hasta que puedan enviarse al dispositivo. El
intermediario de mensajes reenvía los mensajes hasta que reciba unaPUBACK respuesta del dispositivo.

Publicación de mensajes
Tras establecer correctamente una conexión conAWS IoT Core, los dispositivos pueden publicar mensajes.
Elpubsub.py ejemplo hace esto llamando a lapublish operación delmqtt_connection objeto.

mqtt_connection.publish(
topic=args.topic,
payload=message,
qos=mqtt.QoS.AT_LEAST_ONCE
)

topic

El nombre del tema del mensaje que identifica el mensaje

En la aplicación de ejemplo, esto se transmite desde la línea de comandos.

payload

La carga útil del mensaje con formato de cadena (por ejemplo, un documento JSON)

En la aplicación de ejemplo, esto se transmite desde la línea de comandos.

Un documento JSON es un formato de carga común y es reconocido por otrosAWS IoT servicios; sin
embargo, el formato de datos de la carga útil del mensaje puede ser cualquier formato que acuerden

197
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

los editores y los suscriptores. Sin embargo, otrosAWS IoT servicios solo reconocen JSON y CBOR,
en algunos casos, para la mayoría de las operaciones.
qos

El nivel de QoS de este mensaje

Suscribirse a mensajes
Para recibir mensajes de otros serviciosAWS IoT y dispositivos, los dispositivos se suscriben a esos
mensajes por el nombre del tema. Los dispositivos pueden suscribirse a mensajes individuales
especificando un nombre de tema (p. 113) y a un grupo de mensajes especificando un filtro de
tema (p. 114), que puede incluir caracteres comodín. Elpubsub.py ejemplo usa el código que se muestra
aquí para suscribirse a los mensajes y registrar las funciones de devolución de llamada para procesar el
mensaje una vez recibido.

subscribe_future, packet_id = mqtt_connection.subscribe(

topic=args.topic,
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_message_received
)
subscribe_result = subscribe_future.result()

topic

El tema al que se suscribe. Puede ser un nombre de tema o un filtro de tema.

En la aplicación de ejemplo, esto se transmite desde la línea de comandos.

qos

Si el agente de mensajes debe almacenar estos mensajes mientras el dispositivo está desconectado.

Un valor demqtt.QoS.AT_LEAST_ONCE (nivel de QoS 1) requiere que se especifique una sesión

persistente (clean_session=False) al crear la conexión.
callback

La función a la que llamar para procesar el mensaje suscrito.

Lamqtt_connection.subscribe función devuelve un future y un identificador de paquete. Si la solicitud

de suscripción se inició correctamente, el ID del paquete devuelto es superior a 0. Para asegurarse de que
el agente de mensajes recibió y registró la suscripción, debe esperar a que aparezca el resultado de la
operación asincrónica, como se muestra en el ejemplo de código.

La función de devolución de llamada

La devolución de llamada delpubsub.py ejemplo procesa los mensajes suscritos a medida que el
dispositivo los recibe.

def on_message_received(topic, payload, **kwargs):

print("Received message from topic '{}': {}".format(topic, payload))
global received_count
received_count += 1
if received_count == args.count:
received_all_event.set()

topic

El tema del mensaje

198
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

Este es el nombre de tema específico del mensaje recibido, incluso si te suscribiste a un filtro de
temas.
payload

La carga de mensajes

El formato para ello es específico de la aplicación.

kwargs

Posibles argumentos adicionales, tal como se describe en mqtt.Connection.subscribe.

En elpubsub.py ejemplo,on_message_received solo muestra el tema y su carga útil. También cuenta

los mensajes recibidos para finalizar el programa una vez alcanzado el límite.

Tu aplicación evaluaría el tema y la carga útil para determinar qué acciones realizar.

Desconexión y reconexión del dispositivo

Elpubsub.py ejemplo incluye funciones de devolución de llamada que se invocan cuando se desconecta
el dispositivo y cuando se restablece la conexión. Las acciones que realiza el dispositivo en relación con
estos eventos son específicas de la aplicación.

Cuando un dispositivo se conecta por primera vez, debe suscribirse a los temas para recibir. Si la sesión
de un dispositivo está presente cuando se vuelve a conectar, sus suscripciones se restauran y todos
los mensajes almacenados de esas suscripciones se envían al dispositivo después de que se vuelva a
conectar.

Si la sesión de un dispositivo ya no existe cuando se vuelve a conectar, debe volver a suscribirse a sus
suscripciones. Las sesiones persistentes tienen una duración limitada y pueden caducar si el dispositivo se
desconecta durante demasiado tiempo.

Connect tu dispositivo y comunícate conAWS IoT Core

En esta sección se presentan algunos ejercicios que le ayudarán a explorar diferentes aspectos de la
conexión del dispositivo aAWS IoT Core. Para estos ejercicios, utilizarás el cliente de prueba MQTT de
laAWS IoT consola para ver lo que publica tu dispositivo y publicar mensajes en tu dispositivo. Estos
ejercicios utilizan el pubsub.pyejemplo del AWS IoTDevice SDK v2 para Python y se basan en tu
experiencia conIntroducción a AWS IoT Core (p. 18) los tutoriales.

En esta sección, podrá:

• Suscríbete a los filtros de temas comodín (p. 199)
• Procesar suscripciones al filtro de temas (p. 201)
• Publica mensajes desde tu dispositivo (p. 203)

Para estos ejercicios, empezará con el programa depubsub.py muestra.

Note

En estos ejercicios se parte del supuesto de que ha completado losIntroducción a AWS IoT
Core (p. 18) tutoriales y que ha utilizado la ventana de terminal del dispositivo que aparece en ese
tutorial.

Suscríbete a los filtros de temas comodín

En este ejercicio, modificará la línea de comando utilizada para llamar para suscribirsepubsub.py a un
filtro de tema comodín y procesará los mensajes recibidos en función del tema del mensaje.

199
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

Procedimiento de

Para este ejercicio, imagine que su dispositivo contiene un control de temperatura y un control de luz.
Utiliza estos nombres de temas para identificar los mensajes sobre ellos.

1. Antes de empezar el ejercicio, intenta ejecutar este comando desde losIntroducción a AWS IoT
Core (p. 18) tutoriales de tu dispositivo para asegurarte de que todo está preparado para el ejercicio.

cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/
certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint

Deberías ver el mismo resultado que viste en el tutorial de introducción (p. 64).
2. Para este ejercicio, cambie estos parámetros de la línea de comandos.

Acción Parámetro de línea de Efecto

comandos

agregar --message "" Configurarpubsub.py para

escuchar solo

agregar --count 2 Finalice el programa después

de recibir dos mensajes

cambiar --topic device/+/details Defina el filtro de temas al que

suscribirse

Al realizar estos cambios en la línea de comando inicial, se obtiene esta línea de comandos.
Introduzca este comando en la ventana del terminal de su dispositivo.

python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/

Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --
endpoint your-iot-endpoint

El programa debería mostrar algo similar al siguiente:

Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID

'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...

Si ves algo como esto en tu terminal, tu dispositivo está preparado y escuchando los mensajes en los
que los nombres de los temas comiencendevice y terminen con/detail. Así que probemos eso.
3. Estos son algunos mensajes que puede recibir tu dispositivo.

Nombre del tema Carga de mensajes

device/temp/details { "desiredTemp": 20, "currentTemp":

15 }

device/light/details { "desiredLight": 100,

"currentLight": 50 }

200
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

4. Con el cliente de prueba MQTT de laAWS IoT consola, envíe los mensajes descritos en el paso
anterior a su dispositivo.

a. Abra el cliente de prueba MQTT en laAWS IoT consola.

b. En Suscribirse a un tema, en el campo Tema de suscripción, introduzca el filtro de temas:
ydevice/+/details, a continuación, seleccione Suscribirse al tema.
c. En la columna Suscripciones del cliente de prueba de MQTT, seleccione dispositivo/+/details.
d. Para cada uno de los temas de la tabla anterior, haga lo siguiente en el cliente de prueba MQTT:

1. En Publicar, introduzca el valor de la columna Nombre del tema de la tabla.

2. En el campo Carga útil del mensaje situado debajo del nombre del tema, introduzca el valor de
la columna Carga útil del mensaje de la tabla.
3. Observe la ventana de terminal en la quepubsub.py se está ejecutando y, en el cliente de
prueba de MQTT, elija Publicar en el tema.

Debería ver que el mensaje se recibiópubsub.py en la ventana de la terminal.

Resultado de

Con estopubsub.py, se suscribió a los mensajes mediante un filtro de tema comodín, los recibió y los
mostró en la ventana del terminal. Observa cómo te suscribiste a un único filtro de temas y que se llamó a
la función de devolución de llamada para procesar los mensajes que tenían dos temas distintos.

Procesar suscripciones al filtro de temas

Basándose en el ejercicio anterior, modifique la aplicación depubsub.py ejemplo para evaluar los temas
de los mensajes y procesar los mensajes suscritos en función del tema.

Procedimiento de

Para evaluar el tema del mensaje

1. Copie pubsub.py en pubsub2.py.

2. Abrapubsub2.py en el IDE o editor de texto que prefiera.
3. Enpubsub2.py, busque laon_message_received función.
4. Enon_message_received, inserte el siguiente código después de la línea que comienza
porprint("Received message y antes de la línea que comienza porglobal received_count.

topic_parsed = False
if "/" in topic:
parsed_topic = topic.split("/")
if len(parsed_topic) == 3:
# this topic has the correct format
if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
# this is a topic we care about, so check the 2nd element
if (parsed_topic[1] == 'temp'):
print("Received temperature request: {}".format(payload))
topic_parsed = True
if (parsed_topic[1] == 'light'):
print("Received light request: {}".format(payload))
topic_parsed = True
if not topic_parsed:
print("Unrecognized message topic.")

5. Guarde los cambios y ejecute el programa modificado mediante esta línea de comandos.

201
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/

Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --
endpoint your-iot-endpoint

6. En laAWS IoT consola, abra el cliente de prueba MQTT.

7. En Suscribirse a un tema, en el campo Tema de suscripción, introduzca el filtro de temas: ydevice/
+/details, a continuación, seleccione Suscribirse al tema.
8. En la columna Suscripciones del cliente de prueba de MQTT, seleccione dispositivo/+/details.
9. Para cada uno de los temas de esta tabla, haga lo siguiente en el cliente de prueba MQTT:

Nombre del tema Carga de mensajes

device/temp/details { "desiredTemp": 20, "currentTemp":

15 }

device/light/details { "desiredLight": 100,

"currentLight": 50 }

1. En Publicar, introduzca el valor de la columna Nombre del tema de la tabla.

2. En el campo Carga útil del mensaje situado debajo del nombre del tema, introduzca el valor de la
columna Carga útil del mensaje de la tabla.
3. Observe la ventana de terminal en la quepubsub.py se está ejecutando y, en el cliente de prueba
de MQTT, elija Publicar en el tema.

Debería ver que el mensaje se recibiópubsub.py en la ventana de la terminal.

Debería ver algo similar a esto en la ventana de la terminal.

Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-

af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100,
"currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp":
15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!

Resultado de

En este ejercicio, agregaste código para que la aplicación de ejemplo reconociera y procesara varios
mensajes en la función de devolución de llamada. Con esto, su dispositivo podría recibir mensajes y actuar
en consecuencia.

Otra forma de que el dispositivo reciba y procese varios mensajes es suscribirse a diferentes mensajes por
separado y asignar cada suscripción a su propia función de devolución de llamadas.

202
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

Publica mensajes desde tu dispositivo

Puedes usar la aplicación de ejemplo pubsub.py para publicar mensajes desde tu dispositivo. Si bien
publicará los mensajes tal como están, los mensajes no se pueden leer como documentos JSON. Este
ejercicio modifica la aplicación de ejemplo para poder publicar documentos JSON en la carga de mensajes
que puedan leerseAWS IoT Core.

Procedimiento de

En este ejercicio, se enviará el siguiente mensaje con eldevice/data tema.

{
"timestamp": 1601048303,
"sensorId": 28,
"sensorData": [
{
"sensorName": "Wind speed",
"sensorValue": 34.2211224
}
]
}

Para preparar su cliente de prueba de MQTT para monitorear los mensajes de este ejercicio

1. En Suscribirse a un tema, en el campo Tema de suscripción, introduzca el filtro de temas: ydevice/

data, a continuación, seleccione Suscribirse al tema.
2. En la columna Suscripciones del cliente de prueba de MQTT, seleccione dispositivo/datos.
3. Mantenga abierta la ventana del cliente de prueba de MQTT para esperar los mensajes de su
dispositivo.

Para enviar documentos JSON con la aplicación de ejemplo pubsub.py

1. En tu dispositivo, copiapubsub.py apubsub3.py.

2. Editepubsub3.py para cambiar el formato de los mensajes que publica.

a. Abra pubsub3.py en un editor de texto.

b. Busque esta línea de código:

message = "{} [{}]".format(message_string, publish_count)

c. Cámbielo a:

message = "{}".format(message_string)
d. Busque esta línea de código:

message_json = json.dumps(message)
e. Cámbielo a:

message = "{}".json.dumps(json.loads(message))
f. Guarde los cambios.
3. En el dispositivo, ejecuta este comando para enviar el mensaje dos veces.

python3 pubsub3.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/

device.pem.crt --key ~/certs/private.pem.key --topic device/data --count 2 --
message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind
speed","sensorValue":34.2211224}]}' --endpoint your-iot-endpoint

203
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

4. En el cliente de prueba de MQTT, compruebe que ha interpretado y formateado el documento JSON

de la carga del mensaje, como este:

De forma predeterminada,pubsub3.py también se suscribe a los mensajes que envía. Deberías ver que
ha recibido los mensajes en la salida de la aplicación. La ventana de la terminal debería tener un aspecto
similar al siguiente.

Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID

'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data':
{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind
speed","sensorValue":34.2211224}]}
Received message from topic 'device/data':
b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind
speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data':
{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind
speed","sensorValue":34.2211224}]}
Received message from topic 'device/data':
b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind
speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!

Resultado de
Con esto, el dispositivo puede generar mensajes para enviarlosAWS IoT Core a fin de probar la
conectividad básica y proporcionar mensajes del dispositivoAWS IoT Core para su procesamiento. Por
ejemplo, puedes usar esta aplicación para enviar datos de prueba desde tu dispositivo para probar las
acciones de lasAWS IoT reglas.

Revise los resultados

Los ejemplos de este tutorial le proporcionaron experiencia práctica con los conceptos básicos de cómo
los dispositivos pueden comunicarse conAWS IoT Core, una parte fundamental de suAWS IoT solución.
Cuando sus dispositivos pueden comunicarse con ellosAWS IoT Core, pueden transmitir mensajes a
losAWS servicios y otros dispositivos en los que pueden actuar. Del mismo modo,AWS los servicios y otros
dispositivos pueden procesar la información que resulta en el envío de mensajes a sus dispositivos.

Cuando esté listo paraAWS IoT Core seguir explorando, pruebe estos tutoriales:

• the section called “Envío de una notificación de Amazon SNS” (p. 216)

204
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

• the section called “Almacenamiento de datos del dispositivo en una tabla de DynamoDB” (p. 224)
• the section called “Formatear una notificación mediante unAWS Lambdafunción” (p. 229)

Tutorial: Mediante AWS IoT Device SDK para Embedded C

En esta sección, se explica cómo se ejecuta el AWS IoT Device SDK para Embedded C.

Procedimientos de esta sección

• Paso 1: Instalar la AWS IoT Device SDK para Embedded C (p. 205)
• Paso 2: Configurar la aplicación de muestra (p. 205)
• Paso 3: Crear y ejecutar la aplicación de ejemplo (p. 207)

Paso 1: Instalar la AWS IoT Device SDK para Embedded C

AWS IoT Device SDK para Embedded C generalmente se dirige a dispositivos con limitaciones de
recursos que requieren un tiempo de ejecución optimizado del lenguaje C. Puede usar el SDK en cualquier
sistema operativo y alojarlo en cualquier tipo de procesador (por ejemplo, MCU y MPU). Si dispone de más
memoria y recursos de procesamiento, le recomendamos que utilice uno de los pedidos superiores.AWS
IoTSDK para dispositivos y dispositivos móviles (por ejemplo, C++, Java,JavaScripty Python).

En general, AWS IoT Device SDK para Embedded C está dirigido a sistemas que utilizan MCU o MPU de
bajo rendimiento que ejecutan sistemas operativos integrados. Para el ejemplo de programación de esta
sección, asumimos que su dispositivo utiliza Linux.

Example

1. Descarga deAWS IoT Device SDK para Embedded Ca tu dispositivo desdeGitHub.

git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules

Esto crea un directorio denominado aws-iot-device-sdk-embedded-c en el directorio actual.

2. Vaya a ese directorio y retire la última versión. Consultegithub.com/aws/aws-iot-device-SDK
incrustadas-C/etiquetasPara obtener la etiqueta de versión más reciente.

cd aws-iot-device-sdk-embedded-c
git checkout latest-release-tag

3. Instale OpenSSL versión 1.1.0 o posterior. Las bibliotecas de desarrollo de OpenSSL suelen
denominarse «libssl-dev» o «openssl-devel» cuando se instalan a través de un gestor de paquetes.

sudo apt-get install libssl-dev

Paso 2: Configurar la aplicación de muestra

El AWS IoT Device SDK para Embedded C contiene aplicaciones de ejemplo que puede probar. Para
simplificar el proceso, este tutorial utiliza lamqtt_demo_mutual_auth, que ilustra cómo conectarse a
laAWS IoT Coreagente de mensajes y suscribirse y publicar en temas MQTT.

1. Copie el certificado y la clave privada que creó enIntroducción a AWS IoT Core (p. 18)en elbuild/
bin/certificatesdirectorio.

205
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

Note

Los certificados de dispositivo y de entidad de certificación raíz están sujetos a vencimiento o

revocación. Si estos certificados caducan o se revocan, debe copiar un nuevo certificado de
CA o un certificado de clave privada y dispositivo en el dispositivo.
2. Debe configurar el ejemplo con su punto de enlace de AWS IoT Core, su clave privada, su certificado
y su certificado de la entidad de certificación raíz personales. Vaya al directorio aws-iot-device-
sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth.

Si tiene laAWS CLIinstalada, puede utilizar este comando para buscar la URL del punto de enlace de
su cuenta.

aws iot describe-endpoint --endpoint-type iot:Data-ATS

Si no tiene instalada la AWS CLI, abra la consola de AWS IoT. Desde el panel de navegación, elija
Manage (Administrar) y, a continuación, Things (Objetos). Elija la cosa IoT de su dispositivo y, a
continuación, elijaInteractuar. Su punto de enlace se muestra en la sección HTTPS de la página de
detalles del objeto.
3. Abra el iconodemo_config.hy actualice los valores de los elementos siguientes:

AWS_IOT_ENDPOINT

Su punto de enlace personal.

CLIENT_CERT_PATH

La ruta del archivo de certificado, por ejemplocertificates/device.pem.crt".

CLIENT_PRIVATE_KEY_PATH

Por ejemplo, el nombre del archivo de la clave privadacertificates/private.pem.key.

Por ejemplo:

// Get from demo_config.h

// =================================================
#define AWS_IOT_ENDPOINT "my-endpoint-ats.iot.us-east-1.amazonaws.com"
#define AWS_MQTT_PORT 8883
#define CLIENT_IDENTIFIER "testclient"
#define ROOT_CA_CERT_PATH "certificates/AmazonRootCA1.crt"
#define CLIENT_CERT_PATH "certificates/my-device-cert.pem.crt"
#define CLIENT_PRIVATE_KEY_PATH "certificates/my-device-private-key.pem.key"
// =================================================

4. Compruebe si tiene CMake instalado en el dispositivo mediante este comando.

cmake --version

Si ve la información de la versión del compilador, puede continuar con la siguiente sección.

Si aparece un error o no ve la información, deberá instalar el paquete cmake mediante este comando.

sudo apt-get install cmake

Ejecute lacmake --versiony confirme que CMake se ha instalado y que está listo para continuar.
5. Compruebe si tiene las herramientas de desarrollo instaladas en su dispositivo mediante este
comando.

206
 AWS IoT Core Guía para desarrolladores
Conectar un dispositivo aAWS IoT Core
mediante el SDK deAWS IoT dispositivos

gcc --version

Si ve la información de la versión del compilador, puede continuar con la siguiente sección.

Si aparece un error o no ve la información del compilador, deberá instalar el paquete build-

essential con este comando.

sudo apt-get install build-essential

Vuelva a ejecutar el comando gcc --version y confirme que las herramientas de compilación se han
instalado y que está listo para continuar.

Paso 3: Crear y ejecutar la aplicación de ejemplo

Para ejecutar las aplicaciones de ejemplo de AWS IoT Device SDK para Embedded C

1. Vaya aaws-iot-device-sdk-embedded-cy crea un directorio de compilación.

mkdir build && cd build

2. Introduzca el siguiente comando CMake para generar los Makefiles necesarios para crear.

cmake ..

3. Escriba el siguiente comando para compilar el archivo de aplicación ejecutable.

make

4. Ejecute la aplicación mqtt_demo_mutual_auth con este comando.

cd bin
./mqtt_demo_mutual_auth

Debería ver un resultado similar a este:

207
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

El dispositivo está conectado aAWS IoTutilizando elAWS IoT Device SDK para Embedded C.

También puede utilizar laAWS IoTpara ver los mensajes MQTT que está publicando la aplicación de
muestra. Para obtener información sobre cómo utilizar el cliente MQTT en la consola de AWS IoT, consulte
the section called “Ver los mensajes MQTT con el cliente MQTT de AWS IoT” (p. 69).

CreandoAWS IoTreglas para enrutar los datos del

dispositivo a otros servicios
Estos tutoriales le muestran cómo crear y probarAWS IoTreglas mediante algunas de las acciones de
reglas más comunes.

AWS IoTlas reglas envían datos de tus dispositivos a otrosAWSservicios. Escuchan mensajes MQTT
específicos, formatean los datos de las cargas de mensajes y envían el resultado a otrosAWSservicios.

Le recomendamos que las pruebe en el orden en que se muestran aquí, incluso si su objetivo es crear una
regla que utilice una función Lambda o algo más complejo. Los tutoriales se presentan en orden, de básico
a complejo. Presentan nuevos conceptos de forma gradual para ayudarlo a aprender los conceptos que
puede utilizar para crear las acciones de reglas que no tienen un tutorial específico.
Note

AWS IoTlas reglas lo ayudan a enviar los datos de sus dispositivos de IoT a otrosAWSservicios.
Sin embargo, para hacerlo correctamente, necesita un conocimiento práctico de los otros servicios
a los que desea enviar datos. Si bien estos tutoriales proporcionan la información necesaria para
completar las tareas, puede resultarle útil obtener más información sobre los servicios a los que
desea enviar datos antes de utilizarlos en la solución. Una explicación detallada de la otraAWSlos
servicios están fuera del alcance de estos tutoriales.

Descripción general del escenario del tutorial

El escenario de estos tutoriales es el de un dispositivo sensor meteorológico que publica periódicamente

sus datos. Hay muchos dispositivos sensores de este tipo en este sistema imaginario. Sin embargo, los

208
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

tutoriales de esta sección se centran en un solo dispositivo y, al mismo tiempo, muestran cómo puede
incluir varios sensores.

Los tutoriales de esta sección muestran cómo utilizarAWS IoTreglas para realizar las siguientes tareas con
este sistema imaginario de dispositivos sensores meteorológicos.

• Tutorial: Volver a publicar un mensaje MQTT (p. 210)

Este tutorial muestra cómo volver a publicar un mensaje MQTT recibido de los sensores meteorológicos
como un mensaje que contiene solo el ID del sensor y el valor de temperatura. Utiliza soloAWS IoT
Coreservicios y muestra una consulta SQL sencilla y cómo utilizar el cliente MQTT para probar la regla.
• Tutorial: Enviar una notificación de Amazon SNS (p. 216)

Este tutorial muestra cómo enviar un mensaje SNS cuando un valor de un dispositivo sensor
meteorológico supera un valor específico. Se basa en los conceptos presentados en el tutorial anterior y
añade cómo trabajar con otroAWSservicio, elServicio de notificación simple de Amazon(Amazon SNS).

Si es la primera vez que utiliza Amazon SNS, revise suPrimeros pasosejercicios antes de empezar este
tutorial.
• Tutorial: Almacenamiento de datos del dispositivo en una tabla de DynamoDB (p. 224)

Este tutorial muestra cómo almacenar los datos de los dispositivos de sensores meteorológicos en una
tabla de base de datos. Utiliza la sentencia de consulta de reglas y las plantillas de sustitución para
formatear los datos del mensaje del servicio de destino,Amazon DynamoDB.

Si es la primera vez que utiliza DynamoDB, revise suPrimeros pasosejercicios antes de empezar este
tutorial.
• Tutorial: Formatear una notificación mediante unAWS Lambdafunción (p. 229)

Este tutorial muestra cómo llamar a una función Lambda para reformatear los datos del dispositivo
y luego enviarlos como mensaje de texto. Añade un script de Python yAWSEl SDK funciona en
unAWS Lambdafunción para formatear con el mensaje los datos de carga de los dispositivos sensores
meteorológicos y enviar un mensaje de texto.

Si eres nuevo en Lambda, revisa suPrimeros pasosejercicios antes de empezar este tutorial.

AWS IoTdescripción general de las reglas

Todos estos tutoriales creanAWS IoTreglas.

Para unAWS IoTregla para enviar los datos de un dispositivo a otroAWSservicio, utiliza:

• Una instrucción de consulta de reglas que consiste en:

• Una cláusula SELECT de SQL que selecciona y formatea los datos de la carga útil del mensaje
• Un filtro de temas (el objeto FROM de la sentencia de consulta de reglas) que identifica los mensajes
que se van a utilizar
• Una sentencia condicional opcional (una cláusula WHERE de SQL) que especifica las condiciones
específicas en las que se debe actuar
• Al menos una acción de regla

Los dispositivos publican mensajes en temas de MQTT. El filtro de temas de la sentencia SQL SELECT
identifica los temas de MQTT a los que se debe aplicar la regla. Los campos especificados en la sentencia
SQL SELECT formatean los datos de la carga útil del mensaje MQTT entrante para que los utilicen las
acciones de la regla. Para obtener una lista completa de las acciones de las reglas, consulte Acciones de
las reglas de AWS IoT (p. 524).

209
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

Tutoriales de esta sección

• Tutorial: Volver a publicar un mensaje MQTT (p. 210)
• Tutorial: Enviar una notificación de Amazon SNS (p. 216)
• Tutorial: Almacenamiento de datos del dispositivo en una tabla de DynamoDB (p. 224)
• Tutorial: Formatear una notificación mediante unAWS Lambdafunción (p. 229)

Tutorial: Volver a publicar un mensaje MQTT

Este tutorial muestra cómo crear unAWS IoTregla que publica un mensaje MQTT cuando se recibe un
mensaje MQTT especificado. La regla puede modificar la carga útil de los mensajes entrantes antes de
que se publique. Esto permite crear mensajes que se adapten a aplicaciones específicas sin necesidad
de modificar el dispositivo o su firmware. También puede utilizar el aspecto de filtrado de una regla para
publicar mensajes solo cuando se cumpla una condición específica.

Los mensajes que se vuelven a publicar mediante una regla actúan como los mensajes enviados
por cualquier otra.AWS IoTdispositivo o cliente. Los dispositivos pueden suscribirse a los mensajes
republicados del mismo modo que a cualquier otro tema de mensajes de MQTT.

Lo que aprenderás en este tutorial:

• Cómo utilizar consultas y funciones SQL simples en una sentencia de consulta de reglas
• Cómo utilizar el cliente MQTT para probar unAWS IoTregla

Este tutorial tarda unos 30 minutos en completarse.

En este tutorial, podrás:

• Revise los temas de MQTT yAWS IoTreglas (p. 210)
• Paso 1: Crea unAWS IoTregla para volver a publicar un mensaje MQTT (p. 211)
• Paso 2: Pruebe la nueva regla (p. 213)
• Paso 3: Revise los resultados y los pasos siguientes (p. 216)

Antes de empezar este tutorial, asegúrate de que tienes lo siguiente:

• Configura tuCuenta de AWS (p. 19)

Necesitarás tuCuenta de AWSyAWS IoTconsola para completar este tutorial.

• RevisadoVer los mensajes MQTT con el cliente MQTT de AWS IoT (p. 69)

Asegúrese de poder utilizar el cliente MQTT para suscribirse y publicar en un tema. Utilizará el cliente
MQTT para probar la nueva regla en este procedimiento.

Revise los temas de MQTT yAWS IoTreglas

Antes de hablar deAWS IoTreglas, ayuda a entender el protocolo MQTT. En las soluciones de IoT, el
protocolo MQTT ofrece algunas ventajas sobre otros protocolos de comunicación de red, como HTTP, lo
que lo convierte en una opción popular para su uso en dispositivos de IoT. En esta sección se examinan
los aspectos clave de MQTT que se aplican a este tutorial. Para obtener información sobre cómo se
compara MQTT con HTTP, consulteElegir un protocolo para la comunicación del dispositivo (p. 88).

Protocolo MQTT

El protocolo MQTT utiliza un modelo de comunicación de publicación/suscripción con su anfitrión. Para

enviar datos, los dispositivos publican mensajes identificados por temas en elAWS IoTintermediario de

210
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

mensajes. Para recibir mensajes del agente de mensajes, los dispositivos se suscriben a los temas que
van a recibir enviando filtros de temas en las solicitudes de suscripción al agente de mensajes. ElAWS
IoTEl motor de reglas recibe mensajes MQTT del intermediario de mensajes.

Reglas de AWS IoT

AWS IoTlas reglas constan de una sentencia de consulta de reglas y una o más acciones de reglas.
Cuando elAWS IoTEl motor de reglas recibe un mensaje MQTT, estos elementos actúan sobre el mensaje
de la siguiente manera.

• Declaración de consulta de reglas

La sentencia de consulta de la regla describe los temas de MQTT que se deben utilizar, interpreta los
datos de la carga útil del mensaje y formatea los datos tal como se describe en una sentencia SQL
similar a las sentencias utilizadas en las bases de datos SQL populares. El resultado de la sentencia de
consulta son los datos que se envían a las acciones de la regla.
• Acción de la regla

Cada acción de regla de una regla actúa sobre los datos que resultan de la sentencia de consulta
de la regla.AWS IoTsoportamuchas acciones de reglas (p. 524). En este tutorial, sin embargo, te
concentrarás en elRepublish (p. 588)rule action, que publica el resultado de la sentencia de consulta
como un mensaje MQTT con un tema específico.

Paso 1: Crea unAWS IoTregla para volver a publicar un mensaje MQTT

ElAWS IoTregla que crearás en este tutorial se suscribe a ladevice/device_id/dataTemas de MQTT
dondeidentificador del dispositivoes el identificador del dispositivo que envió el mensaje. Estos
temas se describen en unfiltro de temas (p. 114)tandevice/+/data, donde el+es un carácter comodín
que coincide con cualquier cadena entre los dos caracteres de barra diagonal.

Cuando la regla recibe un mensaje de un tema coincidente, vuelve a publicar

eldevice_idytemperaturevalores como un nuevo mensaje de MQTT con eldevice/data/temptema.

Por ejemplo, la carga útil de un mensaje MQTT con eldevice/22/datael tema se ve así:

{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}

La regla toma eltemperaturevalor de la carga útil del mensaje y eldevice_iddel tema y los vuelve a
publicar como un mensaje MQTT con eldevice/data/temptema y una carga de mensajes similar a la
siguiente:

{
"device_id": "22",
"temperature": 28
}

Con esta regla, los dispositivos que solo necesitan el identificador del dispositivo y los datos de
temperatura se suscriben a ladevice/data/temptema para recibir solo esa información.

211
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

Para crear una regla que vuelva a publicar un mensaje MQTT

1. AbrirlaReglaseje delAWS IoTconsola.

2. EnReglas, eligeCreary empieza a crear tu nueva regla.
3. En la parte superior deCrear una regla:

a. EnNombre, introduzca el nombre de la regla. Para este tutorial, asígnele un

nombrerepublish_temp.

Recuerda que el nombre de una regla debe ser único en tu cuenta y región, y no puede tener
espacios. Hemos utilizado un carácter de subrayado en este nombre para separar las dos
palabras del nombre de la regla.
b. EnDescripción, describe la regla.

Una descripción significativa le ayuda a recordar qué hace esta regla y por qué la creó. La
descripción puede ser tan larga como sea necesario, por lo que debe ser lo más detallada
posible.
4. EnDeclaración de consulta de reglasdeCrear una regla:

a. EnUso de la versión SQL, seleccione2016-03-23.

b. En elDeclaración de consulta de reglascuadro de edición, introduzca la sentencia:

SELECT topic(2) as device_id, temperature FROM 'device/+/data'

Esta declaración:

• Escucha los mensajes MQTT con un tema que coincida condevice/+/datafiltro de temas.
• Selecciona el segundo elemento de la cadena del tema y lo asigna a ladevice_idcampo.
• Selecciona el valortemperaturecampo de la carga útil del mensaje y lo asigna a
latemperaturecampo.
5. EnDefinir una o más acciones:

a. Para abrir la lista de acciones de la regla para esta regla, elijaAñadir acción.
b. EnSelecciona una acción, eligeVolver a publicar un mensaje en unAWS IoTtema.
c. En la parte inferior de la lista de acciones, seleccionaConfigurar acciónpara abrir la página de
configuración de la acción seleccionada.
6. EnConfigurar acción:

a. EnTema, introducedevice/data/temp. Este es el tema MQTT del mensaje que publicará esta
regla.
b. EnCalidad de servicio, elige0 - El mensaje se entrega cero o más veces.
c. EnElija o cree un rol para otorgarloAWS IoTacceso para realizar esta acción:

i. Elija Create Role (Crear rol). ElCrear un nuevo rolSe abre un cuadro de diálogo.
ii. Introduzca un nombre que describa la nueva función. En este tutorial,
utilicerepublish_role.

Al crear un nuevo rol, se crean las políticas correctas para realizar la acción de la regla y se
adjuntan al nuevo rol. Si cambia el tema de esta acción de regla o usa esta función en otra
acción de regla, debe actualizar la política de esa función para autorizar el nuevo tema o
acción. Para actualizar un rol existente, elijaActualizar rolen esta sección.
iii. EscojaCrear rolpara crear el rol y cerrar el cuadro de diálogo.
d. EscojaAñadir acciónpara añadir la acción a la regla y volver aCrear una reglapágina.
212
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

7. ElVolver a publicar un mensaje en unAWS IoTtemala acción ahora aparece enDefinir una o más
acciones.

En el recuadro de la nueva acción, a continuaciónVolver a publicar un mensaje en unAWS IoTtema,

puede ver el tema en el que se publicará la acción de volver a publicar.

Esta es la única acción de regla que añadirás a esta regla.

8. EnCrear una regla, desplácese hasta la parte inferior y elijaCrear reglapara crear la regla y completar
este paso.

Paso 2: Pruebe la nueva regla

Para probar tu nueva regla, utilizarás el cliente MQTT para publicar y suscribirte a los mensajes MQTT que
usa esta regla.

Abra elCliente MQTT en elAWS IoTconsolaen una ventana nueva. Esto le permitirá editar la regla sin
perder la configuración de su cliente MQTT. El cliente MQTT no conserva ninguna suscripción o registro de
mensajes si lo deja para ir a otra página de la consola.

Para usar el cliente MQTT para probar la regla

1. En elCliente MQTT en elAWS IoTconsola, suscríbete a los temas de entrada, en este caso,device/
+/data.

a. En el cliente MQTT, enSuscripciones, eligeSuscríbete a un tema.

b. EnTema de suscripción, introduzca el tema del filtro de temas de entrada,device/+/data.
c. Mantenga el resto de los campos en su configuración predeterminada.
d. Elija Subscribe to topic (Suscribirse al tema).

En elSuscripcionescolumna, debajoPublicar en un tema,device/+/dataaparece.

2. Suscríbete al tema en el que se publicará tu regla:device/data/temp.

a. BajoSuscripciones, eligeSuscríbete a un temaotra vez, y enTema de suscripción, introduzca el

tema del mensaje republicado,device/data/temp.
b. Mantenga el resto de los campos en su configuración predeterminada.
c. Elija Subscribe to topic (Suscribirse al tema).

En elSuscripcionescolumna, debajodispositivo/+/datos,device/data/tempaparece.
3. Publica un mensaje en el tema de entrada con un identificador de dispositivo específico,device/22/
data. No puede publicar en MQTT temas que contengan caracteres comodín.

a. En el cliente MQTT, enSuscripciones, eligePublicar en el tema.

b. En elPublicacampo, introduzca el nombre del tema de entrada,device/22/data.
c. Copie los datos de ejemplo que se muestran aquí y, en el cuadro de edición situado debajo del
nombre del tema, pegue los datos de muestra.

{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}

213
 AWS IoT Core Guía para desarrolladores
CreandoAWS IoTreglas para enrutar los
datos del dispositivo a otros servicios

d. Para enviar su mensaje MQTT, elijaPublicar en el tema.

4. Revisa los mensajes que se enviaron.

a. En el cliente MQTT, enSuscripciones, hay un punto verde junto a los dos temas a los que te