Manual AWS IoT

AWS IoT
Guía del desarrollador

AWS IoT Guía del desarrollador
AWS IoT: Guía del desarrollador

Copyright © 2020 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.
Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's,
in any manner that is likely to cause confusion among customers, or in any manner that disparages or discredits
Amazon. All other trademarks not owned by Amazon are the property of their respective owners, who may or may not
be affiliated with, connected to, or sponsored by Amazon.
Table of Contents
¿Qué es AWS IoT? ............................................................................................................................ 1
Componentes de AWS IoT .......................................................................................................... 1
Primeros pasos con AWS IoT ...................................................................................................... 3
Acceso a AWS IoT ..................................................................................................................... 3
Servicios relacionados ................................................................................................................. 3
Funcionamiento de AWS IoT ........................................................................................................ 3
Introducción a AWS IoT Core ............................................................................................................... 5
Inicie sesión en la consola de AWS IoT. ........................................................................................ 5
Creación de un objeto ................................................................................................................. 6
Registro de un dispositivo ............................................................................................................ 6
Creación y activación de un certificado de dispositivo .............................................................. 6
Creación de una política de AWS IoT Core ............................................................................ 8
Asociación de una política de AWS IoT Core a un certificado de dispositivo ............................... 10
Asociación de un certificado a un objeto .............................................................................. 11
Configuración del dispositivo ...................................................................................................... 12
Visualización de los mensajes de MQTT de dispositivo con el cliente MQTT de AWS IoT ..................... 12
Configuración y comprobación de reglas ...................................................................................... 14
Creación de un tema de SNS ............................................................................................. 15
Suscripción a un tema de Amazon SNS ............................................................................... 17
Creación de una regla ....................................................................................................... 18
Comprobación de la regla de Amazon SNS .......................................................................... 25
Pasos siguientes ............................................................................................................... 25
Creación y seguimiento de un trabajo de AWS IoT Core ................................................................. 25
Conexión del dispositivo a AWS IoT .................................................................................... 25
Ejecución del trabajo de ejemplo ......................................................................................... 26
Creación de un documento de trabajo ................................................................................. 26
Creación de un trabajo ...................................................................................................... 26
Ejecución del trabajo en un dispositivo ................................................................................. 34
Seguimiento del progreso de un trabajo con eventos de trabajo y de ejecución de trabajos ............ 35
Tutoriales de reglas de AWS IoT ........................................................................................................ 39
Creación de una regla con una acción de DynamoDB .................................................................... 39
Prueba de una regla con una acción de DynamoDB .............................................................. 49
Creación de una regla con una acción de AWS Lambda ................................................................. 50
Crear una función de Lambda ............................................................................................ 51
Comprobación de la función de Lambda .............................................................................. 55
Creación de una regla con una acción de Lambda ................................................................. 57
Prueba de una regla con una acción de Lambda ................................................................... 67
Solución de problemas de una regla con una acción de Lambda .............................................. 68
Creación de una regla de Amazon SNS ....................................................................................... 69
Uso de los SDK de dispositivos de AWS IoT en Raspberry Pi ................................................................. 78
Requisitos previos ..................................................................................................................... 78
Creación de un objeto de AWS IoT para su Raspberry Pi ............................................................... 78
Uso del AWS IoT Device SDK para Embedded C .......................................................................... 79
Instalación del AWS IoT Device SDK para Embedded C. ........................................................ 79
Configuración de aplicación de muestra ............................................................................... 80
Ejecución de las aplicaciones de ejemplo ............................................................................. 81
Uso del SDK de dispositivos de AWS IoT para JavaScript y Node .................................................... 82
Instale la versión más reciente de Node.js. ........................................................................... 82
Instalación de AWS IoT Device SDK para JavaScript ............................................................. 82
Preparación antes de ejecutar las aplicaciones de ejemplo ...................................................... 82
Ejecución de las aplicaciones de ejemplo ............................................................................. 83
Otros tutoriales de AWS IoT ............................................................................................................... 85
Monitorización de la humedad del suelo con AWS IoT y Raspberry Pi ............................................... 85
Requisitos previos ............................................................................................................. 85
iii
Configuración de AWS IoT ................................................................................................. 85

Configuración del dispositivo Raspberry Pi y el sensor de humedad .......................................... 89
Administración de dispositivos con AWS IoT ......................................................................................... 95
Cómo administrar objetos con el registro ...................................................................................... 95
Crear objeto ..................................................................................................................... 95
Lista de objetos ................................................................................................................ 96
Buscar objetos ................................................................................................................. 96
Actualización de un objeto ................................................................................................. 98
Eliminación de un objeto .................................................................................................... 98
Asociar un principal a un objeto .......................................................................................... 98
Desvincular un principal de un objeto .................................................................................. 98
Tipos de objeto ........................................................................................................................ 99
Creación de un tipo de objeto ............................................................................................. 99
Lista de los tipos de objeto ................................................................................................ 99
Descripción de un tipo de objeto ....................................................................................... 100
Asociación de un tipo de objeto a un objeto ........................................................................ 100
Descartar un tipo de objeto .............................................................................................. 101
Eliminación de un tipo de objeto ........................................................................................ 102
Grupos de objetos estáticos ..................................................................................................... 102
Crear un grupo de objetos estático .................................................................................... 103
Descripción de un grupo de objetos ................................................................................... 104
Agregar un objeto a un grupo de objetos estático ................................................................ 104
Eliminar un objeto de un grupo de objetos estático ............................................................... 104
Enumerar los objetos en un grupo de objetos ...................................................................... 105
Enumeración de grupos de objetos .................................................................................... 105
Enumerar grupos para un objeto ....................................................................................... 107
Actualizar un grupo de objetos estático .............................................................................. 107
Eliminación de un grupo de objetos ................................................................................... 107
Asociar una política a un grupo de objetos estático .............................................................. 108
Desconectar una política de un grupo de objetos estático ...................................................... 108
Mostrar las políticas asociadas a un grupo de objetos estático ............................................... 109
Enumeración de los grupos para una política ...................................................................... 109
Obtención de políticas en vigor para un objeto .................................................................... 109
Prueba de autorización para acciones de MQTT .................................................................. 110
Grupos de objetos dinámicos .................................................................................................... 111
Crear un grupo de objetos dinámico .................................................................................. 112
Describir un grupo de objetos dinámico .............................................................................. 113
Actualizar un grupo de objetos dinámico ............................................................................. 113
Eliminar un grupo de objetos dinámico ............................................................................... 114
Limitaciones y conflictos ................................................................................................... 114
Etiquetado de los recursos de AWS IoT ............................................................................................. 117
Conceptos básicos de etiquetas ................................................................................................ 117
Restricciones y limitaciones en las etiquetas ....................................................................... 118
Uso de etiquetas con políticas de IAM ....................................................................................... 118
Grupos de facturación .............................................................................................................. 120
Visualización de datos de uso y asignación de costos .......................................................... 120
Seguridad ...................................................................................................................................... 122
Seguridad en AWS IoT ............................................................................................................ 122
Autenticación .......................................................................................................................... 123
AWS Training and Certification .......................................................................................... 123
Información general del certificado X.509 ............................................................................ 123
Autenticación del servidor ................................................................................................. 124
Autenticación del cliente ................................................................................................... 126
Autenticación personalizada .............................................................................................. 142
Administración de certificados de dispositivo ............................................................................... 150
Autenticación del servidor ................................................................................................. 150
Autorización ............................................................................................................................ 151
iv
AWS Training and Certification .......................................................................................... 152

Políticas de AWS IoT Core ............................................................................................... 152
Autorización de llamadas directas a los servicios de AWS ..................................................... 181
Acceso entre cuentas ...................................................................................................... 185
Protección de los datos ............................................................................................................ 186
Seguridad de transporte en AWS IoT ................................................................................. 187
Cifrado de datos ............................................................................................................. 188
Administración de identidades y accesos .................................................................................... 189
Público .......................................................................................................................... 189
Autenticación con identidades de IAM ................................................................................ 189
Administración de acceso mediante políticas ....................................................................... 191
Funcionamiento de AWS IoT con IAM ................................................................................ 193
Ejemplos de políticas basadas en identidades ..................................................................... 208
Solución de problemas ..................................................................................................... 211
Registro y monitorización ......................................................................................................... 213
Herramientas de monitorización ......................................................................................... 213
Validación de la conformidad .................................................................................................... 214
Resiliencia .............................................................................................................................. 215
Seguridad de la infraestructura .................................................................................................. 215
Análisis de vulnerabilidades ...................................................................................................... 215
Prácticas recomendadas de seguridad ....................................................................................... 216
Protección de conexiones MQTT en AWS IoT ..................................................................... 216
Mantener sincronizado el reloj del dispositivo ...................................................................... 218
Validar el certificado de servidor ........................................................................................ 218
Usar una identidad única por dispositivo ............................................................................. 219
Usar aprovisionamiento justo a tiempo ............................................................................... 219
AWS Training and Certification .................................................................................................. 219
Monitorización de AWS IoT .............................................................................................................. 220
Configuración de registros de AWS IoT ...................................................................................... 221
Configuración del rol y la política de registro ....................................................................... 221
Configure el registro predeterminado en AWS IoT (consola) ................................................... 222
Configurar el registro predeterminado en AWS IoT (CLI) ....................................................... 223
Configurar el inicio de sesión específico de recursos en AWS IoT (CLI) ................................... 225
Niveles de registro .......................................................................................................... 226
Monitoreo de alarmas y métricas de AWS IoT mediante Amazon CloudWatch .................................. 227
Uso de las métricas de AWS IoT ...................................................................................... 227
Creación de alarmas de CloudWatch en AWS IoT ................................................................ 228
Métricas y dimensiones de AWS IoT .................................................................................. 230
Monitoreo de AWS IoT mediante CloudWatch Logs ...................................................................... 239
Visualización de registros de AWS IoT en la consola de CloudWatch ...................................... 239
Entradas de registro de CloudWatch en AWS IoT ................................................................ 240
Registre las llamadas a la API de AWS IoT con AWS CloudTrail. ................................................... 257
Información de AWS IoT en CloudTrail ............................................................................... 257
Descripción de las entradas de archivos de registro de AWS IoT ............................................ 258
Conexión de dispositivos .................................................................................................................. 260
Puntos de enlace configurables (beta) ........................................................................................ 261
Creación y configuración de dominios administrados por AWS ............................................... 261
Creación y configuración de dominios personalizados ........................................................... 262
Administración de configuraciones de dominio ..................................................................... 265
Agente de mensajes ........................................................................................................................ 266
Temas ................................................................................................................................... 266
Nombres de temas .......................................................................................................... 266
Filtros de temas .............................................................................................................. 267
Temas reservados ........................................................................................................... 267
Protocolos .............................................................................................................................. 276
Protocolos, mapeos de puertos y autenticación .................................................................... 277
MQTT ............................................................................................................................ 277
v
HTTP ............................................................................................................................ 282

Reglas ........................................................................................................................................... 285
Concesión a AWS IoT del acceso requerido ............................................................................... 285
Transmisión de los permisos de rol ........................................................................................... 287
Creación de una regla de AWS IoT ........................................................................................... 288
Visualización de las reglas ....................................................................................................... 291
Eliminar una regla ................................................................................................................... 292
Acciones de reglas de AWS IoT ................................................................................................ 292
Acción de alarma de CloudWatch ...................................................................................... 293
Acción de CloudWatch Logs ............................................................................................. 294
Acción de métrica de CloudWatch ..................................................................................... 294
Acción de DynamoDB ...................................................................................................... 295
Acción DynamoDBv2 ....................................................................................................... 297
Acción de Elasticsearch ................................................................................................... 298
Acción Firehose .............................................................................................................. 299
Acción HTTP .................................................................................................................. 300
Acción de IoT Analytics .................................................................................................... 301
Acción de eventos de IoT ................................................................................................. 303
Acción SiteWise de IoT .................................................................................................... 304
Acción Kinesis ................................................................................................................ 307
Acción Lambda ............................................................................................................... 308
Acción Republish ............................................................................................................ 310
Acción S3 ...................................................................................................................... 310
Acción Salesforce ............................................................................................................ 312
Acción SNS .................................................................................................................... 312
Acción SQS ................................................................................................................... 313
Acción de Step Functions ................................................................................................. 314
Solución de problemas de las reglas .......................................................................................... 315
Control de errores (acción de error) ........................................................................................... 315
Formato de mensaje de acción de error ............................................................................. 315
Ejemplo de acción de error ............................................................................................... 316
Trabajar con destinos de reglas de temas ................................................................................. 317
Creación de un destino de regla del tema ........................................................................... 318
Confirmación de un destino de regla del tema ..................................................................... 318
Deshabilitación de un destino de regla del tema .................................................................. 319
Habilitación de un destino de regla del tema ....................................................................... 319
Envío de un nuevo mensaje de confirmación ....................................................................... 319
Eliminación de un destino de regla del tema ....................................................................... 319
Reducción de los costos de mensajería con Basic Ingest .............................................................. 319
Uso de Basic Ingest ........................................................................................................ 319
Referencia de la SQL de AWS IoT ............................................................................................ 320
Cláusula SELECT ........................................................................................................... 321
Cláusula FROM .............................................................................................................. 323
Cláusula WHERE ............................................................................................................ 324
Tipos de datos ................................................................................................................ 325
Operadores .................................................................................................................... 328
Funciones ...................................................................................................................... 334
Literales ......................................................................................................................... 372
Instrucciones case ........................................................................................................... 372
Extensiones JSON .......................................................................................................... 373
Plantillas de sustitución .................................................................................................... 373
Consultas de objetos anidados .......................................................................................... 374
Versiones de SQL ........................................................................................................... 375
Servicio de sombra del dispositivo ..................................................................................................... 378
Flujo de datos del servicio de sombra del dispositivo .................................................................... 378
Detección de un objeto conectado ..................................................................................... 385
Documentos del servicio de sombra del dispositivo ...................................................................... 386
vi
Propiedades del documento .............................................................................................. 386

Control de versiones de sombra del dispositivo .................................................................... 387
Token de cliente ............................................................................................................. 387
Ejemplo de documento .................................................................................................... 387
Secciones vacías ............................................................................................................ 388
Matrices ......................................................................................................................... 388
Uso de sombras ..................................................................................................................... 389
Compatibilidad del protocolo ............................................................................................. 389
Actualización de la sombra ............................................................................................... 390
Recuperación de un documento de sombra ........................................................................ 390
Eliminación de datos ....................................................................................................... 393
Eliminación de una sombra .............................................................................................. 394
Estado delta ................................................................................................................... 394
Observación de los cambios de estado .............................................................................. 396
Orden de los mensajes .................................................................................................... 396
Recorte de mensajes de sombra ....................................................................................... 397
API RESTful ........................................................................................................................... 398
GetThingShadow ............................................................................................................. 398
UpdateThingShadow ........................................................................................................ 399
DeleteThingShadow ......................................................................................................... 400
Temas de publicación/suscripción MQTT .................................................................................... 400
/update .......................................................................................................................... 401
/update/accepted ............................................................................................................. 402
/update/documents .......................................................................................................... 402
/update/rejected .............................................................................................................. 403
/update/delta ................................................................................................................... 403
/get ............................................................................................................................... 404
/get/accepted .................................................................................................................. 405
/get/rejected .................................................................................................................... 405
/delete ........................................................................................................................... 406
/delete/accepted .............................................................................................................. 406
/delete/rejected ............................................................................................................... 407
Sintaxis de los documentos ...................................................................................................... 407
Documentos de estado de la solicitud ................................................................................ 408
Documentos de estado de la respuesta .............................................................................. 408
Documentos de respuesta de error .................................................................................... 411
Mensajes de error ................................................................................................................... 411
Trabajos ........................................................................................................................................ 413
Conceptos clave de trabajos ..................................................................................................... 413
Administrar trabajos ................................................................................................................. 415
Creación y administración de trabajos (consola) ................................................................... 417
Creación y administración de trabajos (CLI) ........................................................................ 418
Dispositivos y trabajos ............................................................................................................. 426
Programación de dispositivos para trabajar con trabajos ........................................................ 428
Uso de las API de trabajos de AWS IoT ..................................................................................... 438
API de administración y control de trabajo .......................................................................... 438
API de MQTT y HTTPS de dispositivo de trabajo ................................................................. 496
Despliegue de trabajos y configuración de anulaciones ................................................................. 522
Uso de tasas de despliegue de trabajos ............................................................................. 522
Uso de configuraciones de anulaciones de despliegues de trabajos ........................................ 523
Límites de los trabajos ............................................................................................................. 524
Tunelización segura de AWS IoT ...................................................................................................... 525
Conceptos de tunelización segura ............................................................................................. 525
Tutorial de tunelización segura .................................................................................................. 526
Requisitos previos ........................................................................................................... 526
Abrir un túnel ................................................................................................................. 526
Iniciar el proxy local ........................................................................................................ 526
vii
Iniciar una sesión SSH .................................................................................................... 527

Cerrar el túnel ................................................................................................................ 527
Ciclo de vida del túnel seguro ................................................................................................... 527
Control del acceso a los túneles ............................................................................................... 528
Requisitos previos de acceso al túnel ................................................................................ 528
iot:OpenTunnel ............................................................................................................... 528
iot:DescribeTunnel ........................................................................................................... 529
iot:ListTunnels ................................................................................................................. 530
iot:ListTagsForResource ................................................................................................... 530
iot:CloseTunnel ............................................................................................................... 530
iot:TagResource .............................................................................................................. 531
iot:UntagResource ........................................................................................................... 531
Proxy local ............................................................................................................................. 531
Prácticas de seguridad recomendadas del proxy local ........................................................... 532
Fragmento de agente de IoT .................................................................................................... 532
Configuración de un dispositivo remoto ...................................................................................... 533
Aprovisionamiento de dispositivos ...................................................................................................... 535
Aprovisionamiento de dispositivos que no tienen certificados de dispositivo mediante el
aprovisionamiento de flotas ...................................................................................................... 535
Aprovisionar un dispositivo mediante reclamación ................................................................ 536
Aprovisionamiento por usuario de confianza ........................................................................ 537
Enlaces de preaprovisionamiento ...................................................................................... 539
Aprovisionamiento de dispositivos que tienen certificados de dispositivo .......................................... 542
Aprovisionamiento de un solo objeto .................................................................................. 542
Aprovisionamiento justo a tiempo ...................................................................................... 543
Registro masivo .............................................................................................................. 546
Aprovisionamiento de plantillas .................................................................................................. 546
Sección de parámetros .................................................................................................... 546
Sección de recursos ........................................................................................................ 547
Ejemplo de plantilla para el registro JITP y masivo ............................................................... 550
Aprovisionamiento de flotas .............................................................................................. 552
API de aprovisionamiento de flotas ............................................................................................ 554
API de MQTT de aprovisionamiento de dispositivos .............................................................. 555
Servicio de indexación de flota .......................................................................................................... 559
Administración de la indexación de objetos ................................................................................. 559
Habilitación de la indexación de objetos ............................................................................. 559
Descripción de un índice de objeto .................................................................................... 565
Consulta de un índice de objeto ........................................................................................ 566
Restricciones y limitaciones .............................................................................................. 567
Autorización .................................................................................................................... 569
Administración de la indexación de grupos de objetos .................................................................. 569
Habilitación de la indexación de grupos de objetos ............................................................... 569
Descripción de índices de grupos ...................................................................................... 570
Consulta de un índice de grupo de objetos ......................................................................... 570
Autorización .................................................................................................................... 570
Consulta de datos agregados ................................................................................................... 571
GetStatistics ................................................................................................................... 571
GetCardinality ................................................................................................................. 573
GetPercentiles ................................................................................................................ 574
Autorización .................................................................................................................... 575
Sintaxis de la consulta ............................................................................................................. 575
Ejemplo de consultas de objetos ............................................................................................... 576
Ejemplo de consultas de grupo de objetos .................................................................................. 578
AWS IoT Device Defender ............................................................................................................... 580
AWS Training and Certification .................................................................................................. 580
Auditar ................................................................................................................................... 580
Gravedad del problema .................................................................................................... 580
viii
Pasos siguientes ............................................................................................................. 581

Comprobaciones de auditoría ............................................................................................ 581
Cómo realizar auditorías .................................................................................................. 607
Comandos de auditoría ............................................................................................................ 614
Administrar la configuración de auditorías ........................................................................... 614
Programación de auditorías .............................................................................................. 619
Ejecutar una auditoría bajo demanda ................................................................................. 627
Administrar instancias de auditoría ..................................................................................... 629
Comprobar resultados de auditoría .................................................................................... 635
Acciones de mitigación ............................................................................................................ 641
Cómo definir y administrar las acciones de mitigación ........................................................... 644
Aplicación de acciones de mitigación ................................................................................. 647
Permisos ........................................................................................................................ 652
Comandos de las acciones de mitigación ................................................................................... 655
CreateMitigationAction ...................................................................................................... 656
UpdateMitigationAction ..................................................................................................... 660
ListMitigationActions ........................................................................................................ 663
DescribeMitigationAction ................................................................................................... 665
DeleteMitigationAction ...................................................................................................... 670
StartAuditMitigationActionsTask ......................................................................................... 670
CancelAuditMitigationActionsTask ...................................................................................... 673
ListAuditMitigationActionsExecutions .................................................................................. 674
ListAuditMitigationActionsTasks ......................................................................................... 677
DescribeAuditMitigationActionsTask ................................................................................... 680
Detect .................................................................................................................................... 685
Conceptos ...................................................................................................................... 686
Comportamientos ............................................................................................................ 687
Métricas ......................................................................................................................... 688
Establecer el ámbito de las métricas en los perfiles de seguridad utilizando dimensiones ............. 699
Cómo utilizar las dimensiones en la CLI de AWS ................................................................. 700
Cómo utilizar las dimensiones en la consola ....................................................................... 703
Monitorización del comportamiento de dispositivos no registrados ........................................... 707
Cómo utilizar AWS IoT Device Defender Detect ................................................................... 708
Permisos ........................................................................................................................ 710
Envío de métricas desde dispositivos ................................................................................. 711
Comandos de detección ........................................................................................................... 716
AttachSecurityProfile ........................................................................................................ 717
CreateDimension ............................................................................................................. 718
CreateSecurityProfile ....................................................................................................... 720
DeleteDimension ............................................................................................................. 721
DeleteSecurityProfile ........................................................................................................ 722
DescribeDimension .......................................................................................................... 722
DescribeSecurityProfile ..................................................................................................... 724
DetachSecurityProfile ....................................................................................................... 725
ListActiveViolations .......................................................................................................... 725
ListDimensions ................................................................................................................ 726
ListSecurityProfiles .......................................................................................................... 727
ListSecurityProfilesForTarget ............................................................................................. 728
ListTargetsForSecurityProfile ............................................................................................. 729
ListViolationEvents .......................................................................................................... 729
UpdateDimension ............................................................................................................ 730
UpdateSecurityProfile ....................................................................................................... 732
ValidateSecurityProfileBehaviors ........................................................................................ 733
Integración del agente de dispositivo con AWS IoT Greengrass ..................................................... 734
Prácticas recomendadas de seguridad para agentes de dispositivos .............................................. 736
Mensajes de los eventos .................................................................................................................. 739
Eventos de registro ................................................................................................................. 740
ix
Eventos de trabajos ................................................................................................................. 746

Eventos del ciclo de vida ......................................................................................................... 749
Eventos de conexión/desconexión ..................................................................................... 750
Eventos de suscripción/cancelación de suscripción ............................................................... 752
Integración Alexa Voice Service (AVS) para AWS IoT ........................................................................... 754
Introducción a Integración Alexa Voice Service (AVS) para AWS IoT en un dispositivo NXP ................ 755
Vista previa de Integración Alexa Voice Service (AVS) para AWS IoT con una cuenta de NXP
preconfigurada ................................................................................................................ 756
Utilice sus cuentas de desarrollador de AWS y Alexa Voice Service para configurar AVS para
AWS IoT ........................................................................................................................ 759
SDK de AWS IoT para dispositivos y móviles ...................................................................................... 762
SDK de AWS Mobile para Android ............................................................................................ 762
Arduino Yún SDK .................................................................................................................... 762
AWS IoT Device SDK para Embedded C .................................................................................... 763
AWS IoT C++ device SDK ....................................................................................................... 763
AWS Mobile SDK para iOS ...................................................................................................... 763
AWS IoT device SDK for Java .................................................................................................. 763
AWS IoT device SDK for JavaScript .......................................................................................... 764
AWS IoT device SDK for Python ............................................................................................... 764
Solución de problemas ..................................................................................................................... 765
Diagnóstico de problemas de conectividad .................................................................................. 765
Autenticación .................................................................................................................. 765
Autorización .................................................................................................................... 765
Diagnóstico de problemas de las reglas ..................................................................................... 765
Diagnóstico de problemas relacionados con las sombras .............................................................. 766
Diagnosticar problemas con acciones de Salesforce ..................................................................... 768
Registro de seguimiento de ejecución ................................................................................ 768
Éxito y error de una acción .............................................................................................. 768
Solución de problemas de consultas de agregación en el servicio de indexación de flotas ................... 769
Guía para solucionar problemas de AWS IoT Device Defender ...................................................... 770
Errores de AWS IoT ................................................................................................................ 772
Cuotas de AWS IoT ........................................................................................................................ 774
x
Componentes de AWS IoT
¿Qué es AWS IoT?

AWS IoT proporciona una comunicación bidireccional segura entre los dispositivos conectados a Internet
(como sensores, actuadores, microcontroladores integrados o aparatos inteligentes) y la nube de AWS.
Esto le permite recopilar datos de telemetría de varios dispositivos, y almacenar y analizar los datos.
También puede crear aplicaciones que permitan a sus usuarios controlar estos dispositivos desde sus
teléfonos o tablets.

AWS IoT está formado por los siguientes componentes:
Integración Alexa Voice Service (AVS) para AWS IoT
Integre Alexa Voice en cualquier dispositivo conectado. AVS para AWS IoT reduce el costo y la
complejidad de la integración de Alexa. Esta función utiliza AWS IoT para transferir las tareas de audio
que hacen un uso intensivo de procesos informáticos y de la memoria del dispositivo a la nube. Debido
a la reducción resultante en el costo de la factura de materiales de ingeniería (eBoM), los fabricantes
de dispositivos ahora pueden incorporar Alexa en dispositivos IoT con recursos limitados de manera
más económica y permitir a los consumidores hablar directamente con Alexa en su hogar, oficina o
habitación del hotel y disfrutar así de una experiencia de sonido ambiente.
AVS para AWS IoT permite la funcionalidad integrada de Alexa en MCU, como la clase ARM Cortex M
con menos de 1 MB de RAM integrada. Para ello, AVS transfiere las tareas de memoria y computación
a un dispositivo virtual de Alexa integrado en la nube. Esto reduce el costo de eBoM hasta en un
50 %. Para obtener más información, consulte Integración Alexa Voice Service (AVS) para AWS
IoT (p. 754).
Servicio de autenticación personalizado
Puede definir autorizadores personalizados para permitirle administrar su propia estrategia de

autenticación y autorización con un servicio de autenticación personalizado y una función de 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: verificación de JSON Web Token, llamada al proveedor de OAuth, etc.) y deben
devolver los documentos de la política que ha usado la puerta de enlace del dispositivo para
autorizar las operaciones de MQTT. Para obtener más información, consulte Autenticación
personalizada (p. 142).
Gateway de dispositivos
Permite a los dispositivos comunicarse de forma segura y eficaz con AWS IoT.
Servicio de aprovisionamiento de dispositivos
Le permite aprovisionar dispositivos mediante una plantilla que describe los recursos necesarios para
el dispositivo: un objeto, un certificado y una o varias políticas. Un objeto es una entrada en el 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. 535).
1
Sombra del dispositivo
Documento JSON utilizado para almacenar y recuperar información del estado actual de un
dispositivo.
Servicio Device Shadow
Proporciona representaciones persistentes de los dispositivos en la nube de AWS. Es posible publicar

información de estado actualizada en una sombra de un dispositivo y este puede sincronizar su
estado cuando se conecte. Los dispositivos también pueden publicar su estado actual en una sombra
para que lo usen las aplicaciones o los demás dispositivos. Para obtener más información, consulte
Servicio de sombra del dispositivo para AWS IoT (p. 378).
Registro de grupos
Los grupos permiten administrar varios dispositivos a la vez clasificándolos en grupos. Los grupos
también pueden contener otros grupos — puede crear una jerarquía de grupos. Cualquier acción que
realice en un grupo principal se aplicará a sus grupos secundarios, así como a todos los dispositivos
incluidos en el grupo principal y en sus grupos secundarios. Los permisos proporcionados 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. 95).
Servicio de Jobs
Permite definir un conjunto de operaciones remotas que se envían a uno o más dispositivos
conectados a AWS IoT o que se ejecutan en uno o más de esos dispositivos. Por ejemplo, puede
definir un trabajo que indique a un conjunto de 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. 413).
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 sobre WebSocket
para publicar y suscribirse. Puede utilizar la interfaz HTTP REST para publicar. Para obtener más
información, consulte Agente de mensajes de AWS IoT (p. 266).
Registry (Registro)
Organiza los recursos asociados a cada dispositivo en la nube de AWS. 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. 95).
Motor de reglas
Proporciona funciones de procesamiento de mensajes y de integración con otros servicios de AWS.

Puede utilizar un lenguaje basado en SQL para seleccionar datos de cargas de mensajes y procesar
y enviar datos a otros servicios, como Amazon S3, Amazon DynamoDB y AWS Lambda. También
puede utilizar el agente de mensajes para volver a publicar mensajes para otros suscriptores. Para
obtener más información, consulte Reglas para AWS IoT (p. 285).
Servicio de seguridad e identidad
Comparte la responsabilidad de la seguridad en la nube de AWS. Los dispositivos deben proteger

sus credenciales para enviar datos de forma segura al agente de mensajes. El agente de mensajes
y el motor de reglas utilizan las características de seguridad de AWS para enviar datos de
forma segura a dispositivos u otros servicios de AWS. Para obtener más información, consulte
Autenticación (p. 123).
2
Primeros pasos con AWS IoT
Para obtener información sobre los límites de AWS IoT, consulte Límites de AWS IoT.
Primeros pasos con AWS IoT

• Para obtener más información acerca de la AWS IoT, consulte Funcionamiento de AWS IoT (p. 3).
• Para obtener información sobre cómo conectar un dispositivo a AWS IoT, consulte Introducción a AWS
IoT Core (p. 5).
Acceso a AWS IoT

AWS IoT ofrece las interfaces siguientes para crear dispositivos e interactuar con ellos:
• AWS Command Line Interface(AWS CLI)— Ejecuta comandos para AWS IoT en Windows, macOS
y Linux. Estos comandos le permiten crear y administrar objetos, certificados, reglas y políticas. Para
empezar, consulte AWS Command Line Interface Guía del usuario. Para obtener más información
acerca de los comandos de AWS IoT, consulte iot en la AWS CLI Command Reference.
• AWS IoTAPI— 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 mediante programación. 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.
• SDK de AWS— Cree sus aplicaciones IoT mediante API específicas de un lenguaje. 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 AWSSDK y herramientas de .
• SDK de dispositivos de AWS IoT— Cree aplicaciones que se ejecutan en sus dispositivos para enviar y
recibir mensajes de AWS IoT. Para obtener más información, consulte SDK de AWS IoT.
Servicios relacionados
AWS IoT se integra directamente con los siguientes servicios de AWS:
• Amazon Simple Storage Service—Proporciona almacenamiento escalable en la nube de AWS. Para

obtener más información, consulte Amazon S3.
• Amazon DynamoDB—Proporciona bases de datos NoSQL administradas. Para obtener más
información, consulte Amazon DynamoDB.
• Amazon Kinesis—Permite realizar el procesamiento de datos de streaming a gran escala. Para obtener
más información, consulte Amazon Kinesis.
• AWS Lambda—Ejecuta el código en servidores virtuales de Amazon EC2 en respuesta a eventos. Para
obtener más información, consulte AWS Lambda.
• Amazon Simple Notification Service—Envía o recibe notificaciones. Para obtener más información,
consulte Amazon SNS.
• Amazon Simple Queue Service—Almacena de datos en una cola para que los recuperen las
aplicaciones. Para obtener más información, consulte Amazon SQS.
Funcionamiento de AWS IoT

AWS IoT permite que los dispositivos con conexión a Internet puedan conectarse a la nube de AWS
y que las aplicaciones en la nube puedan interactuar con los dispositivos conectados a Internet. Las
3
Funcionamiento de AWS IoT
aplicaciones de IoT habituales recopilan y procesan telemetría de dispositivos, o bien permiten que los
usuarios controlen un dispositivo de forma remota.
El estado de cada dispositivo conectado a AWS IoT se almacena en una sombra de dispositivo. El
servicio Device Shadow administra las sombras de los dispositivos mediante la respuesta a las solicitudes
para recuperar o actualizar los datos de estado del dispositivo. El servicio Device Shadow permite que
los dispositivos se comuniquen con las aplicaciones y que las aplicaciones se comuniquen con los
dispositivos.
La comunicación entre su dispositivo y AWS IoT se protege mediante certificados X.509. AWS IoT puede
generar un certificado, o bien usted puede utilizar su propio certificado. En ambos casos, el certificado
debe registrarse y activarse en AWS IoT y, a continuación, copiarse en el dispositivo. Cuando el dispositivo
se comunica con AWS IoT, presenta el certificado a AWS IoT como credencial.
Recomendamos que todos los dispositivos que se conecten con AWS IoT tengan una entrada en el
registro. El registro almacena información sobre un dispositivo y los certificados que este utiliza para
proteger las comunicaciones con AWS IoT.
Puede crear reglas que definan una o varias acciones que deban ejecutarse en función de los datos de
un mensaje. Por ejemplo, puede insertar, actualizar o consultar una tabla de DynamoDB o invocar una
función Lambda. Las reglas usan expresiones para filtrar los mensajes. Cuando una regla coincide con
un mensaje, el motor de reglas desencadena la acción mediante las propiedades seleccionadas. Las
reglas también contienen una función de IAM que concede permiso a AWS IoT sobre los recursos de AWS
utilizados para desempeñar la acción.
4
Inicie sesión en la consola de AWS IoT.
Introducción a AWS IoT Core

En este tutorial se muestra cómo crear los recursos necesarios para enviar, recibir y procesar mensajes
MQTT de dispositivos que utilizan AWS IoT Core. Puede utilizar un cliente MQTT para emular un
dispositivo IoT.
Para obtener más información acerca de AWS IoT Core, consulte ¿Qué es AWS IoT Core? (p. 1).
Temas
• Inicie sesión en la consola de AWS IoT. (p. 5)
• Creación de un objeto (p. 6)
• Registro de un dispositivo (p. 6)
• Configuración del dispositivo (p. 12)
• Visualización de los mensajes de MQTT de dispositivo con el cliente MQTT de AWS IoT (p. 12)
• Configuración y comprobación de reglas (p. 14)
• Creación y seguimiento de un trabajo de AWS IoT Core (p. 25)
Inicie sesión en la consola de AWS IoT.

Si no tiene una cuenta de AWS, deberá crear una.
Para crear una cuenta de AWS
1. Abra la página de inicio de AWS y elija Crear una cuenta de AWS.

2. Siga las instrucciones en línea. Parte del procedimiento de inscripción consiste en recibir una llamada
telefónica e introducir un número PIN con su teclado de teléfono.
3. Inicie sesión en la consola de administración de AWS y abra la consola de AWS IoT.
4. En la página Welcome, elija Get started.
5
Creación de un objeto
Si es la primera vez que utiliza la consola de AWS IoT, verá la página Welcome to the AWS IoT
Console (Le damos la bienvenida a la consola de ).
Creación de un objeto
Los dispositivos conectados a AWS IoT están representados por objetos en el registro de AWS IoT. Un
objeto representa un dispositivo específico o una entidad lógica. Puede ser un dispositivo físico o un
sensor (por ejemplo, una bombilla o un interruptor 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 con AWS IoT, pero que está
relacionada con otros dispositivos que sí lo están (por ejemplo, un automóvil con sensores de motor o un
panel de control).
Crear un objeto
1. En la página Le damos la bienvenida a la consola de AWS IoT, en el panel de navegación, seleccione

Administración.
2. En la página Aún no tiene ningún objeto, elija Registrar un objeto.
3. En la página Creación de objetos de AWS IoT, elija Crear un solo objeto.
4. En la página Creación de un objeto, en el campo Nombre, escriba un nombre para el objeto, por
ejemplo, MyIotThing. Seleccione Siguiente. 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 es recomendable utilizar información de identificación personal en el nombre del objeto.
Registro de un dispositivo
El registro le permite mantener un registro de todos los dispositivos que están registrados a su cuenta de
AWS IoT Core. El proceso de registro del dispositivo incluye estos pasos:
Temas
• Creación y activación de un certificado de dispositivo (p. 6)
• Creación de una política de AWS IoT Core (p. 8)
• Asociación de una política de AWS IoT Core a un certificado de dispositivo (p. 10)
• Asociación de un certificado a un objeto (p. 11)
Creación y activación de un certificado de dispositivo

La comunicación entre su dispositivo y AWS IoT Core se protege mediante certificados X.509. AWS IoT
Core puede generar un certificado, o bien usted puede utilizar su propio certificado X.509. En este tutorial,
AWS IoT Core generará el certificado X.509 automáticamente. Los certificados deben activarse para poder
usarlos.
1. Elija Create certificate.
6
Creación y activación de un certificado de dispositivo
2. En la página Certificate created (Certificado creado), elija los enlaces Download (Descargar) para
descargar el certificado, la clave privada y la CA raíz para AWS IoT Core. (No es necesario descargar
la clave pública). Guárdelos en su equipo y, a continuación, elija Activate para continuar.
Note
El enlace Download (Descargar) de la CA raíz de AWS IoT le llevará a la página

Autenticación de servidor, en la que debe elegir un certificado de CA. A diferencia de los
demás enlaces Download (Descargar) de la página, no descarga directamente un archivo.
7
Creación de una política de AWS IoT Core
Tenga en cuenta que los nombres de los archivos descargados pueden ser distintos de los que figuran
en la página El certificado se ha creado. Por ejemplo:
• 2a540e2346-certificate.pem.crt
• 2a540e2346-private.pem.key
• 2a540e2346-public.pem.key
Note
Aunque sea poco probable, los certificados de CA raíz están sujetos a vencimiento y
revocación. Si esto ocurriese, deberá copiar un nuevo certificado de CA raíz en su dispositivo.
3. Seleccione Listo para volver a la página principal de la consola de AWS IoT.
Al trabajar con un dispositivo tendrá que copiar la clave privada y certificado de CA raíz en su dispositivo.
Las instrucciones de esta guía se han escrito partiendo del supuesto de que no está utilizando un
dispositivo y simplemente se está familiarizando con la consola de AWS IoT.

Los certificados X.509 se utilizan para autenticar su dispositivo en AWS IoT Core. Las políticas de AWS
IoT Core se utilizan para autorizar a su dispositivo a ejecutar operaciones de AWS IoT Core, como
suscribirse a temas MQTT o publicar en ellos. Su dispositivo presenta su certificado cuando envíe
mensajes a AWS IoT Core. Para permitir a su dispositivo llevar a cabo operaciones de AWS IoT Core,
debe crear una política de AWS IoT Core y asociarla al certificado de su dispositivo.
Para crear una política de AWS IoT Core
1. En el panel de navegación de la izquierda, seleccione Seguridad y, a continuación, elija Políticas. En

la página You don't have a policy yet, elija Create a policy.
8
2. En la página Crear una política, en el campo Nombre, escriba un nombre para la política (por ejemplo,
MyIotPolicy). No utilice información personalmente identificable en sus nombres de política.
3. En el campo Acción, escriba iot:Connect. En el campo ARN de recurso, escriba *. Marque la

casilla Allow. Esto permite que todos los clientes se conecten a AWS IoT Core.
Note
Puede restringir qué clientes (dispositivos) pueden conectarse, especificando un ARN de

cliente como recurso. Los ARN de cliente tienen este formato:
arn:aws:iot:your-region:your-aws-account:client/<my-client-id>
4. Seleccione el botón Añadir declaración para agregar otra instrucción de política. En el campo Acción,
escriba iot:Publish. En el campo Resource ARN (ARN de recurso), escriba el ARN del tema en el
que su dispositivo va a publicar.
Note
El ARN de tema tiene este formato:

arn:aws:iot:your-region:your-aws-account:topic/<your/topic>
Por ejemplo:
arn:aws:iot:us-east-1:123456789012:topic/my/topic
5. Por último, marque la casilla Allow. Esto permite a su dispositivo publicar mensajes en el tema
especificado.
6. Una vez que haya especificado la información de su política, elija Create.
Para obtener más información, consulte Políticas de IAM (p. 193).
9
Asociación de una política de AWS IoT
Core a un certificado de dispositivo
Asociación de una política de AWS IoT Core a un

certificado de dispositivo
Ahora que ha creado una política, debe asociarla a su certificado de dispositivo. Si asocia una política de
AWS IoT Core a un certificado, dará al dispositivo los permisos especificados en la política.
1. En el panel de navegación de la izquierda, seleccione Seguridad y, a continuación, elija Certificados.

2. En la casilla del certificado que ha creado, elija ... para abrir un menú desplegable y, a continuación,
elija Attach policy (Asociar política).
3. En el cuadro de diálogo Asociar políticas a los certificados, marque la casilla de verificación junto a la
política que ha creado en el paso anterior y, a continuación, seleccione Adjunte.
10
Asociación de un certificado a un objeto
Asociación de un certificado a un objeto

Un dispositivo debe tener un certificado, una clave privada y un certificado de entidad de certificación raíz
para autenticarse en AWS IoT Core. También le recomendamos asociar el certificado del dispositivo al
objeto de IoT que representa a su dispositivo en AWS IoT Core. Esto le permite crear políticas de AWS
IoT Core que concedan permisos según los certificados asociados a sus objetos. Para obtener más
información, consulte Variables de la política de objeto (p. 156).
Para asociar un certificado al objeto que representa el dispositivo en el registro
1. En la casilla del certificado que ha creado, elija ... para abrir un menú desplegable y, a continuación,
elija Attach thing (Asociar objeto).
2. En el cuadro de diálogo Asociar objetos a los certificados, marque la casilla situada junto al objeto que
ha registrado y, a continuación, elija Adjunte.
3. Para verificar que el objeto esté asociado, seleccione la casilla del certificado.
11
Configuración del dispositivo
4. En el panel de navegación izquierdo de la página Details (Detalles) del certificado, elija Things
(Objetos).
5. Para verificar que la política se haya asociado, en el panel de navegación izquierdo de la página
Details del certificado, elija Policies.

Todos los dispositivos deben tener un certificado de dispositivo, una clave privada y un certificado de
entidad de certificación raíz instalado para comunicarse con AWS IoT Core. Consulte la documentación de
su dispositivo para saber cómo conectarse a él y copiar el certificado de dispositivo, la clave privada y el
certificado de CA raíz.
Si no dispone de un dispositivo listo para IoT, puede utilizar el cliente MQTT, los SDK de dispositivos
de AWS IoT o la CLI de AWS. Para obtener más información, consulte la sección Uso de los SDK de
dispositivos de AWS IoT en Raspberry Pi (p. 78). Los tutoriales utilizan un Raspberry Pi, pero pueden
adaptarse de manera sencilla para su uso con otros tipos de equipos.
Visualización de los mensajes de MQTT de

dispositivo con el cliente MQTT de AWS IoT
Puede utilizar el cliente MQTT de AWS IoT para comprender mejor los mensajes de MQTT enviados por
un dispositivo.
Los dispositivos publican los mensajes MQTT en temas. Puede utilizar el cliente MQTT de AWS IoT para
suscribirse a estos temas para ver los mensajes.
12
Visualización de los mensajes de MQTT de
dispositivo con el cliente MQTT de AWS IoT
Para ver los mensajes MQTT
1. En la consola de AWS IoT, en el panel de navegación izquierdo, elija Test (Probar).
2. Suscríbase al tema en el que publica su objeto de IoT. Continuando con este ejemplo, en Suscribirse
a un tema, en el campo Tema de suscripción escriba my/topic y, a continuación, elija Suscribirse al
tema.
El tema my/topic aparece en la columna Suscripciones.
13
Configuración y comprobación de reglas
Para emular un objeto de IoT enviando un mensaje
• En la página del cliente MQTT, en la sección Publicación, en el campo Especifique un tema y el

mensaje que desea publica, escriba my/topic. No utilice información personalmente identificable en
sus nombres de temas.
En la sección de carga del mensaje, introduzca el siguiente JSON:
{
"message": "Hello, world",
"clientType": "MQTT client"
}
Elija Publish to topic. Debería ver el mensaje en el cliente MQTT de AWS IoT. (Elija my/topic en la
columna Suscripciones par ver el mensaje).
Configuración y comprobación de reglas

El motor de reglas de AWS IoT; escucha los mensajes de MQTT de entrada que coinciden con una regla.
Cuando se recibe un mensaje que coincide, la regla actúa con los datos del mensaje MQTT (por ejemplo,
14
Creación de un tema de SNS
escribe datos en un bucket de Amazon S3, invoca una función de Lambda o envía un mensaje a un tema
de Amazon SNS). En este paso, crea y configura una regla para enviar los datos recibidos desde un
dispositivo a un tema de Amazon SNS. En concreto, puede:
• Crear un tema de Amazon SNS.

• Suscribirse al tema de Amazon SNS utilizando un número de teléfono móvil.
• Crear una regla que envíe un mensaje al tema de Amazon SNS al recibir un mensaje de su dispositivo.
• Pruebe la regla utilizando el cliente de MQTT.

Utilice la consola de Amazon SNS para crear un tema de Amazon SNS.
Note
Amazon SNS no está disponible en todas las regiones de AWS.
1. Abra la consola de Amazon SNS.

2. En el panel de la izquierda, elija Topics.
3. Elija Create new topic.
4. Escriba un nombre de tema y otro de visualización y, a continuación, seleccione Create topic (Crear
tema). No utilice información personalmente identificable en sus nombres de temas de Amazon SNS.
15
5. Anote el ARN del tema que acaba de crear.
16
Suscripción a un tema de Amazon SNS
Suscripción a un tema de Amazon SNS

Para recibir SMS en su teléfono móvil, suscríbase al tema de Amazon SNS.
1. En la consola de Amazon SNS, seleccione Suscripciones en el panel izquierdo. En el menú

Suscripciones elija Crear suscripción.
2. En Crear suscripción, en la lista desplegable Tema ARN, seleccione el ARN del tema al que desea
suscribirse.
En la lista desplegable Protocolo, elija SMS.
En el campo Punto de conexión, escriba el número de un teléfono móvil habilitado para SMS y, a
continuación, elija Create subscription (Crear suscripción).
Note
Escriba el número de teléfono utilizando únicamente números y guiones.
17
Creación de una regla
La consola de Amazon SNS muestra el siguiente mensaje, pero es posible que no reciba un mensaje SMS
de confirmación.

Las reglas de AWS IoT Core se componen de un filtro de temas, una acción de regla y, en la mayoría de
los casos, un rol de IAM. Los mensajes publicados en temas que coinciden con el filtro de temas activan la
regla. La acción de la regla define qué acción ejecutar cuando se activa la regla. El rol de IAM contiene una
18
o varias políticas de IAM que determinan a qué servicios de AWS puede tener acceso la regla. Puede crear
varias reglas que escuchan un único tema. Del mismo modo, puede crear una única regla que se activa
con varios temas. El motor de reglas de AWS IoT Core procesa constantemente los mensajes publicados
en temas que coinciden con los filtros de temas definidos en las reglas.
En este ejemplo, se crea una regla que utiliza Amazon SNS para enviar una notificación por SMS a un
teléfono móvil.
1. En la consola de AWS IoT, en el panel de navegación izquierdo, elija Act (Actuar).
2. En la página Act, seleccione Create a rule.
3. En la página Crear una regla, en el campo Nombre, escriba un nombra para la regla.
Note
No es recomendable utilizar datos personales en los nombres de las reglas.
En el campo Descripción, escriba una descripción para la regla.
19
4. Desplácese hacia abajo hasta Rule query statement (Instrucción de consulta de regla). Seleccione la
última versión en la lista desplegable de Using SQL version. En el campo Instrucción de consulta de
regla, introduzca SELECT * FROM 'my/topic'.
SELECT * especifica que desea enviar todo el mensaje MQTT que ha activado la regla. FROM 'my/
topic' es el filtro de temas. El motor de reglas utiliza el filtro de temas para determinar qué reglas
deben activarse cuando se recibe un mensaje MQTT.
5. En Set one or more actions, elija Add action.
6. En la página Seleccionar una acción, elija Enviar un mensaje como una notificación push SNS y, a
continuación, elija Configurar acción.
20
21
7. En la página Configurar acción, en Destino de SNS, elija Seleccionar para ampliar el tema de SNS. A
continuación, elija Seleccionar junto al tema de Amazon SNS que creó anteriormente. En Formato de
mensaje, elija JSON.
8. Ahora dé permiso a AWS IoT Core para publicar en el tema de Amazon SNS en su nombre cuando se
active la regla. Elija Create a new role. En Nombre de rol de IAM, escriba un nombre para el nuevo rol
y, a continuación, elija Crear un nuevo rol.
9. En Nombre de rol de IAM, elija Actualizar rol para aplicar los permisos al rol recién creado. Elija el rol
y, a continuación, elija Añadir acción.
22
10. En la página Create a Rule, seleccione Create rule.
23
24
Comprobación de la regla de Amazon SNS
Para obtener más información sobre la creación de reglas, consulte Reglas para AWS IoT (p. 285).
Comprobación de la regla de Amazon SNS

Puede utilizar el cliente MQTT de AWS IoT para probar la regla.
1. En la consola de AWS IoT, en el panel de navegación izquierdo, elija Test (Probar).

2. En la página de cliente MQTT, en la sección Publicación, en el campo Especifique un tema y el
mensaje que desea publicar, escriba my/topic o el tema que ha utilizado en la regla. En la sección
de carga del mensaje, introduzca el siguiente JSON:
{
"default": "Hello, from AWS IoT console",
"message": "Hello, from AWS IoT console"
}
3. Elija Publish to topic. Debería recibir un mensaje de Amazon SNS en su teléfono móvil.
¡Enhorabuena! Ha creado y configurado correctamente una regla que envía los datos recibidos de un
dispositivo a un tema de Amazon SNS.
Pasos siguientes
Para obtener más información sobre las reglas de AWS IoT Core, consulte Tutoriales de reglas de AWS
IoT Core (p. 39) y Reglas de AWS IoT Core (p. 285).
Creación y seguimiento de un trabajo de AWS IoT

Core
Puede usar trabajos de AWS IoT Core le permiten implementar y realizar seguimiento a tareas de
administración en su flota de dispositivos. Puede utilizar trabajos para enviar acciones remotas a uno
o varios dispositivos a la vez, controlar la implementación de trabajos en sus dispositivos y realizar un
seguimiento del estado actual y pasado de las ejecuciones de trabajos en cada dispositivo.
En este tema le enseñamos a crear e implementar un trabajo de ejemplo en un dispositivo. Le guiaremos

por los pasos necesarios para crear un trabajo y realizar un seguimiento de sus eventos en un dispositivo
que esté configurado para comunicarse con AWS IoT Core. En estas instrucciones se presupone que está
utilizando Raspberry Pi, pero se podrían adaptar para otros dispositivos basados en Linux.
A continuación se indican algunos escenarios de ejemplo para utilizar trabajos:
• Actualizar el firmware de dispositivos, software o archivos, como certificados de seguridad.

• Realizar tareas administrativas, como el reinicio de dispositivos o la realización de diagnósticos.
• Restaurar dispositivos a la configuración de fábrica u otros estados correctos conocidos.
Conexión del dispositivo a AWS IoT

Siga estos pasos para conectar una Raspberry Pi a AWS IoT Core.
1. Siga las instrucciones de Conexión de Raspberry Pi. Cuando haya terminado, tendrá un objeto de
AWS IoT Core registrado en la cuenta de AWS. También tendrá certificados de seguridad totalmente
configurados en su dispositivo.
25
Ejecución del trabajo de ejemplo
2. Complete los pasos del tutorial Uso de AWS IoT Device SDK para JavaScript. Cuando haya
terminado, el dispositivo estará conectado a AWS IoT Core, y podrá ejecutar el código de muestra que
viene con el AWS IoT Device SDK para JavaScript.
Ahora, su dispositivo estará listo para utilizar trabajos de AWS IoT Core.
Ejecución del trabajo de ejemplo

El AWS IoT Device SDK para JavaScript incluye un ejemplo llamado jobs-example.js. El ejemplo puede
recibir mensajes de la consola de AWS IoT para verifiar la conectividad. También puede recibir y procesar
ejecuciones de trabajos que se originan en el servicio Jobs de AWS IoT Core.
Puede ejecutar este ejemplo utilizando el siguiente comando. Utilice el punto de enlace REST de su
Raspberry Pi como valor del parámetro -H.
node examples/jobs-example.js -f ~/certs -H <PREFIX>.iot.<REGION>.amazonaws.com -

T thingName
Si ha creado un archivo de configuración que contiene el nombre del objeto y el punto de enlace del host
(el punto de enlace REST de su dispositivo), puede usar el siguiente comando.
node examples/jobs-example.js –f ./certs –F your config file name.json
Creación de un documento de trabajo

Los documentos de trabajo son documentos JSON que contienen la información que necesita su
dispositivo para realizar un trabajo. El AWS IoT Device SDK para JavaScript utiliza una propiedad
denominada operation para dirigir los documentos de trabajo a controladores específicos. El programa
jobs-example.js tiene un controlador de ejemplo para una operación denominada customJob. Para
crear un documento de trabajo con el nombre example-job.json para este controlador, el archivo debe
contener el siguiente objeto JSON.
{
"operation":"customJob",
"otherInfo":"someValue"
}
Para ver más documentos de trabajo de ejemplo, consulte la documentación de la muestra jobs-agent.js.
Creación de un trabajo
Ahora estará listo para crear un trabajo que entregue el documento de trabajo a todos los dispositivos que
especifique. Puede usar la consola de AWS IoT, el SDK de AWS IoT o la CLI de AWS IoT para crear un
trabajo.
El siguiente ejemplo muestra cómo utilizar laCLI de AWS IoT para crear un trabajo.
26
aws iot create-job \

--job-id "example-job-01" \
--targets "arn:aws:iot:::thing/MyRaspberryPi" \
--document file:///example-job.json \
--description "My First test job" \
--target-selection SNAPSHOT
Si guarda su documento de trabajo en un bucket de S3, utilice el parámetro document-source en lugar

del parámetro document para especificar la URL de Amazon S3 para el documento de trabajo.
Si prefiere utilizar la consola de AWS IoT, siga estos pasos para crear un trabajo.
1. Cargue el documento de trabajo en un bucket de S3. Para obtener información, consulte ¿Cómo
puedo cargar archivos y carpetas en un bucket de S3? en la Guía del usuario de la consola de
Amazon Simple Storage Service.
2. En la consola de AWS IoT, seleccione Manage (Administrar) y después Jobs (Trabajos).
3. Elija Create a job (Crear un trabajo).
27
4. En la página Select a job (Seleccionar un trabajo), elija Create custom job (Crear trabajo
personalizado).
28
29
5. En la página Create a job (Crear un trabajo), escriba un ID de trabajo único.

Note
No es recomendable utilizar datos personales en los ID de trabajos.
En Select devices to update (Seleccionar dispositivos que actualizar), seleccione el dispositivo que
haya conectado a AWS IoT.
30
31
6. Desplácese hasta Add a job file (Añadir un archivo de trabajo) y seleccione el archivo del documento
de trabajo que haya actualizado a Amazon S3. En Job type (Tipo de trabajo), seleccione Your job will
complete after deploying to the selected devices/groups (snapshot) (El trabajo se realizará después
de implementarse en los dispositivos o grupos seleccionados (instantánea)). (La otra opción, Your
job will continue deploying to any devices added to the selected groups (continuous) (El trabajo se
seguirá implementando en los dispositivos añadidos a los grupos seleccionados (continuo)), sirve para
implementar un trabajo en grupos de dispositivos, ya que los dispositivos se añaden a cada grupo).
Deje Job executions rollout configuration (Configuración de despliegue de ejecuciones de trabajo) sin
cambiar. Seleccione Create.
32
33
Ejecución del trabajo en un dispositivo
7. El nuevo trabajo aparece en la página Jobs (Trabajos).
Para obtener más información sobre cómo crear e implementar trabajos, consulte Trabajos (p. 413).
Ejecución del trabajo en un dispositivo

Tras haber creado el trabajo, el servicio Jobs envía una notificación de trabajo pendiente a su
dispositivo. Su dispositivo recibirá los detalles del trabajo y el documento de trabajo a través de la API
NextJobExecutionChanged. El ejemplo jobs-example.js que ya ha realizado ejecutará el trabajo en el
dispositivo. Cuando se haya completado el trabajo, el ejemplo publica su estado de completado mediante
el uso de la API UpdateJobExecution. Al ejecutar el ejemplo en su dispositivo, verá el siguiente resultado.
node examples/jobs-example.js -f ./certs -F config.json

connect
startJobNotifications completed for thing: MyRaspberryPi
customJob operation handler invoked, jobId: example-job-01
Al actualizar la página Jobs (Trabajos), podrá ver que su trabajo se ha completado correctamente.
34
Seguimiento del progreso de un trabajo con
eventos de trabajo y de ejecución de trabajos
Seguimiento del progreso de un trabajo con eventos

de trabajo y de ejecución de trabajos
Puede utilizar eventos de Job y eventos de JobExecution para realizar un seguimiento del progreso de
su trabajo.
Es una forma útil de alertar a los usuarios, los administradores de sistemas u otros miembros de su
sistema de que un trabajo se ha completado o de que la ejecución de un trabajo ha cambiado de estado.
Por ejemplo, puede alertar a un usuario de la actualización del firmware de un dispositivo o informar a un
administrador del sistema de que existe un problema en su flota de dispositivos que se debe investigar y
resolver.
Los eventos de trabajos para el trabajo de este ejemplo se publican en los siguientes temas cuando se ha
completado o cancelado el trabajo.
$aws/events/job/example-job-01/completed
$aws/events/job/example-job-01/canceled
Los eventos de ejecución de trabajos para el trabajo de este ejemplo se envían a los siguientes temas
cuando la ejecución del trabajo alcanza uno de los estados finales posibles.
$aws/events/jobExecution/example-job-01/succeeded
$aws/events/jobExecution/example-job-01/failed
$aws/events/jobExecution/example-job-01/rejected
$aws/events/jobExecution/example-job-01/canceled
$aws/events/jobExecution/example-job-01/removed
35
Cuando la ejecución del trabajo se completa en su dispositivo, AWS IoT Core publica un evento
JobExecution con el estado succeeded. Puede ver este evento en la consola navegando a la página Test
(Probar) de y suscribiéndose al tema $aws/events/jobExecution/example-job-01/succeeded del
cliente MQTT.
Aparecerá el siguiente mensaje cuando la ejecución del trabajo para su dispositivo se haya completado
correctamente.
36
AWS IoT Core también publica un evento job completado. Puede ver este evento suscribiéndose al tema
$aws/events/job/example-job-01/completed en el cliente MQTT.
37
38
Creación de una regla con una acción de DynamoDB
Tutoriales de reglas de AWS IoT

En los siguientes tutoriales, se explica cómo crear y probar reglas de AWS IoT. Antes de comenzar,
asegúrese de completar el tutorial de introducción a AWS IoT (p. 5). Le muestra cómo crear una cuenta de
AWS y cómo registrar un dispositivo en AWS IoT, que son requisitos previos para estos tutoriales.
El escenario de este tutorial es un invernadero con filas de las plantas. Cada planta tiene un sensor de
humedad. En un intervalo predeterminado, el sensor de humedad envía sus datos a AWS IoT. El motor
de reglas de AWS IoT recibe estos datos y los escribe en una tabla de DynamoDB. Puede crear una regla
para escribir datos en DynamoDB y emular los sensores que utilizan el cliente de MQTT de AWS IoT.
Una regla de AWS IoT consta de una instrucción SQL SELECT, un filtro de temas y una acción de
regla. Los dispositivos envían información a AWS IoT publicando mensajes en los temas de MQTT. La
instrucción SQL SELECT le permite extraer datos de un mensaje MQTT de entrada. El filtro de temas de
una regla de AWS IoT especifica uno o varios temas de MQTT. La regla se activa cuando se recibe en
un tema un mensaje MQTT que coincide con el filtro de temas. Las acciones de regla le permiten tomar
la información extraída de un mensaje MQTT y enviarla a otro servicio de AWS. Las acciones de regla se
definen para servicios de AWS como Amazon DynamoDB, AWS Lambda, Amazon SNS y Amazon S3.
Con una regla Lambda puede llamar a otros servicios web de AWS o de terceros. Para obtener una lista
completa de las acciones de las reglas, consulte Acciones de las reglas de AWS IoT (p. 292).
En estos tutoriales se presupone está utilizando el cliente de MQTT de AWS IoT y que está utilizando my/
greenhouse como filtro de temas en las reglas.
También puede utilizar su propio dispositivo, pero deberá saber en qué tema de MQTT publica su
dispositivo para especificarlo como filtro de temas en la regla. Para obtener más información, consulte
Reglas de AWS IoT (p. 285).
Creación de una regla con una acción de

DynamoDB
La acción de DynamoDB le permite tomar información de un mensaje MQTT de entrada y escribirla en una
tabla de DynamoDB.
Para crear una regla de DynamoDB
1. En la consola de AWS IoT, en el panel de navegación, elija Act (Actuar).
39
2. En la página Rules (Reglas), elija Create (Crear).
3. En la página Crear una regla, introduzca un nombre y una descripción para la regla.
Note
No es recomendable utilizar datos personales en los nombres o en las descripciones de

regla.
4. En Instrucción de consulta de regla, elija la versión más reciente desde la lista Uso de la versión de
SQL. Para Rule query statement (Instrucción de consulta de regla), escriba:
SELECT * FROM 'my/greenhouse'
("SELECT *" especifica que desea enviar todo el mensaje MQTT que ha desencadenado la regla.
"FROM 'my/greenhouse'" indica el motor de reglas para desencadenar esta regla cuando se
recibe un mensaje MQTT cuyo tema coincide con este filtro de temas). Elija Añadir acción.
40
5. En Select an action (Seleccionar una acción), elija Insert a message into a DynamoDB table (Insertar
un mensaje en una tabla de DynamoDB) y, a continuación, elija Configure action (Configurar acción).
41
6. En Configure action (Configurar acción), elija Create a new resource (Crear un nuevo recurso).
42
7. En la página Amazon DynamoDB, elija Create table.
43
8. En Create DynamoDB table (Crear tabla DynamoDB), escriba un nombre. En Partition key (Clave
de partición), escriba Row. Seleccione Add sort key (Añadir clave de ordenación) y, a continuación,
introduzca PositionInRow en el campo Sort key (Clave de ordenación). Row representa una fila
de plantas en un invernadero. PositionInRow representa la posición de una planta en la fila. Elija
String (Cadena) para las claves de partición y de ordenación y, a continuación, seleccione Create
(Crear). La tabla de DynamoDB tarda unos segundos en crearse. Cierre la pestaña del navegador
donde la consola de Amazon DynamoDB está abierta. Si no cierra la pestaña, su tabla de DynamoDB
no se muestra en la lista desplegable de Table name (Nombre de tabla) en la página Configure action
(Configurar acción) de la consola de AWS IoT.
44
9. En Configure action (Configurar acción), elija la nueva tabla de la lista Table name (Nombre de la
tabla). En Partition key value (Valor de clave de partición), escriba ${row}. Esto indica a la regla que
debe tomar el valor del atributo row en el mensaje MQTT y escribirlo en la columna Row (Fila) de la
tabla de DynamoDB. En Sort key value (Valor de clave de ordenación), escriba ${pos}. Esto escribe
el valor del atributo pos en la columna PositionInRow. En Write message data to this column (Escribir
datos del mensaje en esta columna) introduzca Payload. Esto inserta la carga útil del mensaje en
la columna Payload. Deje Operation (Operación) en blanco. Este campo le permite especificar qué
operación (INSERT, UPDATE o DELETE) desea realizar cuando se activa la acción. Elija Crear un
nuevo rol.
10. En Create a new role (Crear un nuevo rol), introduzca un nombre único en Create role (Crear rol).
45
11. Elija Añadir acción.
46
12. Elija Create rule.
47
48
Prueba de una regla con una acción de DynamoDB
Prueba de una regla con una acción de DynamoDB

1. Para probar la regla, abra la consola de AWS IoT y en el panel de navegación, elija Pruebas.
2. Elija Publicar en un tema. En la sección Publish (Publicar) escriba my/greenhouse. En el área de
mensajes, introduzca el JSON siguiente:
{
"row" : "0",
"pos" : "0",
"moisture" : "75"
}
Vuelva a la consola de DynamoDB y elija Tables (Tablas)
49
Creación de una regla con una acción de AWS Lambda
Seleccione GreenhouseTable y, a continuación, elija Items (Elementos). Los datos se muestran en la

pestaña Items (Elementos).
Creación de una regla con una acción de AWS

Lambda
Puede definir una regla que llame a una función de Lambda, transfiriendo datos del mensaje MQTT que
ha activado la regla. Esto le permite extraer datos del mensaje de entrada y, a continuación, llamar a
otro servicio de AWS o de terceros. En este tutorial, se presupone que ya ha completado el tutorial de
introducción a AWS IoT (p. 5), en el que se crea un tema de Amazon SNS y se suscribe a él. Ahora, creará
una función de Lambda que publica un mensaje en el tema de Amazon SNS que ha creado en el tutorial
de introducción a AWS IoT (p. 5). También creará una regla de Lambda que llama a la función de Lambda
transfiriendo algunos datos del mensaje MQTT que ha activado la regla.
En este tutorial, se utiliza el cliente de MQTT de AWS IoT para enviar un mensaje que desencadena la
regla.
50
Crear una función de Lambda

1. En la consola de AWS Lambda, elija Create function (Crear función).
2. En la página Create function (Crear función), elija Use a blueprint (Utilizar un proyecto). En el campo
de filtro Blueprints (Proyectos), introduzca hello-world y, a continuación, pulse Intro. Elija el
proyecto hello-world-python y, a continuación, elija Configure (Configurar).
3. En Basic information (Información básica), introduzca un nombre para la función.

Note

regla.
51
4. En Execution Role (Rol de ejecución), elija Create a new role from AWS policy templates (Crear un
rol a partir de las plantillas de políticas de AWS). Escriba un nombre para el rol. En Policy templates
(Plantillas de políticas), elija Amazon SNS publish policy (Política de publicación de Amazon SNS).
Haga clic en fuera del menú desplegable para cerrarlo.
5. Elija Create function (Crear función).
52
53
6. En la consola de AWS Lambda, elija el nombre de la función de Lambda. Se muestra información

sobre la función de Lambda. Desplácese a la sección Function code (Código de función) y sustituya el
código existente por el siguiente ejemplo.
from __future__ import print_function
import json
import boto3
print('Loading function')
def lambda_handler(event, context):
# Parse the JSON message

eventText = json.dumps(event)
# Print the parsed JSON message to the console. You can view this text in the
Monitoring tab in the AWS Lambda console or in the Amazon CloudWatch Logs console.
print('Received event: ', eventText)
# Create an SNS client

sns = boto3.client('sns')
# Publish a message to the specified topic

response = sns.publish (
TopicArn = 'arn:aws:iam::123456789012:My_IoT_SNS_Topic',
Message = eventText
)
print(response)
7. Sustituya el valor de TopicArn por el ARN del tema de Amazon SNS que ha creado en Configuración
y pruebas de reglas.
8. Seleccione Save.
54
Comprobación de la función de Lambda

1. En la parte superior derecha de la página de detalles de la función de Lambda, en Select a test event
(Seleccionar un evento de prueba), elija Configure test events (Configurar eventos de prueba).
2. En Configure test event (Configurar evento de prueba), escriba un nombre para el evento de prueba y
sustituya el mensaje JSON por lo siguiente:
{
"message" : "Hello, world"
}
Seleccione Create (Crear).
55
3. En la parte superior derecha de la página de detalles de la función de Lambda, elija Test (Probar) para
probar la función de Lambda con el mensaje que ha especificado en el evento de prueba.
56
Creación de una regla con una acción de Lambda
4. En el código de la función de Lambda, en la pestaña Execution result (Resultado de la ejecución), verá

la salida de la función de Lambda.

En esta sección, se proporcionan los pasos para crear una regla con una acción de Lambda y una acción
de error. La acción de Lambda llama a la función de Lambda. Si se produce un error al llamar a la función
de Lambda, la acción de error publica un mensaje en el tema lambda/error de MQTT. Esto resulta útil
cuando se prueba la regla.
1. Desplácese hasta la consola de AWS IoT y, en el panel de navegación, elija Actuar.
57
2. Elija Crear para crear una regla de AWS IoT.
3. En la página Crear una regla, escriba un nombre y para la regla.
4. En Instrucción de consulta de regla, escriba la consulta siguiente:
58
SELECT * FROM "my/lambda/topic"
5. En Definir una o varias acciones, elija Añadir acción.
6. En Seleccionar una acción, elija Enviar un mensaje a una función de Lambda y, a continuación, elija
Configurar acción.
59
7. En Configurar acción, elija Seleccionar.
60
8. Elija la función de Lambda.
61
10. En la página Crear una regla, en Acción de error, elija Añadir acción.
11. En Definir una acción como una acción de error, seleccione Volver a publicar un mensaje a un tema
de AWS IoT y, a continuación, elija Configurar acción.
62
12. En Configure action (Configurar acción), en Topic (Tema), escriba lambda/error.
63
13. En Elija o cree un rol para conceder acceso a AWS IoT al recurso para que realice esta acción, elija
Crear rol.
14. En Crear un nuevo rol, escriba un nombre para el rol y, a continuación, elija Crear rol.
64
15. En Configurar acción elija Añadir acción.
16. En Crear una regla, elija Crear regla.
65
66
Prueba de una regla con una acción de Lambda
Prueba de una regla con una acción de Lambda

1. Para probar la acción de Lambda, abra la consola de AWS IoT y, en el panel de navegación, elija Test
(Probar).
2. En el cliente MQTT, en Tema de suscripción, escriba lambda/error y, a continuación, elija

Suscribirse al tema.
3. En Publicación, escriba my/lambda/topic y, a continuación, elija Publicar en tema para publicar el

mensaje JSON predeterminado.
67
Solución de problemas de una
regla con una acción de Lambda
La publicación de este mensaje debería activar la regla y llamar a la función de Lambda. La función
de Lambda envía un mensaje de Amazon SNS a un número de teléfono que está suscrito al tema de
Amazon SNS. Si no recibe un mensaje de texto, en el cliente MQTT, compruebe si todos los mensajes se
publicaron lambda/error.
Solución de problemas de una regla con una acción

de Lambda
Si se realiza la llamada a la función de Lambda, pero no recibe un mensaje de texto, asegúrese de que
su número de teléfono está suscrito al tema de Amazon SNS. Si su número de teléfono está suscrito,
compruebe los registros de CloudWatch de la función de Lambda. AWS Lambda escribe los registros en
CloudWatch, lo que le permite ver la salida de la función de Lambda.
Ver registros de CloudWatch
1. En la consola de Lambda, en el panel de navegación, elija Functions (Funciones).
2. Elija la función de Lambda.
3. En la página de detalles de la función de Lambda, elija la pestaña Monitoring (Monitorización).
68
Creación de una regla de Amazon SNS
4. Elija View logs in CloudWatch (Ver registros de CloudWatch).
5. Elija el flujo de registros más reciente.
6. El flujo de registros muestra los registros escritos por la función de Lambda.

Puede definir una regla que envíe los datos de los mensajes a un tema de Amazon SNS.
69
En este tutorial, crea una regla que envía el nombre del objeto de AWS IoT que desencadenó la regla a
todos los suscriptores de un tema de Amazon SNS.
Para crear una regla con una acción de SNS
1. En la consola de AWS IoT, en el panel de navegación, elija Actuar.
2. En la página Reglas, elija Crear.
3. Introduzca un nombre y una descripción breve para la regla.

Note

regla.
70
4. En el editor Instrucción de consulta de regla, introduzca lo siguiente:
SELECT *, topic(3) as thing FROM '$aws/things/+/shadow/update/accepted'
(El filtro de temas que aparece después de "FROM" especifica los temas que dispararán la acción de
la regla cuando se publique un mensaje en ellos. El signo más (+) utilizado en el filtro de temas es un
carácter comodín que coincide con cualquier nombre de objeto. El atributo "topic(3)" después de
"SELECT" añade el nombre del objeto, que es el tercer campo de tema, al contenido del mensaje).
5. En Definir una o varias acciones, elija Añadir acción.
6. En Seleccionar una acción, elija Enviar un mensaje como una notificación push SNS y, a continuación,
elija Configurar acción.
71
72
7. En la página Configurar acción, para Destino de SNS, elija Crear.
8. Escriba un nombre de tema en el cuadro de diálogo y, a continuación, seleccione Create (Crear).
9. En la página Configurar acción, para Destino de SNS, elija el tema de SNS que acaba de crear. En
Formato del mensaje, elija RAW. En Elija o cree un rol para conceder acceso a AWS IoT para que
realice esta acción, elija Crear rol.
73
10. Introduzca un nombre para el rol y, a continuación, seleccione Crear rol.
11. En Configurar acción elija Añadir acción.
74
12. Elija Crear regla.
75
76
Para probarla, añada una suscripción al tema de SNS que ha creado y actualice la sombra de cualquier
objeto de AWS IoT.
Puede utilizar la consola de AWS IoT para buscar un objeto, abrir su página de detalles y cambiar
la sombra del dispositivo. Cuando se notifique el cambio al servicio Device Shadow, este publica un
mensaje en $aws/things/MySNSThing/shadow/update/accepted. Se activará la regla y todos los
suscriptores del tema de SNS recibirán un mensaje con el nombre del objeto.
77
Requisitos previos
Uso de los SDK de dispositivos de

AWS IoT en Raspberry Pi
Los SDK de AWS IoT para dispositivos y móviles le permiten conectar los dispositivos a AWS IoT de
forma sencilla y rápida. 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.
Important
Antes de iniciar este tutorial, complete los pasos de Introducción a AWS IoT Core (p. 5).
Estos tutoriales proporcionan instrucciones paso a paso para conectar Raspberry Pi a la Agente de
mensajes de AWS IoT (p. 266), usando AWS IoT Device SDK para Embedded C y AWS IoT Device SDK
para JavaScript. Después de completar los pasos de estos tutoriales, puede conectarse a la plataforma
de AWS IoT y ejecutar las aplicaciones de ejemplo incluidas con los SDK de AWS IoT para dispositivos y
móviles.
Contenido
• Requisitos previos (p. 78)
• Creación de un objeto de AWS IoT para su Raspberry Pi (p. 78)
• Uso del AWS IoT Device SDK para Embedded C (p. 79)
• Uso del SDK de dispositivos de AWS IoT para JavaScript y Node (p. 82)
Requisitos previos
Necesitará lo siguiente para completar este tutorial:
• Un modelo Raspberry Pi 2 Model B o más reciente.

• Raspbian Wheezy o posterior. Recomendamos usar la última versión de Raspbian, que está disponible
en el sitio web de Raspbian.
• Una conexión Ethernet o Wi-Fi.
• Una cuenta de AWS. Si aún no dispone de una cuenta de AWS, puede obtener una de forma gratuita.
Para ello, vaya al Centro de recursos introductorios de Amazon AWS.
Creación de un objeto de AWS IoT para su

Raspberry Pi
Un objeto representa un dispositivo cuyo estado se almacena en la nube de AWS. El estado del dispositivo
se almacenan en un documento JSON conocido como la sombra del dispositivo. La sombra se utiliza para
almacenar y recuperar información de estado. El servicio Device Shadow mantiene una sombra para cada
dispositivo registrado en AWS IoT.
78
Uso del AWS IoT Device SDK para Embedded C
Para registrar su Raspberry Pi con AWS IoT
1. En su Raspberry Pi, busque a la consola de AWS IoT.

2. En el panel de navegación, seleccione Secure (Seguridad) y, a continuación, elija Policies (Políticas).
3. En la página Policies (Políticas), seleccione Crear a policy (Crear una política).
4. En la página Crear una política:
a. Escriba un nombre para la política (por ejemplo, RaspberryPi-Policy).

b. En Acción, escriba iot:*.
c. En Resource ARN (ARN de recurso), escriba *.
d. En Effect (Efecto) elija Allow (Permitir) y, a continuación, elija Create (Crear).
Esta política permite a su Raspberry Pi publicar mensajes en AWS IoT.

Important
Esta configuración es demasiado permisiva. En un entorno de producción limite

el alcance de los permisos a los requeridos por el dispositivo. Para obtener más
información, consulte Autorización (p. 151).
5. En el panel de navegación de la consola , elija Manage (Administrar) y, a continuación, seleccione
Things (Objetos).
6. Seleccione Create.
8. En la página Add your device to the device registry (Agregar el dispositivo al registro del dispositivo),
introduzca RaspberryPi y, a continuación, elija Next (Siguiente).
9. En la página Añadir un certificado para el objeto, elija Crear certificado.
10. En la página Certificate created (El certificado se ha creado), descargue su claves privada, el
certificado del dispositivo y la entidad de certificación (CA) raíz para AWS IoT. (Seleccione el enlace
Download (Descargar) para cada uno.) Estos archivos se guardan en su directorio /home/pi/
Downloads.
11. Elija Activate (Activar) para activar el certificado X.509 y, a continuación, elija Attach a policy (Asociar
una política).
12. En la página Add a policy for your thing (Agregar una política para su cosa) elija Raspberrypi-policy
(Política de Raspberrypi) y luego elija Register Thing (Registrar cosa).
Uso del 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.
Instalación del AWS IoT Device SDK para Embedded

C.
El AWS IoT Device SDK para Embedded C normalmente está dirigido a dispositivos con limitaciones de
recursos que necesitan un entorno de ejecución optimizado para C, pero se puede utilizar con cualquier
sistema operativo y alojarse en cualquier tipo de procesador (por ejemplo, MCU y MPU). Si dispone de
más memoria y recursos de procesamiento, es conveniente que utilice uno de los SDK de AWS IoT para
dispositivos y móviles superiores (por ejemplo, C++, Java, JavaScript y Python). Por lo general, AWS
IoT Device SDK for Embedded C está pensando para sistemas que utilizan MCU o MPU lentas que
ejecutan sistemas operativos incrustados. En los ejemplos de programación de la documentación, usamos
Raspberry Pi con Linux incrustado.
79
Configuración de aplicación de muestra
Example
1. Descargue el AWS IoT Device SDK para Embedded C en Raspberry Pi desde GitHub.
git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git -b release
Esto crea un directorio denominado aws-iot-device-sdk-embedded-c en el directorio actual.

2. Descargue mbed TLS en su Raspberry Pi desde el sitio web de mbed TLS.
3. Acceda al directorio /home/pi/Downloads. Expanda el archivo mbedtls-versionNumber-
apache.tgz de la versión más reciente utilizando el comando siguiente.
tar -xvf mbedtls-versionNumber-apache.tgz
4. Copie el contenido de mbedtls-versionNumber en el directorio aws-iot-device-sdk-

embedded-C/external_libs/mbedTLS utilizando el siguiente comando.
mv ~/Downloads/mbedtls-versionNumber/* ~/aws-iot-device-sdk-embedded-c/external_libs/
mbedTLS
Configuración de aplicación de muestra

El AWS IoT Device SDK para Embedded C contiene aplicaciones de ejemplo que puede probar. Para
simplificar, este tutorial utiliza la aplicación subscribe_publish_sample, que ilustra cómo puede
conectarse al agente de mensajes de AWS IoT Core, así como suscribirse a temas de MQTT y publicar en
ellos.
1. Copie el certificado, la clave privada y el certificado de CA raíz creado en Creación de un objeto de

AWS IoT para su Raspberry Pi (p. 78) en el directorio aws-iot-device-sdk-embedded-C/
certs.
Note
Los certificados de dispositivo y de CA raíz están sujetos a vencimiento o revocación. Si los

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/samples/linux/subscribe_publish_sample.
Si tiene instalada la AWS CLI, puede utilizar el comando aws iot describe-endpoint --endpoint-type
iot:Data-ATS para buscar la URL del punto de enlace personal. Si no tiene instalada la AWS CLI,
abra la consola de AWS IoT Core. Desde el panel de navegación, elija Manage (Administrar) y, a
continuación, Things (Cosas). Elija la cosa IoT para su Raspberry Pi y, a continuación, elija Interact
(Interactuar). Su punto de enlace se muestra en la sección HTTPS de la página de detalles de la
cosa.
3. Abra el archivo aws_iot_config.h y, en la sección Get from console, actualice los valores de
los elementos siguientes:
AWS_IOT_MQTT_HOST
El punto de enlace personal.

AWS_IOT_MY_THING_NAME
El nombre del objeto.

80
Ejecución de las aplicaciones de ejemplo
AWS_IOT_ROOT_CA_FILENAME
El certificado de CA raíz.
AWS_IOT_CERTIFICATE_FILENAME
Su certificado.
AWS_IOT_PRIVATE_KEY_FILENAME
La clave privada.
Por ejemplo:
// Get from console

// =================================================
#define AWS_IOT_MQTT_HOST "a22j5sm6o3yzc5.iot.us-east-1.amazonaws.com"
#define AWS_IOT_MQTT_PORT 8883
#define AWS_IOT_MQTT_CLIENT_ID "MyRaspberryPi"
#define AWS_IOT_MY_THING_NAME "MyRaspberryPi"
#define AWS_IOT_ROOT_CA_FILENAME "root-CA.crt"
#define AWS_IOT_CERTIFICATE_FILENAME "device.pem.crt"
#define AWS_IOT_PRIVATE_KEY_FILENAME "private.pem.key"
// =================================================

Para ejecutar las aplicaciones de ejemplo de AWS IoT Device SDK para Embedded C
1. Utilice el archivo Make incluido para compilar la subscribe_publish_sample_app.
make -f Makefile
Esto generará un archivo ejecutable.

2. Ejecute subscribe_publish_sample_app. Debería ver un resultado similar a este:
Su Raspberry Pi ya está conectado a AWS IoT mediante AWS IoT Device SDK para Embedded C.
81
Uso del SDK de dispositivos de
AWS IoT para JavaScript y Node
Uso del SDK de dispositivos de AWS IoT para

JavaScript y Node
En este tutorial, se muestra cómo instalar Node.js, el administrador de paquetes npm y el SDK de
dispositivos de AWS IoT para JavaScript en un Raspberry Pi y cómo ejecutar las aplicaciones de ejemplo.
Instale la versión más reciente de Node.js.

Para utilizar el SDK de dispositivos de AWS IoT para JavaScript, instale Node.js y el administrador de
paquetes npm en el Raspberry Pi.
1. Para descargar la última versión del repositorio de nodos, abra una ventana de terminal y ejecute el
siguiente comando:
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -

2. Ejecute el comando siguiente para instalar Node y npm.
sudo apt-get install -y nodejs

3. Ejecute los comandos siguientes para verificar la instalación de Node y npm.
node -v
npm -v
Si se muestra un número de versión, node y npm se instalan correctamente.
Instalación de AWS IoT Device SDK para JavaScript

Instale el SDK de dispositivos de AWS IoT para JavaScript en su Raspberry Pi.
1. En la ventana del terminal, utilice el siguiente comando para clonar el repositorio del SDK de
dispositivos de AWS IoT para JavaScript en su directorio principal (de forma predeterminada, /home/
pi).
git clone https://github.com/aws/aws-iot-device-sdk-js.git

2. cd en el directorio aws-iot-device-sdk-js.
3. Utilice npm para instalar el SDK:
npm install
Preparación antes de ejecutar las aplicaciones de

ejemplo
En aws-iot-device-sdk-js, cree un directorio certs y copie la clave privada, el certificado de
dispositivo y el certificado de CA raíz en él.
Para ejecutar las aplicaciones de ejemplo del AWS IoT Device SDK para JavaScript, necesita la siguiente
información:
82
La región de AWS
Para encontrar la región que está utilizando, abra la consola de AWS IoT y compruebe la URL. La
región aparece inmediatamente después de https://. Por ejemplo:
https://us-west-2.console.aws.amazon.com/iot/home?region=us-west-2#/
dashboard
Para obtener más información, consulte Puntos de enlace del servicio de AWS IoT.
Un ID de cliente
Una cadena alfanumérica arbitraria que se utiliza para identificar un dispositivo o una aplicación que
se conecta a AWS IoT. Este debería ser el mismo que su nombre de cosa de IoT para este tutorial.
La clave privada
La ruta completa a su clave privada en el Raspberry Pi (por ejemplo, /home/pi/aws-iot-device-

sdk-js/certs/private.pem.key).
El certificado X.509 de AWS IoT
La ruta completa al certificado de AWS IoT en el Raspberry Pi ()por ejemplo, /home/pi/aws-iot-

device-sdk-js/certs/device.pem.crt).
La CA raíz de Amazon de STS
La ruta completa a la CA raíz de Amazon en el Raspberry Pi (por ejemplo, /home/pi/aws-iot-

device-sdk-js/certs/Amazon-root-CA-1.pem).
El punto de enlace de AWS IoT
Si ha instalado la AWS CLI en su Raspberry Pi, puede ejecutar el comando describe-endpoint de CLI
para buscar su punto de enlace:
aws iot describe-endpoint --endpoint-type iot:Data-ATS
Si no tiene la AWS CLI instalada, abra la consola de AWS IoT. Desde el panel de navegación, elija
Manage (Administrar) y, a continuación, Things (Cosas). Elija la cosa IoT para su Raspberry Pi y, a
continuación, elija Interact (Interactuar). Su punto de enlace se muestra en la sección HTTPS de la
página de detalles de la cosa.
El puerto en el que escucha el agente de mensajes de AWS IoT
Siempre es el 8883.
El nombre del objeto de IoT
Es el nombre utilizado al registrar el Raspberry Pi en AWS IoT.

El AWS IoT Device SDK para JavaScript contiene varios ejemplos en el directorio aws-iot-device-
sdk-js/examples. Le recomendamos que empiece por device-example.js. Este ejemplo se
ejecuta en dos modos. En el modo 1, se suscribe al tema de MQTT, topic_1, y publica un mensaje
cada 4 segundos en topic_2. En el modo 2, se suscribe al tema topic_2 y publica un mensaje cada
4 segundos en topic_1. Puede ejecutar dos instancias de device-example.js (una en el modo 1 y
otra en el modo 2) y ver los mensajes que se envían y se reciben.
En el directorio aws-iot-device-sdk-js/examples, ejecute el siguiente comando para iniciar una

instancia del ejemplo:
node device-example -k "../certs/private.pem.key" -c "../certs/device.pem.crt" -i "raspberry-pi-1" -a "../

certs/Amazon-root-CA-1" -H "<your-iot-endpoint>" -p 8883 -T "your-thing-name" --test-mode 1
83
Inicie otra instancia de device-example.js ejecutando en el modo 2:
node device-example -k "../certs/private.pem.key" -c "../certs/device.pem.crt" -i "raspberry-pi-2" -a "../

certs/Amazon-root-CA-1" -H "<your-iot-endpoint>" -p 8883 -T "your-thing-name" --test-mode 2
Important
Asegúrese de que utiliza distintos ID de cliente al ejecutar las dos instancias de device-
example.js. No es posible conectar dos clientes (dispositivos o aplicaciones) a AWS IoT
utilizando el mismo ID de cliente. Se termina la conexión del primer cliente y se establece la
conexión del segundo cliente.
El nombre del objeto únicamente es importante cuando se crea una política específica de un
objeto de IoT. En el tutorial de introducción a AWS IoT, no se crea una política de este tipo, por lo
que puede utilizar el mismo nombre de objeto para las dos instancias.
Su Raspberry Pi ya está conectado a AWS IoT mediante AWS IoT SDK for JavaScript.
Si las dos instancias se ejecuten correctamente, la salida de la instancia que se ejecuta en el modo 1 debe
tener el siguiente aspecto:
substituting 250ms dely for truems...

connect
message topic_1 {"mode1Process":1}
...
La salida de la instancia que se ejecuta en el modo 2 debe tener el siguiente aspecto:
substituting 250ms dely for truems...

connect
...
Si el ejemplo no se ejecuta correctamente, intente agregar la opción -d para mostrar información de

depuración.
84
Monitorización de la humedad del
suelo con AWS IoT y Raspberry Pi
Otros tutoriales de AWS IoT

Los tutoriales de esta sección le muestran cómo utilizar varios servicios de AWS IoT juntos para realizar
una tarea específica. Estos tutoriales se centran más en la integración de los servicios que en ofrecer un
recorrido exhaustivo de las características de AWS IoT. Los tutoriales de esta sección pueden basarse el
uno sobre el otro para mostrarle cómo comenzar poco a poco y desarrollar sus soluciones a medida que
sus necesidades comerciales cambien o crezcan.
Cada tutorial incluye una lista de requisitos previos, incluido hardware específico. Siempre que sea posible,
los tutoriales proporcionan alternativas si no tiene todo el hardware necesario.
Monitorización de la humedad del suelo con AWS

IoT y Raspberry Pi
En este tutorial se muestra cómo utilizar un Raspberry Pi, un sensor de humedad, e AWS IoT para
monitorizar el nivel de humedad del suelo de una planta o un terreno. El Raspberry Pi ejecuta código que
lee el nivel de humedad y la temperatura del sensor y, a continuación, envía los datos a AWS IoT. Puede
crear una regla en AWS IoT que envíe un correo electrónico a una dirección suscrita a un tema de Amazon
SNS cuando el nivel de humedad caiga por debajo de un umbral.
Contenido
• Requisitos previos (p. 85)
• Configuración de AWS IoT (p. 85)
• Cree la política de AWS IoT. (p. 86)
• Creación de la clave privada, certificado y objeto de AWS IoT (p. 87)
• Cree un tema de Amazon SNS y una suscripción. (p. 88)
• Creación de una regla de AWS IoT para enviar un correo electrónico (p. 88)
• Configuración del dispositivo Raspberry Pi y el sensor de humedad (p. 89)
Requisitos previos
Para completar este tutorial, se necesita lo siguiente:
• Una cuenta de AWS.

• Un usuario de IAM con permisos de administrador.
• Un equipo de desarrollo con Windows, macOS, Linux o Unix para obtener acceso a la consola de AWS
IoT.
• Un Raspberry Pi 3B o 4B con Raspbian Buster. Para ver instrucciones de instalación, consulte
Instalación de imágenes del sistema operativo en el sitio web de Rasberry Pi.
• Un monitor, teclado, ratón y conexión de red wifi o Ethernet para su Raspberry Pi.
• Un sensor de humedad compatible con Raspberry Pi. El sensor utilizado en este tutorial es un sensor de
humedad capacitivo Adafruit STEMMA I2C con un conector hembra de 4 clavijas JST.
Configuración de AWS IoT

Para completar este tutorial, debe crear los siguientes recursos. Para conectar un dispositivo a AWS IoT,
debe crear un objeto de IoT, un certificado de dispositivo y una política de AWS IoT.
85
• Un objeto de AWS IoT.
Un objeto representa un dispositivo físico (en este caso, su Rasberry Pi) e incluye metadatos estáticos
sobre el dispositivo.
• Un certificado de dispositivo.
Todos los dispositivos deben tener un certificado de dispositivo para conectarse a AWS IoT y
autenticarse con el mismo.
• Una política de AWS IoT.
Cada certificado de dispositivo tiene una o varias políticas de AWS IoT asociadas a él. Estas políticas
determinan a qué recursos de AWS IoT puede obtener acceso el dispositivo.
• Un certificado de CA raíz de AWS IoT.
Los dispositivos y otros clientes utilizan un certificado de CA raíz de AWS IoT para autenticar el servidor
de AWS IoT con el que se están comunicando. Para obtener más información, consulte Autenticación
del servidor (p. 124).
• Una regla de AWS IoT.
Una regla incluye una consulta y una o varias acciones de regla. La consulta extrae datos de los
mensajes del dispositivo para determinar si los datos de los mensajes deben procesarse. La acción de
regla especifica qué hacer si los datos coinciden con la consulta.
• Un tema de Amazon SNS y una suscripción a un tema.
La regla escucha los datos de humedad del dispositivo Raspberry Pi. Si el valor está por debajo de
un umbral, envía un mensaje al tema de Amazon SNS. Amazon SNS envía dicho mensaje a todas las
direcciones de correo electrónico suscritas al tema.
Cree la política de AWS IoT.

Cree una política de AWS IoT que permita al dispositivo Raspberry Pi conectarse y enviar mensajes a
AWS IoT.
1. En la consola de AWS IoT, si aparece un botón Get started (Empezar), elíjalo. De lo contrario, en el
panel de navegación, expanda Secure (Seguridad) y, a continuación, elija Policies (Políticas).
2. Si aparece el cuadro de diálogo You don’t have any policies yet (Aún no tiene ninguna política), elija
Create a policy (Crear una política). De lo contrario, seleccione Create.
3. Escriba un nombre para la política de AWS IoT (por ejemplo, MoistureSensorPolicy).
4. En la sección Add statements (Añadir instrucciones), sustituya la política existente por el siguiente
JSON. Sustituya <region> y <account> por su región de AWS y número de cuenta de AWS.
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:<region>:<account>:client/RaspberryPi"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:<region>:<account>:topic/$aws/things/RaspberryPi/shadow/
update",
delete",
86
"arn:aws:iot:<region>:<account>:topic/$aws/things/RaspberryPi/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
update/accepted",
delete/accepted",
"arn:aws:iot:<region>:<account>:topic/$aws/things/RaspberryPi/shadow/get/
accepted",
update/rejected",
delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:<region>:<account>:topicfilter/$aws/things/RaspberryPi/shadow/
update/accepted",
delete/accepted",
get/accepted",
update/rejected",
delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:<region>:<account>:thing/RaspberryPi"
}
]
}
5. Seleccione Create (Crear).
Creación de la clave privada, certificado y objeto de AWS IoT

Cree un objeto en el registro de AWS IoT para representar su Raspberry Pi.
1. En la consola de AWS IoT, en el panel de navegación, elija Manage (Administrar) y, a continuación,

seleccione Things (Objetos).
2. Si aparece el cuadro de diálogo You don't have any things yet (Aún no tiene ningún objeto), elija
Register a thing (Registrar un objeto). De lo contrario, seleccione Create.
4. En la página Add your device to the device registry (Añadir su dispositivo al registro de dispositivos),
escriba un nombre para el objeto de IoT (por ejemplo, RaspberryPi) y, a continuación, elija Next
(Siguiente). No puede modificar el nombre de un objeto una vez creado. Para cambiar el nombre
87
de un objeto, debe crear otro objeto nueva, asignarle el nuevo nombre y eliminar después el objeto
anterior.
5. En la página Añadir un certificado para el objeto, elija Crear certificado.
6. Elija los enlaces Download (Descargar) para descargar el certificado, la clave privada y el certificado
de CA raíz.
Important
Esta es la única vez que puede descargar el certificado y la clave privada.
7. Elija Activate.
8. Elija Asociar una política.
9. En Add a policy for your thing (Añadir una política al objeto), elija MoistureSensorPolicy y, a
continuación, seleccione Register Thing (Registrar objeto).
Cree un tema de Amazon SNS y una suscripción.

Cree un tema de Amazon SNS y una suscripción.
1. En la consola de AWS IoT, elija Services (Servicios), escriba SNS y, a continuación, seleccione Simple
Notification Service (Servicio de notificación sencillo).
2. En el panel de navegación, elija Topics (Temas) y, a continuación, seleccione Create topic (Crear
tema).
3. Escriba un nombre para el tema (por ejemplo, MoistureSensorTopic).
4. Escriba un nombre de visualización para el tema (por ejemplo, Moisture Sensor Topic). Este es
el nombre que se muestra para el tema en la consola de Amazon SNS.
5. Elija Create new topic (Crear nuevo tema).
6. En la página de detalles del tema de Amazon SNS, elija Create subscription (Crear suscripción).
7. En Protocol (Protocolo), elija Email (Correo electrónico).
8. En Punto de enlace, introduzca su dirección de correo electrónico.
9. Seleccione Create subscription.
10. Abra su cliente de correo electrónico y busque un mensaje con el asunto MoistureSensorTopic.
Abra el correo electrónico y haga clic en el enlace Confirm subscription (Confirmar suscripción).
Important
No recibirá ninguna alerta por correo electrónico de este tema de Amazon SNS hasta que
confirme la suscripción.
Debería recibir un mensaje de correo electrónico con el texto que escribió.
Creación de una regla de AWS IoT para enviar un correo

electrónico
Una regla de AWS IoT define una consulta y una o varias acciones que se deben realizar cuando se recibe
un mensaje de un dispositivo. El motor de reglas de AWS IoT escucha los mensajes enviados por los
dispositivos y utiliza los datos de los mensajes para determinar si se debe realizar alguna acción. Para
obtener más información, consulte Reglas para AWS IoT (p. 285).
En este tutorial el dispositivo Raspberry Pi publica mensajes en aws/things/RaspberryPi/shadow/

update. Se trata de un tema de MQTT interno utilizado por los dispositivos y el servicio Thing Shadow. El
Raspberry Pi publica mensajes que tienen el siguiente formato:
88
Raspberry Pi y el sensor de humedad
"reported": {
"moisture" : <moisture-reading>,
"temp" : <temperature-reading>
}
}
Puede crear una consulta que extraiga los datos de humedad y temperatura del mensaje entrante.
También puede crear una acción de Amazon SNS que tome los datos y los envíe a los suscriptores del
tema de Amazon SNS si la lectura de la humedad está por debajo de un valor de umbral.
1. En la consola de AWS IoT, en el panel de navegación, elija Act (Actuar). Si aparece el cuadro de
diálogo You don't have any rules yet (Aún no tiene ninguna regla), elija Create a rule (Crear una regla).
De lo contrario, seleccione Create.
2. En la página Create a rule (Crear una regla), introduzca un nombre para la regla (por ejemplo,
MoistureSensorRule).
3. En Description (Descripción), proporcione una breve descripción de esta regla, (por ejemplo, Sends
an alert when soil moisture level readings are too low).
4. En Rule query statement (Instrucción de consulta de regla), elija SQL versión 2016-03-23 e introduzca
la siguiente instrucción de consulta SQL de AWS IoT:
SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE

state.reported.moisture < 400
Esta instrucción activa la acción de la regla cuando la lectura de moisture es menor que 400.
Note
Es posible que tenga que utilizar un valor diferente. Una vez que el código se ejecute en el
dispositivo Raspberry Pi, si toca el sensor, lo coloca en agua o en una maceta, podrá ver los
valores que se obtienen del sensor.
5. En Set one or more actions (Definir una o varias acciones), elija Add action (Añadir acción).
6. En la página Seleccionar una acción, elija Enviar un mensaje como una notificación push SNS.
7. Desplácese hasta la parte inferior de la página y, a continuación, elija Configure action (Configurar
acción).
8. En la página Configure action (Configurar acción), en SNS target (Objetivo de SNS), elija Select
(Seleccionar) y, a continuación, seleccione LowMoistureTopic.
9. En Formato del mensaje, elija RAW.
10. En Choose or create a role to grant AWS IoT access to perform this action (Elija o cree un rol para
conceder acceso a AWS IoT para que realice esta acción), elija Create role (Crear rol). Introduzca un
nombre para el rol (por ejemplo, LowMoistureTopicRole) y, a continuación, elija Create role (Crear
rol).
12. Elija Create rule.
Configuración del dispositivo Raspberry Pi y el sensor

de humedad
Inserte la tarjeta micro SD en el Raspberry Pi, conecte el monitor, el teclado, el ratón y, si no utiliza una
conexión wifi, el cable Ethernet. No conecte aún el cable de alimentación.
89
Conecte el cable puente JST al sensor de humedad. El otro lado del puente tiene cuatro cables:
• Verde: I2C SCL

• Blanco: I2C SDA
• Rojo: alimentación (3,5 V)
• Negro: conexión a tierra
Sujete el dispositivo Raspberry Pi con el enchufe hembra Ethernet a la derecha. En esta orientación hay
dos filas de clavijas GPIO en la parte superior. Conecte los cables del sensor de humedad a la fila inferior
de clavijas en el orden que se indica a continuación. Comenzando por la clavija del extremo izquierdo,
conecte el cable rojo (alimentación), el cable blanco (SDA) y el cable verde (SCL). Omita una clavija y, a
continuación, conecte el cable negro (conexión a tierra). Para obtener más información, consulte Cableado
de equipos Python.
Conecte el cable de alimentación al dispositivo Raspberry Pi y conecte el otro extremo a una toma de
corriente para encenderlo.
Configuración del dispositivo Raspberry Pi
1. En Welcome to Raspberry Pi (Bienvenido a Raspberry Pi), elija Next (Siguiente).

2. Elija el país, el idioma, la zona horaria y la distribución del teclado. Seleccione Siguiente.
3. Escriba una contraseña para el dispositivo Raspberry Pi y, a continuación, elija Next (Siguiente).
4. Elija una red wifi y, a continuación, elija Next (Siguiente). Si no utiliza una red wifi, elija Skip (Omitir).
5. Elija Next (Siguiente) para comprobar si hay actualizaciones de software. Cuando se completen las
actualizaciones, elija Restart (Reiniciar) para reiniciar el dispositivo Raspberry Pi.
Una vez que se inicie el dispositivo Raspberry Pi, habilite la interfaz de I2C.
1. En la esquina superior izquierda del escritorio de Raspbian, haga clic en el icono de Raspberry, elija
Preferences (Preferencias) y, a continuación, elija Raspberry Pi Configuration (Configuración de
Raspberry Pi).
2. En la pestaña Interfaces (Interfaces), en I2C, elija Enable (Habilitar).
3. Seleccione OK.
Las bibliotecas del sensor de humedad Adafruit STEMMA se han escrito para CircuitPython. Para
ejecutarlas en un dispositivo Raspberry Pi, debe instalar la última versión de Python 3.
1. Ejecute los siguientes comandos desde un símbolo del sistema para actualizar el software del
dispositivo Raspberry Pi:
sudo apt-get update
sudo apt-get upgrade

2. Ejecute el siguiente comando para actualizar la instalación de Python 3:
sudo pip3 install --upgrade setuptools

3. Ejecute el siguiente comando para instalar las bibliotecas de GPIO de Raspberry Pi:
pip3 install RPI.GPIO

4. Ejecute el siguiente comando para instalar las bibliotecas de Adafruit Blinka:
pip3 install adafruit-blinka
90
Para obtener más información, consulte la sección Installing CircuitPython Libraries on Raspberry Pi.
5. Ejecute el siguiente comando para instalar las bibliotecas de Adafruit Seesaw:
sudo pip3 install adafruit-circuitpython-seesaw

6. Ejecute el siguiente comando para instalar el SDK de dispositivos AWS IoT para Python:
pip3 install AWSIoTPythonSDK
El dispositivo Raspberry Pi ahora tiene todas las bibliotecas necesarias. Cree un archivo denominado
moistureSensor.py y copie el siguiente código Python en el archivo:
from adafruit_seesaw.seesaw import Seesaw

from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA
import logging
import time
import json
import argparse
import busio
# Shadow JSON schema:

#
# {
# "state": {
# "desired":{
# "moisture":<INT VALUE>,
# "temp":<INT VALUE>
# }
# }
# }
# Function called when a shadow is updated

def customShadowCallback_Update(payload, responseStatus, token):
# Display status and data from update request

if responseStatus == "timeout":
print("Update request " + token + " time out!")
if responseStatus == "accepted":
payloadDict = json.loads(payload)
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Update request with token: " + token + " accepted!")
print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Update request " + token + " rejected!")
# Function called when a shadow is deleted

def customShadowCallback_Delete(payload, responseStatus, token):
# Display status and data from delete request

if responseStatus == "timeout":
print("Delete request " + token + " time out!")
if responseStatus == "accepted":
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Delete request with token: " + token + " accepted!")
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
91
if responseStatus == "rejected":
print("Delete request " + token + " rejected!")
# Read in command-line parameters

def parseArgs():
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host",
help="Your AWS IoT custom endpoint")
parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath",
help="Root CA file path")
parser.add_argument("-c", "--cert", action="store", dest="certificatePath",
help="Certificate file path")
parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private
key file path")
parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port
number override")
parser.add_argument("-n", "--thingName", action="store", dest="thingName",
default="Bot", help="Targeted thing name")
parser.add_argument("-id", "--clientId", action="store", dest="clientId",
default="basicShadowUpdater", help="Targeted client id")
args = parser.parse_args()
return args
# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Parse command line arguments

args = parseArgs()
if not args.certificatePath or not args.privateKeyPath:

parser.error("Missing credentials for authentication.")
exit(2)
# If no --port argument is passed, default to 8883

if not args.port:
args.port = 8883
# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath,
args.certificatePath)
# AWSIoTMQTTShadowClient connection configuration

myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec
# Initialize Raspberry Pi's I2C interface

i2c_bus = busio.I2C(SCL, SDA)
92
# Intialize SeeSaw, Adafruit's Circuit Python library

ss = Seesaw(i2c_bus, addr=0x36)
# Connect to AWS IoT

myAWSIoTMQTTShadowClient.connect()
# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName,
True)
# Delete current shadow JSON doc

deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)
# Read data from moisture sensor and update shadow

while True:
# read moisture level through capacitive touch pad

moistureLevel = ss.moisture_read()
# read temperature from the temperature sensor

temp = ss.get_temp()
# Display moisture and temp readings

print("Moisture Level: {}".format(moistureLevel))
print("Temperature: {}".format(temp))
# Create message payload

payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}
# Update shadow
deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
time.sleep(1)
Guarde el archivo en un lugar donde pueda encontrarlo. Ejecute moistureSensor.py desde la línea de
comandos con los siguientes parámetros:
endpoint
Su punto de enlace de AWS IoT personalizado. Para obtener más información, consulte API RESTful
de sombra de dispositivo (p. 398).
rootCA
La ruta completa al certificado de CA raíz de AWS IoT.

cert
La ruta completa al certificado de dispositivos de AWS IoT.

clave
La ruta completa a la clave privada del certificado de dispositivos de AWS IoT.

thingName
El nombre del objeto (en este caso, RaspberryPi).

clientId
El ID de cliente de MQTT. Use RaspberryPi.
La línea de comandos debería tener este aspecto:
python3 moistureSensor.py --endpoint <your-endpoint> --rootCA ~/certs/

AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/
raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi
93
Pruebe a tocar el sensor, colocarlo en una maceta o ponerlo en un vaso de agua para ver cómo
responde a distintos niveles de humedad. Si es necesario, puede cambiar el valor del umbral en la opción
MoistureSensorRule. Cuando la lectura del sensor de humedad está por debajo del valor especificado
en la instrucción de consulta SQL de la regla, AWS IoT publica un mensaje en el tema de Amazon SNS.
Debería recibir un mensaje de correo electrónico que incluya los datos de humedad y temperatura.
Una vez que haya verificado la recepción de mensajes de correo electrónico de Amazon SNS, pulse
CTRL + C para detener el programa Python. Es poco probable que el programa Python envíe suficientes
mensajes para incurrir en gastos, pero se recomienda detener el programa cuando haya terminado.
94
Cómo administrar objetos con el registro
Administración de dispositivos con

AWS IoT
AWS IoT proporciona un registro que le ayuda a administrar los objetos. Un objeto es una representación
de un dispositivo concreto o de una entidad lógica. Puede ser un dispositivo físico o un sensor (por
ejemplo, una bombilla o un interruptor 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 con AWS IoT, pero que está
relacionada con otros dispositivos que sí lo están (por ejemplo, un automóvil con sensores de motor o un
panel de control).
La información sobre un objeto se almacena en el registro en forma de datos JSON. A continuación, se

muestra un ejemplo de objeto:
{
"version": 3,
"thingName": "MyLightBulb",
"defaultClientId": "MyLightBulb",
"thingTypeName": "LightBulb",
"attributes": {
"model": "123",
"wattage": "75"
}
}
Los objetos se identifican por su nombre. También pueden tener atributos, que son pares nombre-
valor que puede utilizar para almacenar información acerca del objeto, como su número de serie o su
fabricante.
En un caso de uso de dispositivo típico, se utiliza el nombre del objeto como ID de cliente MQTT
predeterminado. Aunque no es obligatorio establecer un mapeo entre el nombre de un objeto del registro y
el uso que hace de los ID de cliente MQTT, los certificados o el estado de sombra, le recomendamos que
elija un nombre de objeto y lo utilice como ID de cliente MQTT, tanto para el registro como para el servicio
Device Shadow. De esta forma, puede organizar su flota de IoT más fácilmente, sin perder la flexibilidad
del modelo de certificado de dispositivo subyacente o las sombras.
No es necesario crear un objeto en el registro para conectar un dispositivo a AWS IoT. Al añadir objetos al
registro, podrá administrar y buscar dispositivos con más facilidad.
Cómo administrar objetos con el registro

La consola de AWS IoT o la CLI de AWS se utilizan para interactuar con el registro. En las secciones
siguientes se muestra cómo utilizar la CLI para trabajar con el registro.
Crear objeto
A continuación, se muestra cómo se utiliza el comando CreateThing de AWS IoT en la CLI para crear
un objeto: No se puede modificar el nombre de un objeto una vez creado. Para cambiar el nombre de un
objeto, debe crear otro objeto nueva, asignarle el nuevo nombre y eliminar después el objeto anterior.
95
Lista de objetos
$ aws iot create-thing --thing-name "MyLightBulb" --attribute-payload "{\"attributes\":

{\"wattage\":\"75\", \"model\":\"123\"}}"
El comando CreateThing muestra el nombre y el ARN (nombre de recurso de Amazon) del nuevo objeto:
{
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/MyLightBulb",
"thingName": "MyLightBulb"
"thingId": "12345678abcdefgh12345678ijklmnop12345678"
}
Note
No es recomendable utilizar datos personales en los nombres de objeto.
Lista de objetos
Puede utilizar el comando ListThings para enumerar todos los objetos en su cuenta:
$ aws iot list-things

{
"things": [
{
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
},
{
"attributes": {
"numOfStates":"3"
},
"version": 11,
"thingName": "MyWallSwitch"
}
]
}
Buscar objetos
Puede utilizar el comando DescribeThing para crear una lista de información acerca de un objeto:
$ aws iot describe-thing --thing-name "MyLightBulb"

{
"version": 3,
"thingName": "MyLightBulb",
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/MyLightBulb",
"thingId": "12345678abcdefgh12345678ijklmnop12345678"
"defaultClientId": "MyLightBulb",
"thingTypeName": "StopLight",
"attributes": {
"model": "123",
"wattage": "75"
}
}
96
Buscar objetos
Puede utilizar el comando ListThings para buscar todos los objetos asociados a un nombre de tipo de
objeto:
$ aws iot list-things --thing-type-name "LightBulb"
{
"things": [
{
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MyRGBLight"
},
{
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MySecondLightBulb"
}
]
}
Puede utilizar el comando ListThings para buscar todos los objetos que tienen un atributo con un valor
específico:
$ aws iot list-things --attribute-name "wattage" --attribute-value "75"
{
"things": [
{
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 3,
},
{
"attributes": {
"model": "123",
"wattage": "75"
},
"version": 1,
"thingName": "MyRGBLight"
},
{
"attributes": {
"model": "123",
"wattage": "75"
},
97
Actualización de un objeto
"version": 1,
"thingName": "MySecondLightBulb"
}
]
}
Actualización de un objeto
Puede utilizar el comando UpdateThing para actualizar un objeto. Tenga en cuenta que este comando
solo actualiza los atributos del objeto. El nombre de un objeto no se puede modificar. Para cambiar el
nombre de un objeto, debe crear otro objeto nueva, asignarle el nuevo nombre y eliminar después el objeto
anterior.
$ aws iot update-thing --thing-name "MyLightBulb" --attribute-payload "{\"attributes\":

{\"wattage\":\"150\", \"model\":\"456\"}}"
El comando UpdateThing no genera una salida. Puede utilizar el comando de DescribeThing para ver el
resultado:
$ aws iot describe-thing --thing-name "MyLightBulb"

{
"attributes": {
"model": "456",
"wattage": "150"
},
"version": 2,
}
Eliminación de un objeto
Puede utilizar el comando DeleteThing para eliminar un objeto:
$ aws iot delete-thing --thing-name "MyThing"
Este comando se devuelve correctamente sin error si la eliminación se realiza correctamente o especifica
un objeto que no existe.
Asociar un principal a un objeto

Un dispositivo físico debe tener un certificado X.509 para comunicarse con AWS IoT. Puede asociar el
certificado de un dispositivo con el objeto del registro que representa a dicho dispositivo. Para adjuntar un
certificado a su objeto, utilice el comando AttachThingPrincipal:
$ aws iot attach-thing-principal --thing-name "MyLightBulb" --principal "arn:aws:iot:us-

east-1:123456789012:cert/a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847"
El comando AttachThingPrincipal no genera una salida.
Desvincular un principal de un objeto

Puede utilizar el comando DetachThingPrincipal para desvincular un certificado de un objeto:
98
Tipos de objeto
$ aws iot detach-thing-principal --thing-name "MyLightBulb" --principal "arn:aws:iot:us-

east-1:123456789012:cert/a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847"
El comando DetachThingPrincipal no genera una salida.
Tipos de objeto
Los tipos de objeto le permiten almacenar información descriptiva y de configuración común a todos los
objetos asociados al mismo tipo de objeto. Esto simplifica la administración de objetos en el registro. Por
ejemplo, puede definir un tipo de objeto LightBulb (bombilla). Todos los objetos asociados al tipo de objeto
LightBulb comparten un conjunto de atributos: número de serie, fabricante y potencia. Al crear un objeto
de tipo LightBulb (o cambiar el tipo a LightBulb) puede especificar valores para cada uno de los atributos
definidos en este tipo de objeto.
Aunque los tipos de objeto son opcionales, su uso facilita la detección de objetos.
• Los objetos con un tipo de objeto pueden tener un máximo de 50 atributos.

• Los objetos sin tipo de objeto pueden tener un máximo de tres atributos.
• Los objetos solo se pueden asociar a un tipo de objeto.
• El número de tipos de objetos que puede crear en su cuenta es ilimitado.
Los tipos de objeto son inmutables. No se puede cambiar el nombre de un tipo de objeto después de que
se haya creado. Puede descartar un tipo de objeto, en cualquier momento, para evitar que se le asocien
nuevos objetos. También puede eliminar tipos de objeto que no tengan objetos asociados.
Creación de un tipo de objeto

Puede utilizar el comando CreateThingType para crear un tipo de objeto:
$ aws iot create-thing-type
--thing-type-name "LightBulb" --thing-type-properties

"thingTypeDescription=light bulb type, searchableAttributes=wattage,model"
El comando CreateThingType devuelve una respuesta que contiene el tipo de objeto y su ARN:
{
"thingTypeId": "df9c2d8c-894d-46a9-8192-9068d01b2886",
"thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb"
}
Lista de los tipos de objeto

Puede utilizar el comando ListThingTypes para crear una lista de los tipos de objeto:
$ aws iot list-thing-types
El comando ListThingTypes devuelve una lista de los tipos de objeto definidos en su cuenta de AWS:
99
Descripción de un tipo de objeto
"thingTypes": [
{
"thingTypeProperties": {
"searchableAttributes": [
"wattage",
"model"
],
"thingTypeDescription": "light bulb type"
},
"thingTypeMetadata": {
"deprecated": false,
"creationDate": 1468423800950
}
}
]
}
Descripción de un tipo de objeto

Puede utilizar el comando DescribeThingType para obtener información acerca de un tipo de objeto:
$ aws iot describe-thing-type --thing-type-name "LightBulb"
El comando DescribeThingType devuelve información acerca del tipo especificado:
{
"model",
"wattage"
],
"thingTypeDescription": "light bulb type"
},
"thingTypeId": "df9c2d8c-894d-46a9-8192-9068d01b2886",
"thingTypeArn": "arn:aws:iot:us-west-2:123456789012:thingtype/LightBulb",
"creationDate": 1544466338.399
}
}
Asociación de un tipo de objeto a un objeto

Puede utilizar el comando CreateThing para especificar un tipo de objeto cuando crea un objeto:
$ aws iot create-thing --thing-name "MyLightBulb" --thing-type-name "LightBulb" --

attribute-payload "{\"attributes\": {\"wattage\":\"75\", \"model\":\"123\"}}"
Puede utilizar el comando UpdateThing en cualquier momento para cambiar el tipo de objeto asociado a un
objeto:
$ aws iot update-thing --thing-name "MyLightBulb"

--thing-type-name "LightBulb" --attribute-payload "{\"attributes\":
{\"wattage\":\"75\", \"model\":\"123\"}}"
También puede utilizar el comando UpdateThing para desvincular un objeto de un tipo de objeto.
100
Descartar un tipo de objeto
Descartar un tipo de objeto

Los tipos de objeto son inmutables. No se pueden cambiar una vez que están definidos. Sin embargo,
puede descartar un tipo de objeto para evitar que los usuarios le asocien nuevos objetos. Todos los objetos
que estén asociados al tipo de objeto permanecen igual, sin cambios.
Para descartar un tipo de objeto, utilice el comando DeprecateThingType:
$ aws iot deprecate-thing-type --thing-type-name "myThingType"
Puede utilizar el comando de DescribeThingType para ver el resultado:
$ aws iot describe-thing-type --thing-type-name "StopLight":
{
"wattage",
"numOfLights",
"model"
],
"thingTypeDescription": "traffic light type",
},
"deprecated": true,
"creationDate": 1468425854308,
"deprecationDate": 1468446026349
}
}
Descartar un tipo de objeto es una operación reversible. Puede anular un descarte utilizando la marca --
undo-deprecate con el comando de la CLI DeprecateThingType:
$ aws iot deprecate-thing-type --thing-type-name "myThingType" --undo-deprecate
Puede utilizar el comando de la CLI DescribeThingType para ver el resultado:
$ aws iot describe-thing-type --thing-type-name "StopLight":
{
"thingTypeArn": "arn:aws:iot:us-east-1:123456789012:thingtype/StopLight",
"thingTypeId": "12345678abcdefgh12345678ijklmnop12345678"
"wattage",
"numOfLights",
"model"
],
"thingTypeDescription": "traffic light type"
},
"creationDate": 1468425854308,
}
}
101
Eliminación de un tipo de objeto
Eliminación de un tipo de objeto

Puede eliminar tipos de objeto solo después de que se hayan descartado. Para eliminar un tipo de objeto,
utilice el comando DeleteThingType:
$ aws iot delete-thing-type --thing-type-name "StopLight"
Note
Debe esperar cinco minutos después de descartar un tipo de objeto para poder eliminarlo.
Grupos de objetos estáticos

Los grupos de objetos estáticos permiten administrar varios objetos a la vez clasificándolos en grupos. Los
grupos de objetos estáticos contienen un grupo de objetos que se administran a través de la consola, la
CLI o la API. Por otro lado, los grupos de objetos dinámicos (p. 111) contienen objetos que coinciden
con una consulta especificada. Los grupos de objetos estáticos también pueden contener otros grupos
de objetos estáticos, lo que permite establecer una jerarquía de grupos. Puede asociar una política a un
grupo principal y sus grupos secundarios la heredarán, así como todos los objetos del grupo y los grupos
secundarios. Esto facilita el control de los permisos para un gran número de objetos.
Esto es lo que puede hacer con los grupos de objetos estáticos:
• Crear, describir o eliminar un grupo.

• Añadir un objeto a un grupo o a más de un grupo.
• Quitar un objeto de un grupo.
• Enumerar los grupos que ha creado.
• Enumerar todos los grupos secundarios de un grupo (sus descendientes directos e indirectos).
• Enumerar los objetos de un grupo, incluidos todos los objetos en sus grupos secundarios.
• Enumerar todos los grupos antecesores de un grupo (sus grupos principales directos e indirectos).
• Añadir, eliminar o actualizar los atributos de un grupo. (Los atributos son pares nombre-valor que puede
usar para almacenar información acerca de un grupo).
• Adjuntar una política a un grupo o separarla de él.
• Enumerar las directivas adjuntadas a un grupo.
• Enumerar las políticas heredadas por un objeto (en virtud de las políticas adjuntadas a su grupo o uno
de sus grupos principales).
• Configurar opciones de registro para objetos de un grupo. Consulte Configuración de registros de AWS
IoT (p. 221).
• Crear trabajos que se enviarán y se ejecutarán en cada objeto del grupo y sus grupos secundarios.
Consulte Trabajos (p. 413).
Los grupos de objetos estáticos tienen algunas limitaciones:
• Un grupo puede tener como máximo un grupo principal directo.

• Si un grupo es secundario de otro grupo, debe especificarlo en el momento en que se crea.
• No puede cambiar el principal de un grupo más adelante, así que asegúrese de planificar la jerarquía de
grupos y crear un grupo principal antes de crear los grupos secundarios que contiene.
• El número de grupos a los que puede pertenecer un objeto es limitado.
• No puede añadir un objeto a más de un grupo en la misma jerarquía. (En otras palabras, no puede
agregar un objeto a dos grupos que comparten un principal común).
102
Crear un grupo de objetos estático
• No se puede cambiar el nombre de un grupo.

• Los nombres de grupos de objetos no pueden contener caracteres internacionales, como û, é o ñ.
Asociar políticas a grupos y separarlas de ellos puede mejorar la seguridad de las operaciones de AWS
IoT de una serie de formas significativas. El método por dispositivo de asociar una política a un certificado,
que luego se asocia a un objeto, consume mucho tiempo y dificulta la actualización o cambio rápido de
políticas en una flota de dispositivos. Disponer de una política adjunta al grupo del objeto ahorra pasos
cuando hay que rotar los certificados en un objeto. Además, las políticas se aplican dinámicamente a
objetos cuando cambian la pertenencia a un grupo, por lo que no es necesario volver a crear un conjunto
complejo de permisos cada vez que un dispositivo cambia la pertenencia en un grupo.
Crear un grupo de objetos estático

Utilice el comando CreateThingGroup para crear un grupo de objetos estático:
$ aws iot create-thing-group --thing-group-name LightBulbs
El comando CreateThingGroup devuelve una respuesta que contiene el nombre, el ID y el ARN del grupo
de objetos estático:
{
"thingGroupName": "LightBulbs",
"thingGroupId": "abcdefgh12345678ijklmnop12345678qrstuvwx",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
}
Note
No es recomendable utilizar datos personales en los nombres de grupo de objetos.
A continuación, se muestra un ejemplo que especifica el grupo principal de un grupo de objetos estático
durante su creación:
$ aws iot create-thing-group --thing-group-name RedLights --parent-group-name LightBulbs
Al igual que antes, el comando CreateThingGroup devuelve una respuesta que contiene el nombre, el ID y
el ARN del grupo de objetos:
{
"thingGroupName": "RedLights",
"thingGroupId": "abcdefgh12345678ijklmnop12345678qrstuvwx",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights",
}
Important
Tenga en cuenta las siguientes limitaciones cuando cree jerarquías de grupos de objetos:
• Un grupo de objetos solo puede tener un grupo principal directo.

• El número de grupos secundarios directos que puede tener un grupo de objetos es limitado.
• La profundidad máxima de una jerarquía de grupo es limitada.
• El número de atributos que puede tener un grupo de objetos es limitado. (Los atributos son
pares nombre-valor que puede usar para almacenar información acerca de un grupo). La
longitud de cada nombre de atributo y cada valor también es limitada.
103
Descripción de un grupo de objetos
Descripción de un grupo de objetos

Puede utilizar el comando DescribeThingGroup para obtener información acerca de un grupo de objetos:
$ aws iot describe-thing-group --thing-group-name RedLights
El comando DescribeThingGroup devuelve información acerca del grupo especificado:
{
"thingGroupName": "RedLights",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights",
"thingGroupId": "12345678abcdefgh12345678ijklmnop12345678",
"version": 1,
"thingGroupMetadata": {
"parentGroupName": "Lights",
"rootToParentThingGroups": [
{
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/ShinyObjects",
"groupName": "ShinyObjects"
},
{
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs",
"groupName": "LightBulbs"
}
]
},
"thingGroupProperties": {
"attributePayload": {
"attributes": {
"brightness": "3400_lumens"
},
},
"thingGroupDescription": "string"
},
}
Agregar un objeto a un grupo de objetos estático

Puede utilizar el comando AddThingToThingGroup para agregar un objeto a un grupo de objetos estático:
$ aws iot add-thing-to-thing-group --thing-name MyLightBulb --thing-group-name RedLights
El comando AddThingToThingGroup no genera una salida.

Important
Puede añadir un objeto a un máximo de 10 grupos. Sin embargo, no puede añadir un objeto a
más de un grupo en la misma jerarquía. (En otras palabras, no puede añadir un objeto a dos
grupos que comparten un grupo principal común).
Si un objeto pertenece al número máximo de grupos de objetos posible y uno o varios de estos
grupos es un grupo de objetos dinámico, puede utilizar la marca overrideDynamicGroups para que
los grupos estáticos tengan prioridad sobre los grupos dinámicos.
Eliminar un objeto de un grupo de objetos estático

Puede utilizar el comando RemoveThingFromThingGroup para quitar un objeto de un grupo:
104
Enumerar los objetos en un grupo de objetos
$ aws iot remove-thing-from-thing-group --thing-name MyLightBulb --thing-group-name

RedLights
El comando RemoveThingFromThingGroup no genera una salida.
Enumerar los objetos en un grupo de objetos

Puede utilizar el comando ListThingsInThingGroup para listar los objetos que pertenecen a un grupo:
$ aws iot list-things-in-thing-group --thing-group-name LightBulbs
El comando ListThingsInThingGroup devuelve una lista de los objetos en el grupo determinado:
{
"things":[
"TestThingA"
]
}
Con el parámetro --recursive, puede enumerar los objetos que pertenecen a un grupo y también los
que están en alguno de sus grupos secundarios:
$ aws iot list-things-in-thing-group --thing-group-name LightBulbs --recursive
{
"things":[
"TestThingA",
"MyLightBulb"
]
}
Note
Esta operación es a largo plazo coherente. En otras palabras, los cambios que se hagan en el
grupo de objetos podrían no reflejarse inmediatamente.
Enumeración de grupos de objetos

Puede usar el comando ListThingGroups para mostrar los grupos de objetos de la cuenta:
$ aws iot list-thing-groups
El comando ListThingGroups devuelve una lista de los grupos de objetos definidos en la cuenta de AWS:
{
"thingGroups": [
{
"groupName": "LightBulbs",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
},
{
"groupName": "RedLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLights"
},
105
Enumeración de grupos de objetos
{
"groupName": "RedLEDLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLEDLights"
},
{
"groupName": "RedIncandescentLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/
RedIncandescentLights"
}
{
"groupName": "ReplaceableObjects",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/ReplaceableObjects"
}
]
}
Utilice los filtros opcionales para enumerar los grupos que tienen un grupo determinado como grupo
principal (--parent-group) o los grupos cuyo nombre comienza por un prefijo determinado (--name-
prefix-filter). El parámetro --recursive le permite listar también todos los grupos secundarios, no
los grupos secundarios directos de un grupo de objetos:
$ aws iot list-thing-groups --parent-group LightBulbs
En este caso, el comando ListThingGroups devuelve una lista de grupos secundarios directos del grupo de
objetos definido en la cuenta de AWS:
{
"childGroups":[
{
}
]
}
Utilice el parámetro --recursive con el comando ListThingGroups para listar todos los grupos
secundarios de un grupo de objetos, no solo un elemento secundario directo:
$ aws iot list-thing-groups --parent-group LightBulbs --recursive
El comando ListThingGroups devuelve una lista de todos los grupos secundarios de un grupo de objetos:
{
"childGroups":[
{
},
{
"groupName": "RedLEDLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RedLEDLights"
},
{
"groupName": "RedIncandescentLights",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/
RedIncandescentLights"
}
]
}
106
Enumerar grupos para un objeto
Note
Esta operación es a largo plazo coherente. En otras palabras, los cambios que se hagan en el
grupo de objetos podrían no reflejarse inmediatamente.
Enumerar grupos para un objeto

Puede utilizar el comando ListThingGroupsForThing para enumerar los grupos los que pertenece un
objeto, incluidos los grupos principales:
$ aws iot list-thing-groups-for-thing --thing-name MyLightBulb
El comando ListThingGroupsForThing devuelve una lista de los grupos de objetos a los que pertenece este
objeto, incluidos los grupos principales:
{
"thingGroups":[
{
"groupName": "LightBulbs",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"
},
{
},
{
"groupName": "ReplaceableObjects",
"groupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/ReplaceableObjects"
}
]
}
Actualizar un grupo de objetos estático

Puede utilizar el comando UpdateThingGroup para actualizar los atributos de un grupo de objetos estático:
$ aws iot update-thing-group --thing-group-name "LightBulbs" --thing-group-properties

"thingGroupDescription=\"this is a test group\", attributePayload=\"{\"attributes
\"={\"Owner\"=\"150\",\"modelNames\"=\"456\"}}"
El comando UpdateThingGroup devuelve una respuesta que contiene el número de versión del grupo
después de la actualización:
{
"version": 4
}
Note
El número de atributos que un objeto puede tener es limitado.
Eliminación de un grupo de objetos

Para eliminar un grupo de objetos, use el comando DeleteThingGroup:
107
Asociar una política a un grupo de objetos estático
$ aws iot delete-thing-group --thing-group-name "RedLights"
El comando DeleteThingGroup no genera una salida.

Important
Si intenta eliminar un grupo de objetos que tenga grupos secundarios de objetos, aparecerá un
error:
A client error (InvalidRequestException) occurred when calling the

DeleteThingGroup
operation: Cannot delete thing group : RedLights when there are still child groups
attached to it.
Debe eliminar los grupos secundarios antes de eliminar el grupo.
Puede eliminar un grupo que tenga objetos secundarios, pero no se seguirán aplicando los permisos
concedidos a los objetos por la pertenencia del grupo. Antes de eliminar un grupo que tenga una política
adjunta, compruebe detenidamente que la eliminación de esos permisos no hará que los objetos del grupo
no funcionen correctamente. Además, tenga en cuenta que los comandos que muestran a qué grupos
pertenece un objeto (por ejemplo, ListGroupsForThing) podrían seguir mostrando el grupo mientras se
actualizan los registros en la nube.
Asociar una política a un grupo de objetos estático

Puede usar el comando AttachPolicy para asociar una política a un grupo de objetos estático y, por
extensión, a todos los objetos de ese grupo y de sus grupos secundarios:
$ aws iot attach-policy \

--target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs" \
--policy-name "myLightBulbPolicy"
El comando AttachPolicy no genera una salida

Important
Puede asociar un número máximo de dos políticas a un grupo.

Note
No es recomendable utilizar datos personales en los nombres de política.
El parámetro --target puede ser un ARN de grupo de objetos (como más arriba), un ARN del certificado
o una identidad de Amazon Cognito. Para obtener más información acerca de las políticas, los certificados
y la autenticación, consulte Autenticación (p. 123).
Desconectar una política de un grupo de objetos

estático
Puede usar el comando DetachPolicy para separar una política de un grupo de objetos y de esa forma, por
extensión, a todos los objetos de ese grupo y a los objetos de cualquiera de sus grupos secundarios:
$ aws iot detach-policy --target "arn:aws:iot:us-west-2:123456789012:thinggroup/LightBulbs"

--policy-name "myLightBulbPolicy"
108
Mostrar las políticas asociadas
a un grupo de objetos estático
El comando DetachPolicy no genera una salida.
Mostrar las políticas asociadas a un grupo de objetos

estático
Puede utilizar el comando ListAttachedPolicies para mostrar las políticas asociadas a un grupo de objetos
estático:
$ aws iot list-attached-policies --target "arn:aws:iot:us-west-2:123456789012:thinggroup/

RedLights"
El parámetro --target puede ser un ARN de grupo de objetos (como más arriba), un ARN del certificado
o una identidad de Amazon Cognito.
Agregue el parámetro --recursive opcional para incluir también todas las políticas asociadas a los
grupos principales del grupo.
El comando ListAttachedPolicies devuelve una lista de políticas:
{
"policies": [
"MyLightBulbPolicy"
...
]
}
Enumeración de los grupos para una política

Puede utilizar el comando ListTargetsForPolicy para enumerar los destinos, incluidos los grupos, a los que
se adjunta una política:
$ aws iot list-targets-for-policy --policy-name "MyLightBulbPolicy"
Añada el parámetro --page-size number opcional para especificar el número máximo de resultados
que se va a devolver para cada consulta y el parámetro --marker string en las llamadas siguientes
para recuperar el siguiente conjunto de resultados, si lo hubiera.
El comando ListTargetsForPolicy devuelve una lista de destinos y el token que usar para recuperar más
resultados:
{
"nextMarker": "string",
"targets": [ "string" ... ]
}
Obtención de políticas en vigor para un objeto

Puede usar el comando GetEffectivePolicies para mostrar las políticas en vigor de un objeto, incluidas las
políticas asociadas a grupos a los que pertenece el objeto (si el grupo es un grupo principal directo o un
antecesor indirecto):
$ aws iot get-effective-policies \

--thing-name "MyLightBulb" \
109
Prueba de autorización para acciones de MQTT
--principal "arn:aws:iot:us-east-1:123456789012:cert/
a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847"
Utilice el parámetro --principal para especificar el ARN del certificado adjunto al objeto. Si utiliza la
autenticación de identidad de Amazon Cognito, utilice el parámetro --cognito-identity-pool-id y,
opcionalmente, agregue el parámetro --principal para especificar una identidad de Amazon Cognito.
Si especifica solo el --cognito-identity-pool-id, se devuelven las políticas asociadas a ese rol del
grupo de identidades para usuarios sin autenticar. Si usa ambos, se devuelven las políticas asociadas a
ese rol del grupo de identidades para los usuarios autenticados.
El parámetro --thing-name es opcional y puede usarse en lugar del parámetro --principal. Cuando
se utiliza, se devolverán las políticas asociadas a cualquier grupo al que pertenece el objeto y las políticas
asociadas a grupos principales de estos grupos (hasta el grupo raíz en la jerarquía).
El comando GetEffectivePolicies devuelve una lista de políticas:
{
"effectivePolicies": [
{
"policyArn": "string",
"policyDocument": "string",
"policyName": "string"
}
...
]
}
Prueba de autorización para acciones de MQTT

Puede utilizar el comando TestAuthorization para probar si se permite la acción de MQTT para un objeto:
aws iot test-authorization \

--principal "arn:aws:iot:us-east-1:123456789012:cert/
a0c01f5835079de0a7514643d68ef8414ab739a1e94ee4162977b02b12842847" \
--auth-infos "{\"actionType\": \"PUBLISH\", \"resources\": [ \"arn:aws:iot:us-
east-1:123456789012:topic/my/topic\"]}"
Utilice el parámetro --principal para especificar el ARN del certificado adjunto al objeto. Si usa la
autenticación de identidad de Amazon Cognito, especifique una identidad de Cognito como --principal
o use el parámetro --cognito-identity-pool-id, o ambos. (Si especifica solo --cognito-
identity-pool-id, se tienen en cuenta las políticas asociadas a ese rol del grupo de identidades para
usuarios sin autenticar. Si usa ambos, se tienen en cuenta las políticas asociadas a ese rol del grupo de
identidades para los usuarios autenticados.
Especifique una o más acciones de MQTT que desee probar mediante la enumeración de conjuntos de
recursos y tipos de acción que siguen al parámetro --auth-infos. El campo actionType debería
contener "PUBLISH", "SUBSCRIBE", "RECEIVE" o "CONNECT". El campo resources debe contener una
lista de ARN de recursos. Para obtener más información, consulte Políticas de AWS IoT Core (p. 152).
Puede probar los efectos de la adición de políticas mediante la especificación de estas con el parámetro
--policy-names-to-add. También puede probar los efectos de la eliminación de políticas mediante
ellas con el parámetro --policy-names-to-skip.
Puede usar el parámetro --client-id opcional para restringir los resultados.
El comando TestAuthorization devuelve detalles acerca de acciones que se permiten o deniegan para
cada conjunto de consultas --auth-infos especificadas:
110
Grupos de objetos dinámicos
{
"authResults": [
{
"allowed": {
"policies": [
{
}
]
},
"authDecision": "string",
"authInfo": {
"actionType": "string",
"resources": [ "string" ]
},
"denied": {
"explicitDeny": {
"policies": [
{
}
]
},
"implicitDeny": {
"policies": [
{
}
]
}
},
"missingContextValues": [ "string" ]
}
]
}
Grupos de objetos dinámicos

Los grupos de objetos dinámicos actualizan la pertenencia al grupo a través de consultas de búsqueda.
Los grupos de objetos dinámicos permiten cambiar la forma en que se interactúa con los objetos en
función de sus datos de conectividad, registro o sombra.
Puesto que los grupos de objetos dinámicos están vinculados al índice de su flota, debe habilitar el
servicio de indexación de flotas para utilizarlos. Puede obtener una vista previa de los objetos en un
grupo de objetos dinámico antes de crear el grupo con una consulta de búsqueda de indexación de
flotas. Para obtener más información, consulte Servicio de indexación de flota (p. 559) y Sintaxis de la
consulta (p. 575).
Puede especificar un grupo de objetos dinámico como destino para un trabajo. Solo realizan el trabajo los
objetos que cumplen los criterios que definen el grupo de objetos dinámico.
Por ejemplo, supongamos que desea actualizar el firmware en sus dispositivos, pero, para reducir la
posibilidad de que la actualización se interrumpa, solo desea actualizar el firmware en los dispositivos
con duración de la batería superior al 80 %. Puede crear un grupo de objetos dinámico que solo incluya
dispositivos con una duración de la batería por encima del 80 %, y puede utilizar el grupo de objetos
dinámico como destino para el trabajo de actualización del firmware. Recibirán la actualización del
111
Crear un grupo de objetos dinámico
firmware solo los dispositivos que cumplan con sus criterios de duración de la batería. A medida que
los dispositivos alcancen el 80 % de duración de la batería, estos se van añadiendo al grupo de objetos
dinámico y reciben la actualización del firmware.
Para obtener más información sobre cómo especificar grupos de objetos como destinos de trabajos,
consulte CreateJob (p. 454).
Los grupos de objetos dinámicos se diferencian de los grupos de objetos estáticos como sigue:
• La pertenencia de un objeto no se define de forma explícita. Para crear un grupo de objetos dinámico,
debe definir una cadena de consulta que defina la pertenencia a un grupo.
• Los grupos de objetos dinámicos no pueden formar parte de una jerarquía.
• Los grupos de objetos dinámicos no pueden tener políticas aplicadas.
• Puede utilizar un conjunto diferente de comandos para crear, actualizar y eliminar grupos de objetos
dinámicos. Para el resto de operaciones, para interactuar con grupos de objetos dinámicos se pueden
usar los mismos comandos que se utilizan para interactuar con grupos de objetos estáticos.
• El número de grupos dinámicos que puede tener una sola cuenta es limitado.
Para obtener más información acerca de los grupos de objetos estáticos, consulte Grupos de objetos
estáticos (p. 102).
Por ejemplo, suponga que creamos un grupo dinámico que contiene todas las salas de un almacén cuya
temperatura es superior a 60 grados Fahrenheit. Cuando la temperatura de una sala sea 61 grados o
superior, esta sala se añade al grupo de objetos dinámico RoomTooWarm. Todas las salas del grupo de
objetos dinámico RoomTooWarm tienen encendidos los ventiladores. Cuando la temperatura de una sala
cae a 60 grados o menos, se elimina del grupo de objetos dinámico y se apaga su ventilador.
Crear un grupo de objetos dinámico

Utilice el comando CreateDynamicThingGroup para crear un grupo de objetos dinámico. Para crear un
grupo de objetos dinámico para el escenario de la sala demasiado caliente, utilizaría el comando create-
dynamic-thing-group de la CLI:
$ aws iot create-dynamic-thing-group --thing-group-name "RoomTooWarm" --query-string

"attributes.temperature>60"
Note
No es recomendable utilizar datos personales en los nombres de grupo de objetos dinámico.
El comando CreateDynamicThingGroup devuelve una respuesta que contiene el nombre del índice, la
cadena de consulta, la versión de la consulta, el nombre del grupo de objetos, el ID del grupo de objetos y
el ARN del grupo de objetos:
{
"indexName": "AWS_Things",
"queryVersion": "2017-09-30",
"thingGroupName": "RoomTooWarm",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RoomTooWarm",
"queryString": "attributes.temperature>60\n",
"thingGroupId": "abcdefgh12345678ijklmnop12345678qrstuvwx"
}
El grupo de objetos dinámico no se crea de manera instantánea. Reponer un grupo de objetos dinámico
lleva tiempo. Cuando se crea un grupo de objetos dinámico, el estado del grupo se establece en
112
Describir un grupo de objetos dinámico
BUILDING. Cuando termina el proceso de reposición, el estado cambia a ACTIVE. Para comprobar el
estado del grupo de objetos dinámico, utilice el comando DescribeThingGroup.
Describir un grupo de objetos dinámico

Utilice el comando DescribeThingGroup para obtener información acerca de un grupo de objetos dinámico:
$ aws iot describe-thing-group --thing-group-name "RoomTooWarm"
El comando DescribeThingGroup devuelve información acerca del grupo especificado:
{
"status": "ACTIVE",
"thingGroupName": "RoomTooWarm",
"thingGroupArn": "arn:aws:iot:us-west-2:123456789012:thinggroup/RoomTooWarm",
"queryString": "attributes.temperature>60\n",
"version": 1,
"thingGroupMetadata": {
},
"thingGroupProperties": {},
"queryVersion": "2017-09-30",
"thingGroupId": "84dd9b5b-2b98-4c65-84e4-be0e1ecf4fd8"
}
Al ejecutar DescribeThingGroup en un grupo de objetos dinámico se devuelven atributos específicos de

grupos de objetos dinámicos, como, por ejemplo, queryString y el estado.
El estado de un grupo de objetos dinámico puede tomar los siguientes valores:
ACTIVE
El grupo de objetos dinámico está listo para usarse.

BUILDING
Se está creando el grupo de objetos dinámico y se está procesando la pertenencia de los objetos.
REBUILDING
Se está actualizando la pertenencia al grupo de objetos dinámico tras ajustar la consulta de búsqueda
del grupo.
Note
Tras crear un grupo de objetos dinámico podrá utilizar el grupo, independientemente de su

estado. Solo los grupos de objetos dinámicos con estado ACTIVE incluyen todos los objetos
que coinciden con la consulta de búsqueda para ese grupo de objetos dinámico. Los grupos de
objetos dinámicos con estado BUILDING y REBUILDING podrían no incluir todos los objetos
coincidentes con la consulta de búsqueda.
Actualizar un grupo de objetos dinámico

Utilice el comando UpdateDynamicThingGroup para actualizar los atributos de un grupo de objetos
dinámico, incluida la consulta de búsqueda del grupo. El siguiente comando actualiza la descripción del
grupo de objetos y la cadena de consulta que cambia los criterios de pertenencia a una temperatura > 65:
113
Eliminar un grupo de objetos dinámico
$ aws iot update-dynamic-thing-group --thing-group-name "RoomTooWarm" --thing-group-

properties "thingGroupDescription=\"This thing group contains rooms warmer than 65F.\"" --
query-string "attributes.temperature>65"
El comando UpdateDynamicThingGroup devuelve una respuesta que contiene el número de versión del
grupo después de la actualización:
{
"version": 2
}
Los grupos de objetos dinámicos no se actualizan de manera instantánea. Reponer un grupo de

objetos dinámico lleva tiempo. Cuando un grupo de objetos dinámico se actualiza, su estado cambia a
REBUILDING, al tiempo que el grupo actualiza su pertenencia. Cuando termina el proceso de reposición,
el estado cambia a ACTIVE. Para comprobar el estado del grupo de objetos dinámico, utilice el comando
DescribeThingGroup.
Eliminar un grupo de objetos dinámico

Para eliminar un grupo de objetos dinámico, use el comando DeleteDynamicThingGroup:
$ aws iot delete-dynamic-thing-group --thing-group-name "RoomTooWarm"
El comando DeleteDynamicThingGroup no genera una salida.
Los comandos que muestran a qué grupos pertenece un objeto (por ejemplo,ListGroupsForThing) podrían
seguir mostrando el grupo mientras se actualizan los registros en la nube.
Limitaciones y conflictos
Los grupos de objetos dinámicos comparten estas limitaciones con los grupos de objetos estáticos:
• El número de atributos que puede tener un grupo de objetos es limitado.

• El número de grupos a los que puede pertenecer un objeto es limitado.
• A los grupos de objetos no se les puede cambiar el nombre.
• Los nombres de los grupos de objetos no pueden contener caracteres internacionales, como û, é o ñ.
A la hora de utilizar grupos de objetos dinámicos, tenga en cuenta lo siguiente:
El servicio de indexación de flotas debe estar habilitado.

El servicio de indexación de flotas debe estar habilitado y el proceso de reposición de indexación de
flotas debe haberse completado para poder crear y utilizar grupos de objetos dinámicos. Normalmente se
producirá cierto retraso tras habilitar el servicio de indexación de flotas. El proceso de reposición puede
llevar algún tiempo. Cuantos más objetos haya registrado, más tiempo tardará en completarse el proceso
de reposición. Tras habilitar el servicio de indexación de flotas para grupos de objetos dinámicos, no podrá
deshabilitarlo hasta que se eliminen todos los grupos de objetos dinámicos.
Note
Si tiene los permisos para consultar el índice de la flota, podrá obtener acceso a los datos de los
objetos en toda la flota.
114
El número de grupos de objetos dinámicos es limitado

El número de grupos dinámicos es limitado.
Comandos correctos pueden registrar errores

Cuando se crea o actualiza un grupo de objetos dinámico, es posible que algunos de los objetos válidos
para estar en el grupo dinámico no se hayan agregado todavía. Sin embargo, el comando para crear
o actualizar un grupo de objetos dinámicos sigue ejecutándose correctamente en esos casos, aunque
registran un error y generan una métrica AddThingToDynamicThingGroupsFailed (p. 231).
En el registro de CloudWatch, se crea una entrada de error por cada objeto que no se haya podido agregar
a un grupo de objetos dinámico o que se haya eliminado de un grupo de objetos dinámico para agregarlo
a otro grupo. Cuando un objeto no se puede agregar a un grupo dinámico, también se crea una métrica
AddThingToDynamicThingGroupsFailed (p. 231); sin embargo, una sola métrica puede representar
varias entradas de registro.
Cuando un objeto pasa a ser válido para agregarse a un grupo de objetos dinámico, se tiene en cuenta lo
siguiente:
• ¿Este objeto ya está en el número máximo de grupos posible? (Consulte los límites)
• NO: el objeto se agrega al grupo de objetos dinámico.
• SÍ: ¿el objeto es miembro de algún grupo de objetos dinámico?
• NO: el objeto no se puede agregar al grupo de objetos dinámicos, se registra un error y se genera
una métrica AddThingToDynamicThingGroupsFailed (p. 231).
• SÍ: ¿el grupo de objetos al que se va a unir es anterior a cualquier otro grupo de objetos dinámico
del que el objeto ya sea miembro?
• NO: el objeto no se puede agregar al grupo de objetos dinámicos, se registra un error y se genera
una métrica AddThingToDynamicThingGroupsFailed (p. 231).
• SÍ: elimine el objeto del grupo de objetos dinámicos más reciente del que es miembro, registre
un error y agregue el objeto al grupo de objetos dinámicos. Esto genera un error y una métrica
AddThingToDynamicThingGroupsFailed (p. 231) en el grupo de objetos dinámico del que
se ha eliminado el objeto.
Cuando un objeto de un grupo dinámico ya no satisface la consulta de búsqueda, se elimina del grupo
de objetos dinámicos. Del mismo modo, cuando un objeto se actualiza para satisfacer una consulta de
búsqueda de un grupo de objetos dinámico, se agrega al grupo tal y como se describió anteriormente.
Estas incorporaciones y eliminaciones son normales y no generan entradas en el registro de errores.
Con overrideDynamicGroups habilitado, los grupos estáticos

disfrutan de prioridad sobre los grupos dinámicos.
El número de grupos a los que puede pertenecer un objeto es limitado. Cuando se actualiza la pertenencia
de un objeto utilizando el comando AddThingToThingGroup o UpdateThingGroupsForThing, si se agrega el
parámetro --overrideDynamicGroups, se otorga prioridad a los grupos de objetos estáticos frente a los
dinámicos.
Cuando se agrega un objeto a un grupo de objetos estático, debe tenerse en cuenta lo siguiente:
• ¿El objeto ya es miembro del número máximo de grupos?

• NO: el objeto se agrega al grupo de objetos estático.
• SÍ: ¿el objeto está en algún grupo dinámico?
• NO: el objeto no se puede agregar al grupo de objetos. El comando genera una excepción.
115
• SÍ: ¿se ha habilitado --overrideDynamicGroups?

• NO: el objeto no se puede agregar al grupo de objetos. El comando genera una excepción.
• SÍ: el objeto se elimina del último grupo de objetos dinámico que se creó, se registra un error y
se genera una métrica AddThingToDynamicThingGroupsFailed (p. 231) para el grupo de
objetos dinámico del que se eliminó el objeto. A continuación, el objeto se agrega al grupo de
objetos estáticos.
Los grupos de objetos dinámicos más antiguos tienen prioridad

sobre los más nuevos.
El número de grupos a los que puede pertenecer un objeto es limitado. Cuando un objeto pasa a ser válido
para agregarse a un grupo de objetos dinámico gracias a una operación de creación o actualización pero
ya está en el máximo número de grupos posible, puede eliminarse de otro grupo de objetos dinámico y
agregarse en este. Si necesita más información sobre esto, consulte Comandos correctos pueden registrar
errores (p. 115) y Con overrideDynamicGroups habilitado, los grupos estáticos disfrutan de prioridad
sobre los grupos dinámicos. (p. 115) para ver ejemplos.
Cuando un objeto se elimina de un grupo de objetos dinámico, se registra un error y se genera un evento.
No se pueden aplicar políticas a grupos de cosas dinámicos

Si intenta aplicar una política a un grupo de objetos dinámico, se generará una excepción.
La pertenencia a grupos de objetos dinámicos es coherente a

largo plazo.
Para el registro solo se evalúa el estado final de un objeto. Los estados intermedios se pueden omitir si se
actualizan rápidamente los estados. Evite asociar una regla, un trabajo con un grupo de objetos dinámico
cuya pertenencia dependa de un estado intermedio.
116
Conceptos básicos de etiquetas
Etiquetado de los recursos de AWS

IoT
Para administrar y organizar más fácilmente grupos de objetos, tipos de objetos, reglas de temas, trabajos,
auditorías programadas y perfiles de seguridad, dispone de la opción de asignar sus propios metadatos
en forma de etiquetas a cada uno de estos recursos. En esta sección se describe qué son las etiquetas y
cómo crearlas.
Para ayudarle a administrar los costos relacionados con los objetos puede crear grupos de
facturación (p. 120) con objetos. A continuación, puede asignar etiquetas con sus metadatos a cada
uno de estos grupos de facturación. En esta sección se explican también los grupos de facturación y los
comandos disponibles para crearlos y administrarlos.
Conceptos básicos de etiquetas

Puede utilizar etiquetas para clasificar los recursos de AWS IoT de diversas maneras (por ejemplo, según
su finalidad, su propietario o su entorno). Esto resulta útil cuando tiene muchos recursos del mismo tipo,
ya que le permite identificar rápidamente un recurso específico utilizando las etiquetas asignadas. Cada
etiqueta está formada por una clave y un valor opcional, ambos definidos por el usuario. Por ejemplo,
puede definir un conjunto de etiquetas para los tipos de objetos de modo que le resulte más fácil hacer
un seguimiento de los dispositivos con arreglo al tipo al que pertenecen. Le recomendamos que cree un
conjunto de claves de etiqueta que cumpla sus necesidades para cada tipo de recurso. Mediante el uso de
un conjunto coherente de claves de etiquetas, podrá administrar los recursos más fácilmente.
Puede buscar y filtrar sus recursos en función de las etiquetas que añada o aplique. También puede
utilizar etiquetas de grupo de facturación para categorizar y realizar un seguimiento de los costos. También
puede utilizar etiquetas para controlar el acceso a los recursos según se describe en Uso de etiquetas con
políticas de IAM (p. 118).
Para que sea más fácil usarlas, Tag Editor en la consola de administración de AWS proporciona un método
unificado y centralizado para crear y administrar etiquetas. Para obtener más información, consulte Uso de
Tag Editor en el tema sobre uso de la consola de administración de AWS.
También puede trabajar con etiquetas utilizando la CLI de AWS y la API de AWS IoT. Puede asociar
etiquetas a grupos de objetos, tipos de objetos, reglas de temas, trabajos, perfiles de seguridad y
grupos de facturación en el momento de crearlos utilizando el campo Tags (Etiquetas) en los siguientes
comandos:
• CreateBillingGroup
• CreateDynamicThingGroup
• CreateJob
• CreateOTAUpdate
• CreateScheduledAudit
• CreateSecurityProfile
• CreateStream
• CreateThingGroup
• CreateThingType
• CreateTopicRule
117
Restricciones y limitaciones en las etiquetas
Puede añadir, modificar o eliminar etiquetas para recursos existentes que admitan el uso de etiquetas con
los siguientes comandos:
• TagResource
• ListTagsForResource
• UntagResource
Puede editar las claves y los valores de las etiquetas y también puede eliminar etiquetas de un recurso
en cualquier momento. Puede establecer el valor de una etiqueta como una cadena vacía, pero no puede
asignarle un valor nulo. Si añade una etiqueta con la misma clave que una etiqueta existente en ese
recurso, el nuevo valor sobrescribirá al antiguo. Si elimina un recurso, también se eliminarán todas las
etiquetas que este tenga asociadas.
Restricciones y limitaciones en las etiquetas

Se aplican las siguientes restricciones básicas a las etiquetas:
• Cantidad máxima de etiquetas por recurso: 50.

• Longitud máxima de la clave: 127 caracteres Unicode en UTF-8
• Longitud máxima del valor: 255 caracteres Unicode en UTF-8
• Las claves y los valores de las etiquetas distinguen entre mayúsculas y minúsculas.
• No utilice el prefijo «aws:» en los nombres o valores de las etiquetas. Está reservado para AWS. Los
nombres y valores de etiquetas que tienen este prefijo no se pueden editar. Las etiquetas que tengan
este prefijo no cuentan para el límite de etiquetas por recurso.
• Si se utiliza su esquema de etiquetado en múltiples servicios y recursos, recuerde que otros servicios
podrían tener otras restricciones sobre caracteres permitidos. Los caracteres permitidos son: letras,
espacios y números representables en UTF-8, además de los siguientes caracteres especiales: + - = .
_ : / @.
Uso de etiquetas con políticas de IAM

Puede aplicar permisos de nivel de recurso basados en etiquetas en las políticas de IAM que utiliza con las
acciones de la API de AWS IoT. Esto le ofrece un mejor control sobre los recursos que un usuario puede
crear, modificar o utilizar. Puede utilizar el elemento Condition (también llamado bloque Condition)
junto con las siguientes claves de contexto de condición y valores en una política de IAM para controlar el
acceso del usuario (permiso) en función de las etiquetas de un usuario:
• Utilice aws:ResourceTag/tag-key: tag-value para permitir o denegar acciones de los usuarios

en recursos con etiquetas específicas.
• Utilice aws:RequestTag/tag-key: tag-value para exigir (o impedir) el uso de una etiqueta
específica al realizar una solicitud de API para crear o modificar un recurso que permita etiquetas.
• Utilice aws:TagKeys: [tag-key, ...] para exigir (o impedir) el uso de un conjunto de claves de
etiquetas al realizar una solicitud de API para crear o modificar un recurso que permita etiquetas.
Note
Las claves de contexto de condición y los valores de una política de IAM se aplican únicamente a
las acciones de AWS IoT en las que un identificador de un recurso que se puede etiquetar es un
parámetro obligatorio. Por ejemplo, no se puede permitir ni denegar el uso de DescribeEndpoint
en función de los valores y las claves de contexto de condición porque en esta solicitud no se
hace referencia a ningún recurso que se pueda etiquetar (grupos de objetos, tipos de objetos,
reglas de temas, trabajos o perfiles de seguridad).
118
Uso de etiquetas con políticas de IAM
Para obtener más información sobre el uso de etiquetas, consulte Control del acceso mediante etiquetas
en la Guía del usuario de AWS Identity and Access Management. La sección de referencia de políticas
JSON de IAM de esta guía incluye sintaxis, descripciones y ejemplos detallados de los elementos,
variables y lógica de evaluación de las políticas JSON de IAM.
La siguiente política de ejemplo aplica dos restricciones basadas en etiquetas. Un usuario de IAM
restringido por esta política:
• No se puede dar a un recurso la etiqueta "env=prod" (en el ejemplo, consulte la línea

"aws:RequestTag/env" : "prod").
• No se puede modificar u obtener acceso a un recurso que tiene una etiqueta existente "env=prod" (en el
ejemplo, consulte la línea "aws:ResourceTag/env" : "prod").
{
"Version" : "2012-10-17",
"Statement" : [
{
"Effect" : "Deny",
"Action" : "iot:*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"aws:RequestTag/env" : "prod"
}
}
},
{
"Effect" : "Deny",
"Action" : "iot:*",
"Resource" : "*",
"Condition" : {
"StringEquals" : {
"aws:ResourceTag/env" : "prod"
}
}
},
{
"Effect": "Allow",
"Action": [
"iot:*"
],
"Resource": "*"
}
]
}
También puede especificar varios valores de etiqueta para una determinada clave de etiqueta
encerrándola en una lista, tal y como se muestra a continuación:
"StringEquals" : {
"aws:ResourceTag/env" : ["dev", "test"]
}
Note
Si permite o deniega a los usuarios acceso a recursos en función de etiquetas, debe considerar
denegar explícitamente a los usuarios la posibilidad de agregar estas etiquetas o retirarlas de los
mismos recursos. De lo contrario, es posible que un usuario eluda sus restricciones y obtenga
acceso a un recurso modificando sus etiquetas.
119
Grupos de facturación
Grupos de facturación
AWS IoT no le permite aplicar directamente etiquetas a objetos individuales, pero sí le permite colocar
objetos en grupos de facturación y aplicarles etiquetas. En AWS IoT, la asignación de datos de costos y
uso basados en etiquetas queda limitada a los grupos de facturación.
Dispone de los siguientes comandos:
• AddThingToBillingGroup agrega un objeto a un grupo de facturación.

• CreateBillingGroup crea un grupo de facturación.
• DeleteBillingGroup elimina el grupo de facturación.
• DescribeBillingGroup devuelve información sobre un grupo de facturación.
• ListBillingGroups muestra los grupos de facturación que ha creado.
• ListThingsInBillingGroup muestra los objetos que ha agregado al grupo de facturación indicado.
• RemoveThingFromBillingGroup elimina el objeto indicado del grupo de facturación.
• UpdateBillingGroup actualiza la información sobre el grupo de facturación.
• CreateThing permite especificar un grupo de facturación para el objeto durante su creación.
• DescribeThing devuelve la descripción de un objeto, incluido el grupo de facturación al que este
pertenece, si lo hay.
Visualización de datos de uso y asignación de costos

Puede utilizar etiquetas de grupo de facturación para categorizar y realizar un seguimiento de los costos.
Cuando se aplican etiquetas a grupos de facturación (y también a los objetos que estos incluyen), AWS
genera un informe de asignación de costos como archivo de valores separados por comas (CSV) con
el uso y los costos agregados por las etiquetas. Puede aplicar etiquetas que representen categorías de
negocio (por ejemplo, centros de costos, nombres de aplicación o propietarios) para estructurar los costos
entre diferentes servicios. Para obtener más información sobre el uso de etiquetas para la asignación de
costos, consulte Uso de etiquetas de asignación de costos en la Guía del usuario de Administración de
costos y facturación de AWS.
Note
Para asociar los datos de uso y costos de forma precisa con los objetos que ha colocado en
grupos de facturación, cada dispositivo o cada aplicación debe:
• Haberse registrado como objeto en AWS IoT. Para obtener más información, consulte
Administración de dispositivos con AWS IoT (p. 95).
• Conéctese al agente de mensajes de AWS IoT a través de MQTT utilizando únicamente el
nombre del objeto como ID de cliente. Para obtener más información, consulte Agente de
mensajes de AWS IoT (p. 266).
• Autenticarse mediante un certificado de cliente asociado al objeto.
Dispone de las dimensiones de precios para los grupos de facturación (en función de la actividad de los
objetos asociados al grupo de facturación):
• Conectividad (en función del nombre del objeto utilizado como ID de cliente para conectarse)
• Mensajes (en función de la entrada de mensajes procedentes de un objeto y la salida de mensajes
destinados a un objeto; solo MQTT)
• Operaciones de sombra (en función del objeto cuyo mensaje activó una actualización de sombra)
• Reglas activadas (en función del objeto cuyo mensaje entrante activó la regla; no se aplica a las reglas
activadas por los eventos del ciclo de vida de MQTT)
120
Visualización de datos de uso y asignación de costos
• Actualizaciones de índices de objetos (en función del objeto que se haya agregado al índice)
• Acciones remotas (en función del objeto actualizado)
• Informes de Detect (p. 685) (en función del objeto cuya actividad se notifica).
Los datos de costo y uso basados en etiquetas (y notificados para un grupo de facturación) no reflejan las
siguientes actividades:
• Operaciones de registro de dispositivos (incluidas las actualizaciones de objetos, grupos de objetos y

tipos de objetos). Para obtener más información, consulte Administración de dispositivos con AWS IoT
(p. 95)).
• Actualizaciones de índices de grupos de objetos (al agregar un grupo de objetos)
• Consultas de búsqueda en índices.
• Aprovisionamiento de dispositivos (p. 535).
• Informes de Auditar (p. 580).
121
Seguridad en AWS IoT
Seguridad en AWS IoT

La seguridad en la nube de AWS es la mayor prioridad. Como cliente de AWS, se beneficiará de una
arquitectura de red y un centro de datos diseñados para satisfacer los requisitos de seguridad de las
organizaciones más exigentes.
La seguridad es una responsabilidad compartida entre AWS y usted. El modelo de responsabilidad

compartida la describe como seguridad de la nube y seguridad en la nube:
• Seguridad de la nube – AWS es responsable de proteger la infraestructura que ejecuta servicios de

AWS en la nube de AWS. AWS también proporciona servicios que puede utilizar de forma segura.
Auditores externos prueban y verifican periódicamente la eficacia de nuestra seguridad en el marco
de los programas de conformidad de AWS. Para obtener más información acerca de los programas
de conformidad que se aplican a AWS IoT, consulte Servicios de AWS en el ámbito del programa de
conformidad.
• Seguridad en la nube: su responsabilidad viene determinada por el servicio de AWS que utilice. También
es responsable de otros factores, incluida la confidencialidad de los datos, los requisitos de la empresa y
la legislación y los reglamentos aplicables.
Esta documentación le ayuda a comprender cómo aplicar el modelo de responsabilidad compartida cuando
se utiliza AWS IoT. En los siguientes temas, se le mostrará cómo configurar AWS IoT para satisfacer sus
objetivos de seguridad y conformidad. También puede aprender a utilizar otros servicios de AWS que le
ayudan a supervisar y proteger sus recursos de AWS IoT.
Temas
• Seguridad de AWS IoT (p. 122)
• Autenticación (p. 123)
• Administración de certificados de dispositivo (p. 150)
• Autorización (p. 151)
• Protección de los datos en AWS IoT Core (p. 186)
• Administración de identidad y acceso en AWS IoT (p. 189)
• Registro y monitorización (p. 213)
• Validación de conformidad para AWS IoT Core (p. 214)
• Resiliencia de AWS IoT Core (p. 215)
• Seguridad de la infraestructura en AWS IoT (p. 215)
• Análisis y administración de vulnerabilidades en AWS IoT Core (p. 215)
• Prácticas de seguridad recomendadas para AWS IoT Core (p. 216)
• AWS Training and Certification (p. 219)
Seguridad de AWS IoT

Cada dispositivo o cliente conectado debe tener una credencial con la que interactuar con AWS IoT. Todo
el tráfico hacia y desde AWS IoT se envía de forma segura a través de Transport Layer Security (TLS). Los
mecanismos de seguridad de la nube de AWS protegen los datos cuando estos circulan entre AWS IoT y
otros servicios de AWS.
122
Autenticación
• Es responsable de administrar las credenciales del dispositivo (certificados X.509, credenciales de

AWS, identidades de Amazon Cognito, identidades federadas o tokens de autenticación personalizados)
y las políticas de AWS IoT. Para obtener más información, consulte Administración de claves en
AWS IoT (p. 188). También es el responsable de asignar identidades exclusivas a cada uno de los
dispositivos y de administrar los permisos de cada dispositivo o un grupo de dispositivos.
• Los dispositivos se conectan AWS IoT con certificados X.509 o identidades de Amazon Cognito a
través de una conexión TLS segura. Durante la investigación y el desarrollo, así como para algunas
aplicaciones que realizan llamadas a la API o utilizan WebSockets también puede autenticar usando
usuarios y grupos de IAM o tokens de autenticación personalizados. Para obtener más información,
consulte Usuarios, grupos y roles de IAM (p. 141).
• Al utilizar la autenticación de AWS IoT, el agente de mensajes es responsable de autenticar los
dispositivos, de incorporar los datos del dispositivo de forma segura y de conceder o denegar los
permisos de acceso que especifique para sus dispositivos mediante políticas de AWS IoT.
• Cuando se utiliza la autenticación personalizada, un autorizador personalizado es responsable de
autenticar los dispositivos y de conceder o denegar los permisos de acceso que especifique para los
dispositivos que utilicen políticas de AWS IoT o IAM.
• El motor de reglas de AWS IoT reenvía los datos de los dispositivos a otros dispositivos u otros servicios
de AWS de acuerdo con las reglas que haya definido. Utiliza AWS Identity and Access Management
para transferir datos de forma segura a su destino final. Para obtener más información, consulte
Administración de identidad y acceso en AWS IoT (p. 189).
Autenticación
La autenticación es un mecanismo en el que se verifica la identidad de un cliente o un servidor. La
autenticación del servidor es el proceso en el que los dispositivos u otros clientes aseguran que se
comunican con un punto de enlace de AWS IoT real. La autenticación de cliente es el proceso en el que
los dispositivos u otros clientes se autentican con AWS IoT.
AWS Training and Certification

Realice el siguiente curso para obtener más información sobre la autenticación en AWS IoT: Deep Dive
into AWS IoT Authentication and Authorization.
Información general del certificado X.509

Los certificados X.509 son certificados digitales que utilizan el estándar de infraestructura de clave pública
X.509 para asociar una clave pública a una identidad contenida en un certificado. Los certificados X.509
123
Autenticación del servidor
se generan a través de una entidad de confianza conocida como autoridad de certificación (CA). La CA
administra uno o varios certificados especiales llamados certificados de CA, que utiliza para generar
certificados X.509. Solo la autoridad de certificación tiene acceso a los certificados de CA. Las cadenas de
certificados X.509 se utilizan tanto para la autenticación del servidor por parte de los clientes como para la
autenticación del cliente por parte del servidor.

Cuando el dispositivo u otro cliente intenta conectarse a AWS IoT Core, el servidor de AWS IoT Core
enviará un certificado X.509 que el dispositivo utiliza para autenticar el servidor. La autenticación se lleva
a cabo en la capa TLS mediante la validación de la cadena de certificados X.509 (p. 127). Este es el
mismo método que utiliza el navegador cuando visita una URL HTTPS.
Cuando sus dispositivos u otros clientes establecen una conexión TLS con un punto de enlace de AWS IoT
Core, AWS IoT Core presenta una cadena de certificados que los dispositivos utilizan para verificar si se
están comunicando con AWS IoT Core y no con otro servidor que suplante a AWS IoT Core . La cadena
que se presenta depende de una combinación del tipo de punto de enlace al que se conecta el dispositivo
y del conjunto de cifrado (p. 187) que el cliente y AWS IoT Core negociaron durante el protocolo TLS.
Tipo de punto de enlace

AWS IoT Core admite dos tipos diferentes de puntos de enlace de datos: iot:Data e iot:Data-
ATS. Los puntos de enlace iot:Data presentan un certificado firmado por el certificado de entidad de
certificación raíz de VeriSign Class 3 Public Primary G5. Los puntos de enlace iot:Data-ATS presentan
un certificado de servidor firmado por una entidad emisora de certificados de Amazon Trust Services.
Los certificados presentados por los puntos de enlace de ATS están firmados por Starfield. Algunas
implementaciones de cliente TLS requieren la validación de la raíz de confianza y requieren que los
certificados de CA de Starfield estén instalados en los almacenes de confianza del cliente.
Warning
No se recomienda utilizar un método de fijación de certificados que aplica hash en todo el

certificado (incluido el nombre del emisor, etc.) porque esto provocará un error en la verificación
del certificado porque los certificados ATS que proporcionamos están firmados de forma cruzada
por Starfield y tienen un nombre de emisor diferente.
Use puntos de enlace iot:Data-ATS a menos que su dispositivo requiera certificados de CA de

Symantec o Verisign. Los certificados de Symantec y Verisign han quedado obsoletos y ya no son
compatibles con la mayoría de los navegadores web.
Puede utilizar el comando describe-endpoint para crear el punto de enlace de ATS.
El comando describe-endpoint devuelve un punto de enlace en el formato siguiente.
<account-specific-prefix>.iot.<your-region>.amazonaws.com
La primera vez que se llama a describe-endpoint, se crea un punto de enlace. Todas las llamadas
posteriores a describe-endpoint devuelven el mismo punto de enlace.
En lo que se refiere a la compatibilidad con versiones anteriores, AWS IoT Core sigue siendo compatible
con los puntos de enlace de Symantec. Para obtener más información, consulte How AWS IoT Core is
Helping Customers Navigate the Upcoming Distrust of Symantec Certificate Authorities. Los dispositivos
124
que funcionan en los puntos de enlace de ATS son totalmente interoperables con los dispositivos que
funcionan en los puntos de enlace de Symantec en la misma cuenta y no es necesario volver a registrarlos.
Note
Para ver el punto de enlace iot:Data-ATS en la consola de AWS IoT Core, elija Settings
(Configuración). La consola solo muestra el punto de enlace iot:Data-ATS. De forma
predeterminada, el comando describe-endpoint muestra el punto de enlace iot:Data para
garantizar la compatibilidad con versiones anteriores. Para ver el punto de enlace iot:Data-
ATS, especifique el parámetro --endpointType como en el ejemplo anterior.
Crear un IotDataPlaneClient con el AWS SDK para Java

De forma predeterminada, el AWS SDK para Java - Versión 2 crea un IotDataPlaneClient utilizando
un punto de enlace iot:Data. Para crear un cliente que utilice un punto de enlace iot:Data-ATS, debe
hacer lo siguiente.
• Cree un punto de enlace iot:Data-ATS utilizando la API DescribeEndpoint.

• Especifique ese punto de enlace al crear el IotDataPlaneClient.
En el ejemplo siguiente se realizan ambas operaciones.
public void setup() throws Exception {

IotClient client =
IotClient.builder().credentialsProvider(CREDENTIALS_PROVIDER_CHAIN).region(Region.US_EAST_1).build();
String endpoint = client.describeEndpoint(r -> r.endpointType("iot:Data-
ATS")).endpointAddress();
iot = IotDataPlaneClient.builder()
.credentialsProvider(CREDENTIALS_PROVIDER_CHAIN)
.endpointOverride(URI.create("https://" + endpoint))
.region(Region.US_EAST_1)
.build();
}
Certificados de entidad de certificación para autenticación de

servidor
En función del tipo de punto de enlace de datos que esté utilizando y del conjunto de cifrado que haya
negociado, los certificados de autenticación del servidor de AWS IoT Core estarán firmados por uno de los
siguientes certificados de la entidad de certificación raíz:
Puntos de enlace de VeriSign (heredados)
• Clave RSA de 2048 bits: Certificado de entidad de certificación raíz G5 principal y público de clase 3 de
VeriSign
Puntos de enlace de Amazon Trust Services (preferidos)

Note
Es posible que tenga que hacer clic con el botón derecho en estos enlaces y seleccionar Guardar
enlace como... para guardar estos certificados como archivos.
• Clave RSA de 2048 bits: Amazon Root CA 1-

• Clave RSA de 4096 bits: Amazon Root CA 2. Reservada para futura utilización.
• Clave ECC de 256 bits: Amazon Root CA 3.
• Clave ECC de 384 bits: Amazon Root CA 4. Reservada para futura utilización.
125
Autenticación del cliente
Todos estos certificados tienen firma cruzada del Certificado Starfield Root CA. A partir del lanzamiento de
AWS IoT Core en la región de Asia Pacífico (Mumbai) el 9 de mayo de 2018, todas las regiones nuevas de
AWS IoT Core proporcionan exclusivamente certificados de ATS.
Directrices de autenticación de servidores

Hay muchas variables que pueden afectar a la capacidad de un dispositivo para validar el certificado
de autenticación del servidor de AWS IoT Core. Por ejemplo, los dispositivos pueden tener demasiada
memoria limitada para contener todos los certificados de CA raíz posibles, o los dispositivos pueden
implementar un método no estándar de validación de certificados. Por estas razones, sugerimos seguir
estas directrices:
• Le recomendamos que utilice el punto final ATS e instale todos los certificados de CA raíz de Amazon
compatibles.
• Si no puede almacenar todos estos certificados en su dispositivo y si sus dispositivos no utilizan la
validación basada en ECC, puede omitir los certificados Amazon Root CA 3 y Amazon Root CA 4 de
ECC. Si sus dispositivos no implementan una validación de certificados basada en RSA, puede omitir
los certificados RSA Amazon Root CA 1 y Amazon Root CA 2. Es posible que tenga que hacer clic con
el botón derecho en estos enlaces y seleccionar Guardar enlace como... para guardar estos certificados
como archivos.
• Si tiene problemas de validación de certificados de servidor al conectarse a su punto de enlace de ATS,
intente agregar el certificado Amazon Root CA correspondiente con firma cruzada a su almacén de
confianza. Es posible que tenga que hacer clic con el botón derecho en estos enlaces y seleccionar
Guardar enlace como... para guardar estos certificados como archivos.
• Amazon Root CA 1 con firma cruzada
• Amazon Root CA 2 con firma cruzada: reservado para futura utilización.
• Amazon Root CA 3 con firma cruzada
• Amazon Root CA 4 con firma cruzada: reservado para futura utilización.
• Si experimenta problemas de validación de certificados de servidor, es posible que el dispositivo deba
confiar explícitamente en la CA raíz. Intente agregar el Certificado Starfield Root CA a su almacén de
confianza.
• Si sigue teniendo problemas después de ejecutar los pasos anteriores, póngase en contacto con AWS
Developer Support.
Note
Los certificados de CA tienen una fecha de vencimiento posterior que no pueden usar para
validar un certificado del servidor. Los certificados de CA podrían tener que reemplazarse antes
de su fecha de vencimiento. Asegúrese de que puede actualizar los certificados de entidad de
certificación raíz en todos sus dispositivos o clientes para asegurarse de que la conectividad se
mantenga y esté al día de las prácticas recomendadas de seguridad.
Note
Cuando se conecte a AWS IoT Core en el código del dispositivo, pase el certificado a la API que
está utilizando para realizar la conexión. La API que use variará según el SDK. Para obtener más
información, consulte los SDK de dispositivo de AWS IoT Core (p. 762).

AWS IoT admite tres tipos de entidades principales de identidad para la autenticación de dispositivos o
clientes:
• Certificados de cliente X.509 (p. 127)

• Usuarios, grupos y roles de IAM (p. 141)
126
• Identidades de Amazon Cognito (p. 141)
Estas identidades se pueden usar con dispositivos, aplicaciones móviles, web o de escritorio. Incluso los
puede utilizar un usuario que escribe comandos de interfaz de línea de comandos (CLI) de AWS IoT. Por lo
general, los dispositivos AWS IoT utilizan certificados X.509, mientras que las aplicaciones móviles utilizan
identidades de Amazon Cognito. Las aplicaciones web y de escritorio usan IAM o identidades federadas.
Los comandos de la AWS CLI utilizan IAM. Para obtener más información acerca de las identidades de
IAM, consulte Administración de identidad y acceso en AWS IoT (p. 189).
Certificados de cliente X.509

Los certificados X.509 proporcionan a AWS IoT la capacidad de autenticar las conexiones de clientes y
dispositivos. Los certificados de cliente deben registrarse con AWS IoT antes de que un cliente pueda
comunicarse con AWS IoT. Se puede registrar un certificado de cliente en varias cuentas de AWS en la
misma región de AWS para facilitar el traslado de dispositivos entre sus cuentas de AWS en la misma
región. Para obtener más información, consulte Uso de certificados de cliente X.509 en varias cuentas de
AWS con registro de varias cuentas (p. 128).
Se recomienda que cada dispositivo o cliente reciba un certificado único para permitir acciones de
administración de clientes precisas, incluida la revocación de certificados. Los dispositivos y los
clientes deben ser compatibles con la rotación y la sustitución de certificados para garantizar un buen
funcionamiento cuando los certificados caduquen.
Para obtener información sobre el uso de certificados X.509 para admitir más de unos pocos
dispositivos, consulte Aprovisionamiento de dispositivos (p. 535) para revisar las distintas opciones de
aprovisionamiento y administración de certificados que admite AWS IoT.
AWS IoT admite estos tipos de certificados de cliente X.509:
• Certificados X.509 generados por AWS IoT

• Certificados X.509 firmados por una entidad de certificación registrada con AWS IoT.
• Certificados X.509 firmados por una entidad de certificación que no está registrada con AWS IoT.
En esta sección se describe cómo administrar certificados X.509 en AWS IoT. Puede utilizar la consola de
AWS IoT o la AWS CLI para realizar estas operaciones de certificado:
• Crear certificados de cliente de AWS IoT (p. 129)

• Creación de sus propios certificados de cliente (p. 130)
• Registrar un certificado de cliente (p. 135)
• Activar o desactivar un certificado de cliente (p. 139)
• Revocar un certificado de cliente (p. 140)
Para obtener más información sobre los comandos de la AWS CLI que realizan estas operaciones,
consulte la Referencia de la CLI de AWS IoT.
Uso de certificados de cliente X.509

Los certificados X.509 autentican las conexiones de cliente y dispositivo en AWS IoT. Los certificados
X.509 ofrecen varios beneficios con respecto a otros mecanismos de identificación y autenticación. Los
certificados X.509 permiten usar claves asimétricas con los dispositivos. Por ejemplo, podría forzar claves
privadas en un almacenamiento seguro en un dispositivo para que el material criptográfico confidencial
nunca salga del dispositivo. Los certificados X.509 proporcionan una autenticación del cliente más fiable
que los otros sistemas, como el nombre de usuario y la contraseña o los tokens de portador, ya que la
clave privada jamás abandona el dispositivo.
127
AWS IoT autentica los certificados utilizando el modo de autenticación de cliente del protocolo TLS. La
compatibilidad con TLS está disponible en numerosos lenguajes de programación y sistemas operativos,
y se utiliza generalmente para cifrar datos. En la autenticación de cliente de TLS, AWS IoT solicita un
certificado X.509 de cliente y valida el estado y la cuenta de AWS del certificado con arreglo a un registro
de certificados. A continuación, desafía al cliente para obtener una prueba de propiedad de la clave privada
que corresponde a la clave pública contenida en el certificado. AWS IoT requiere que los clientes envíen la
extensión de Indicación de nombre de servidor (SNI) al protocolo de Transport Layer Security (TLS). Para
obtener más información sobre la configuración de la extensión SNI, consulte Seguridad de transporte en
AWS IoT (p. 187).
Los certificados X.509 se pueden verificar con una entidad de certificación (CA) de confianza. Puede crear
certificados de cliente que utilicen la entidad de certificación Amazon Root y puede utilizar sus propios
certificados de cliente firmados por otra entidad de certificación. Para obtener más información sobre el uso
de sus propios certificados X.509, consulte Creación de sus propios certificados de cliente (p. 130).
La fecha y hora de caducidad de los certificados firmados por un certificado de entidad de certificación
se establecen en el momento de su creación. Los certificados X.509 generados por AWS IoT caducan a
medianoche UTC del 31 de diciembre de 2049 (2049-12-31T23:59:59Z). Para obtener más información
sobre el uso de la consola de AWS IoT para crear certificados que utilicen la entidad de certificación de
Amazon Root, consulte Crear certificados de cliente de AWS IoT (p. 129).
Uso de certificados de cliente X.509 en varias cuentas de AWS con registro de

varias cuentas
El registro de varias cuentas permite mover dispositivos entre sus cuentas de AWS en la misma
región. Con esto, puede registrar, probar y configurar un dispositivo en una cuenta de preproducción
y, a continuación, registrar y utilizar el mismo dispositivo y certificado de dispositivo en una cuenta
de producción. También puede registrar el certificado de cliente en el dispositivo (los certificados de
dispositivo) sin una entidad de certificación (p. 137) registrada con AWS IoT.
Los dispositivos que utilizan el registro de varias cuentas deben enviar la extensión Indicación de nombre
de servidor (SNI) al protocolo de Transport Layer Security (TLS) y proporcionar la dirección de punto de
enlace completa en el campo host_name, cuando se conectan a AWS IoT. AWS IoT utiliza la dirección de
punto de enlace en host_name para enrutar la conexión a la cuenta de AWS IoT correcta. Los dispositivos
existentes que no envíen una dirección de punto de enlace válida en host_name seguirán funcionando,
pero no podrán utilizar las características que requiere esta información. Para obtener más información
acerca de la extensión SNI y para aprender a identificar la dirección del punto de enlace del campo
host_name, consulte Seguridad de transporte en AWS IoT (p. 187).
Para utilizar el registro de varias cuentas
1. No registre la entidad de certificación con la que firmó los certificados del dispositivo con AWS IoT.
2. Registre los certificados de dispositivo sin una entidad de certificación. Consulte Registrar un
certificado de cliente sin una entidad de certificación registrada (CLI) (p. 137).
3. Utilice el host_name correcto en la extensión SNI para TLS cuando el dispositivo se conecte a AWS
IoT. Consulte Seguridad de transporte en AWS IoT (p. 187).
Algoritmos de firma de certificados admitidos por AWS IoT

AWS IoT es compatible con los siguientes algoritmos de firma de certificado:
• SHA256WITHRSA
• SHA384WITHRSA
• SHA512WITHRSA
• DSA_WITH_SHA256
• ECDSA-WITH-SHA256
128
Crear certificados de cliente de AWS IoT

AWS IoT proporciona certificados de cliente firmados por la entidad de certificación (CA) Amazon Root.
En este tema se describe cómo crear un certificado de cliente firmado por la entidad de certificación
Amazon Root y descargar los archivos de certificado. Después de crear los archivos de certificado de
cliente, debe instalarlos en el cliente.
Puede utilizar la consola de AWS IoT o la AWS CLI para crear un certificado de AWS IoT firmado por la
entidad de certificación Amazon Root.
Crear un certificado de AWS IoT (consola)
Para crear un certificado de AWS IoT mediante la consola de AWS IoT

2. En el panel de navegación izquierdo, elija Security (Seguridad), elija Certificates (Certificados) y, a
continuación, elija Create (Crear).
3. Elija One-click certificate creation (recommended) [Creación de un certificado con un clic
(recomendado)] - Create certificate (Crear certificado).
4. En la página Certificate created! (¡Certificado creado!), descargue los archivos de certificado del
cliente para el objeto, clave pública y clave privada en una ubicación segura.
Si necesita además el archivo de certificado de entidad de certificación de Amazon Root, esta página
también tiene el enlace a la página desde la que puede descargarlo.
5. Ahora se ha creado y registrado un certificado de cliente con AWS IoT. Debe activar el certificado
antes de usarlo en un cliente.
Elija Activate para activar el certificado de cliente ahora. Si no desea activar el certificado ahora,
Activar un certificado de cliente (consola) (p. 139) describe cómo activarlo más adelante.
6. Si desea asociar una política al certificado, elija Attach a policy.
Si no desea asociar una política ahora, elija Done para finalizar. Puede asociar una política más
adelante.
Después de completar el procedimiento, instale los archivos de certificado en el cliente.
Crear un certificado (CLI) de AWS IoT

La AWS CLI proporciona el comando create-keys-and-certificate para crear certificados de cliente firmados
por la entidad emisora de certificados de Amazon Root. No obstante, este comando no descarga el archivo
de certificado de entidad de certificación de Amazon Root. Puede descargar el archivo de certificado de
entidad de certificación de Amazon Root desde Certificados de entidad de certificación para autenticación
de servidor (p. 125).
Este comando crea archivos de clave privada, clave pública y certificado X.509 y registra y activa el
certificado con AWS IoT.
aws iot create-keys-and-certificate \

--set-as-active \
--certificate-pem-outfile <certificate_filename> \
--public-key-outfile <public_key_filename> \
--private-key-outfile <private_key_filename>
129
Si no desea activar el certificado al crearlo y registrarlo, este comando crea archivos de clave privada,
clave pública y certificado X.509 y registra el certificado, pero no lo activa. Activar un certificado de cliente
(CLI) (p. 140) describe cómo activar el certificado más adelante.
aws iot create-keys-and-certificate \

--no-set-as-active \
--certificate-pem-outfile <certificate_filename> \
--public-key-outfile <public_key_filename> \
--private-key-outfile <private_key_filename>
Instale los archivos de certificado en el cliente.
Creación de sus propios certificados de cliente

AWS IoT admite certificados de cliente firmados por otras entidades de certificados raíz (entidades de
certificación). Puede registrar certificados de cliente firmados por otra entidad de certificación raíz; sin
embargo, si desea que el dispositivo o cliente registre su certificado de cliente cuando se conecte por
primera vez AWS IoT, la entidad de certificación raíz debe estar registrada con AWS IoT.
Note
Un certificado de entidad de certificación solo se puede registrar mediante una cuenta en una
región.
Para obtener más información acerca del uso de certificados X.509 para admitir más de unos pocos
dispositivos, consulte Aprovisionamiento de dispositivos (p. 535) para revisar las diferentes opciones de
administración y aprovisionamiento de certificados que admite AWS IoT.
Temas
• Administración de sus certificados de entidad de certificación (p. 130)
• Creación de un certificado de cliente mediante el certificado de entidad de certificación (p. 134)
Administración de sus certificados de entidad de certificación

En esta sección se describen las tareas comunes para administrar sus propios certificados de entidad de
certificación.
• Creación de un certificado de entidad de certificación (p. 130), si necesita uno.

• Registro de su certificado de entidad de certificación (p. 131)
• Desactivar un certificado de entidad de certificación (p. 133)
Creación de un certificado de entidad de certificación

Si no dispone de certificado de CA, puede crear uno con herramientas de OpenSSL.
Note
No puede realizar este procedimiento en la consola de AWS IoT.
Para crear un certificado de entidad de certificación con las herramientas OpenSSL
1. Genere un par de claves.
openssl genrsa -out <root_CA_key_filename> 2048
2. Utilice la clave privada del par de claves para generar un certificado de CA.
openssl req -x509 -new -nodes \
130
-key <root_CA_key_filename> \
-sha256 -days 1024 \
-out <root_CA_pem_filename>
Registro de su certificado de entidad de certificación

Es posible que tenga que registrar la entidad de certificación con AWS IoT si está utilizando certificados de
cliente firmados por una entidad emisora de certificados que AWS IoT no reconoce.
Si desea que los clientes registren automáticamente sus certificados de cliente con AWS IoT la primera vez
que se conectan, la entidad de certificación que firmó los certificados de cliente debe estar registrada con
AWS IoT. De lo contrario, no es necesario registrar el certificado de entidad de certificación que firmó los
certificados de cliente.
Note
Un certificado de entidad de certificación solo se puede registrar mediante una cuenta en una
región.
Registro de un certificado de entidad de certificación (consola).

Note
Asegúrese de que tiene el archivo de certificado de entidad de certificación raíz y el archivo de
clave privada antes de comenzar.
Este procedimiento también requiere el uso de la interfaz de línea de comandos para ejecutar
comandos openssl.
Para registrar un certificado de entidad de certificación mediante la consola de AWS IoT

2. En el panel de navegación de la izquierda, elija Secure (Seguridad), elija CAs (Entidades de
certificación) y, a continuación, Register.
3. En Select a CA (Seleccionar una entidad de certificación), elija Register CA.
4. En Register a CA certificate (Registrar un certificado de entidad de certificación), siga los pasos que se
muestran.
Los pasos 1 - 4 se realizan en la interfaz de línea de comandos.
Los pasos 5 y 6 requieren los archivos creados en los pasos 3 y 4.

5. Si desea activar este certificado cuando lo registre, marque Activate CA certificate (Activar certificado
de entidad de certificación).
El certificado de entidad de certificación debe estar activo antes de poder registrar los certificados de
cliente firmados por él.
6. Si desea habilitar este certificado para registrar automáticamente certificados de cliente firmados por
este certificado, seleccione Enable auto-registration of device certificates (Habilitar registro automático
de certificados de dispositivo).
7. Elija Register CA certificate para completar el registro.
El certificado de entidad de certificación aparece en la lista de entidades emisoras de certificados con su

estado actual.
Registro de un certificado de entidad de certificación (CLI)

Note
Asegúrese de que tiene el archivo de certificado de entidad de certificación raíz y el archivo de
clave privada antes de comenzar.
131
Para registrar un certificado de entidad de certificación mediante la AWS CLI
1. Utilice get-registration-code para obtener un código de registro de AWS IoT. Guarde el

registrationCode devuelto para usarlo como Common Name del certificado de verificación de
clave privada.
aws iot get-registration-code
2. Genere un par de claves para el certificado de verificación de clave privada:
openssl genrsa -out <verification_cert_key_filename> 2048
3. Cree una solicitud de firma de certificado (CSR) para el certificado de verificación de clave privada.
Establezca el campo Common Name del certificado en el registrationCode devuelto por get-
registration-code.
openssl req -new \

-key <verification_cert_key_filename> \
-out <verification_cert_csr_filename>
Se le solicita información, incluido el Common Name del certificado.
You are about to be asked to enter information that will be incorporated

into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:
State or Province Name (full name) []:
Locality Name (for example, city) []:
Organization Name (for example, company) []:
Organizational Unit Name (for example, section) []:
Common Name (e.g. server FQDN or YOUR name) []:<your_registration_code>
Email Address []:
Please enter the following 'extra' attributes

to be sent with your certificate request
A challenge password []:
An optional company name []:
4. Utilice la CSR para crear un certificado de verificación de la clave privada:
openssl x509 -req \

-in <verification_cert_csr_filename> \
-CA <root_CA_pem_filename> \
-CAkey <root_CA_key_filename> \
-CAcreateserial \
-out <verification_cert_pem_filename> \
-days 500 -sha256
5. Registre el certificado de CA en AWS IoT. Pase el nombre de archivo del certificado de entidad
de certificación y el nombre de archivo del certificado de verificación de clave privada al comando
register-ca-certificate:
aws iot register-ca-certificate \

--ca-certificate file://<root_CA_pem_filename> \
--verification-cert file://<verification_cert_pem_filename>
132
Este comando devuelve el certificateID, si se realiza correctamente.

6. En este punto, el certificado de entidad de certificación se ha registrado con AWS IoT, pero no
está activo. El certificado de entidad de certificación debe estar activo antes de poder registrar los
certificados de cliente firmados por él.
Este paso activa el certificado de entidad de certificación.
Ejecute el comando de CLI update-certificate para activar el certificado de entidad de certificación:
aws iot update-ca-certificate \

--certificate-id <certificateId> \
--new-status ACTIVE
Utilice el comando describe-ca-certificate para ver el estado del certificado de entidad de certificación.
Desactivar un certificado de entidad de certificación
Cuando un certificado de entidad de certificación está habilitado para el registro automático de certificados
de cliente, AWS IoT comprueba el certificado de entidad de certificación utilizado para firmar el certificado
de cliente para asegurarse de que la entidad de certificación esté ACTIVE. Si el certificado de entidad de
certificación es INACTIVE, AWS IoT no permite que se registre el certificado de cliente.
Al establecer el certificado de entidad de certificación como INACTIVE, impide que los certificados de
cliente nuevos emitidos por la entidad de certificación se registren automáticamente.
Note
Todos los certificados de dispositivo registrados que haya firmado el certificado de entidad de
certificación en riesgo siguen funcionando hasta que revoque explícitamente cada uno de ellos.
Desactivar un certificado de entidad de certificación (consola)
Para desactivar un certificado de entidad de certificación mediante la consola de AWS IoT

2. En el panel de navegación de la izquierda, elija Secure (Seguridad) y, a continuación, elija CAs
(Entidades de certificación).
3. En la lista de entidades de certificación, busque la que desea desactivar y abra el menú de opciones
mediante el icono de puntos suspensivos.
4. En el menú de opciones, elija Deactivate (Desactivar).
La entidad de certificación debe mostrarse como Inactive (Inactiva) en la lista.

Note
La consola de AWS IoT no proporciona una forma de enumerar los certificados firmados por la
entidad de certificación desactivada. Para obtener una opción de AWS CLI para enumerar esos
certificados, consulte Desactivar un certificado de entidad de certificación (CLI) (p. 133).
Desactivar un certificado de entidad de certificación (CLI)
La AWS CLI proporciona el comando update-ca-certificate para desactivar un certificado de entidad de

certificación.
133
--new-status INACTIVE
Utilice el comando list-certificates-by-ca para obtener una lista de todos los certificados de cliente
registrados firmados por la entidad de certificación especificada. Por cada certificado de cliente firmado
por el certificado de entidad de certificación especificado, puede utilizar el comando update-certificate para
revocar el certificado de cliente y evitar que este se use.
Creación de un certificado de cliente mediante el certificado de entidad de certificación
Puede utilizar su propia entidad de certificación (CA) para crear certificados de cliente. El certificado de
cliente debe registrarse en AWS IoT para poder utilizarlo. Para obtener información acerca de las opciones
de registro de los certificados de cliente, consulte Registrar un certificado de cliente (p. 135).
Crear un certificado de cliente (CLI)

Note
No puede realizar este procedimiento en la consola de AWS IoT.
Para crear un certificado de cliente mediante la AWS CLI
1. Genere un par de claves.
openssl genrsa -out <device_cert_key_filename> 2048
2. Cree una CSR para el certificado de cliente.
openssl req -new \

-key <device_cert_key_filename> \
-out <device_cert_csr_filename>
Se le solicita que indique información, tal y como se muestra aquí:
You are about to be asked to enter information that will be incorporated

into your certificate request.
What you are about to enter is what is called a Distinguished Name or a DN.
There are quite a few fields but you can leave some blank
For some fields there will be a default value,
If you enter '.', the field will be left blank.
-----
Country Name (2 letter code) [AU]:
State or Province Name (full name) []:
Locality Name (for example, city) []:
Organization Name (for example, company) []:
Organizational Unit Name (for example, section) []:
Common Name (e.g. server FQDN or YOUR name) []:
Email Address []:
Please enter the following 'extra' attributes

to be sent with your certificate request
A challenge password []:
An optional company name []:
3. Cree un certificado de cliente a partir de la CSR.
openssl x509 -req \

-in <device_cert_csr_filename> \
134
-CA <root_ca_pem_filename> \
-CAkey <root_ca_key_filename> \
-CAcreateserial
-out <device_cert_pem_filename> \
-days 500 -sha256
En este punto, se ha creado el certificado de cliente, pero aún no se ha registrado con AWS IoT. Para
obtener información acerca de cómo y cuándo registrar el certificado de cliente, consulte Registrar un
certificado de cliente (p. 135).
Registrar un certificado de cliente

Los certificados de cliente deben registrarse con AWS IoT para habilitar las comunicaciones entre el cliente
y AWS IoT. Puede registrar cada certificado de cliente manualmente o puede configurar los certificados de
cliente para que se registren automáticamente cuando el cliente se conecte a AWS IoT por primera vez.
Si desea que sus clientes y dispositivos registren sus certificados de cliente cuando se conectan por
primera vez, debe usar Registro de su certificado de entidad de certificación (p. 131) para firmar el
certificado de cliente con AWS IoT en las regiones en las que desea usarlo. La entidad de certificación de
Amazon Root se registra automáticamente en AWS IoT.
Los certificados de cliente pueden compartirse con las cuentas y regiones de AWS. Los procedimientos de
estos temas deben realizarse en cada cuenta y región en la que desee utilizar el certificado de cliente. El
registro de un certificado de cliente en una cuenta o región no es reconocido automáticamente por otra.
Note
Los clientes que utilizan el protocolo Transport Layer Security (TLS) para conectarse a AWS IoT
deben admitir la extensión de indicación de nombre de servidor (SNI) para TLS. Para obtener más
información, consulte Seguridad de transporte en AWS IoT (p. 187).
Temas
• Registrar manualmente un certificado de cliente (p. 135)
• Registrar un certificado de cliente cuando el cliente se conecta a AWS IoT (Registro justo a
tiempo) (p. 137)
Registrar manualmente un certificado de cliente
Puede registrar un certificado de cliente manualmente mediante la consola de AWS IoT y la AWS CLI.
Los procedimientos de este tema deben realizarse en cada cuenta y región en la que desee utilizar el
certificado de cliente. Las cuentas y regiones de AWS pueden compartir certificados de cliente, pero solo si
el certificado de cliente está firmado por una entidad de certificación (CA) que NO esté registrada con AWS
IoT. El registro de un certificado de cliente en una cuenta o región no es reconocido automáticamente por
otra.
Registrar manualmente un certificado de cliente (consola)

Note
Antes de realizar este procedimiento, asegúrese de que tiene el archivo.pem del certificado de
cliente y de que el certificado de cliente fue firmado por una entidad de certificación que se ha
registrado con AWS IoT (p. 131).
Para registrar un certificado existente con el AWS IoT mediante la consola
135
2. En el panel de navegación izquierdo, elija Secure (Seguridad), elija Certificates (Certificados) y, a

continuación, elija Create.
3. En Create a certificate (Crear un certificado), busque la entrada Use my certificate (Usar mi certificado)
y elija Get started.
4. En Select a CA (Seleccionar una entidad de certificación), si los certificados están firmados por una
entidad de certificación que está registrada con AWS IoT, elija dicha entidad de certificación en la lista
y, a continuación, elija Next.
Si los certificados de cliente no están firmados por una entidad de certificación registrada con
AWS IoT, consulte Registrar manualmente un certificado de cliente sin una entidad de certificación
registrada (consola) (p. 136).
5. En Register existing device certificates (Registrar certificados de dispositivo existentes), elija Select
certificates y seleccione hasta 10 archivos de certificado que registrar.
6. Después de cerrar el cuadro de diálogo de archivo, seleccione si desea activar o revocar los
certificados de cliente cuando los registre.
Si no activa un certificado cuando se registra, Activar un certificado de cliente (consola) (p. 139)
describe cómo activarlo más adelante.
Si un certificado se revoca cuando se registra, no se puede activar más tarde.
Después de elegir los archivos de certificado que desea registrar y seleccionar las acciones que desea
realizar después del registro, elija Register certificates.
Los certificados de cliente registrados correctamente aparecen en la lista de certificados.
Registrar manualmente un certificado de cliente sin una entidad de certificación registrada

(consola)
Note
Antes de realizar este procedimiento, asegúrese de que tiene el archivo .pem del certificado de
cliente.
Para registrar un certificado existente con el AWS IoT mediante la consola

2. En el panel de navegación izquierdo, elija Secure (Seguridad), elija Certificates (Certificados) y, a
continuación, elija Create.
3. En Create a certificate (Crear un certificado), busque la entrada Use my certificate (Usar mi certificado)
y elija Get started.
4. En Select a CA (Seleccionar una entidad de certificación), elija Next.
5. En Register existing device certificates (Registrar certificados de dispositivo existentes), elija Select
certificates y seleccione hasta 10 archivos de certificado que registrar.
6. Después de cerrar el cuadro de diálogo de archivo, seleccione si desea activar o revocar los
certificados de cliente cuando los registre.
Si no activa un certificado cuando se registra, Activar un certificado de cliente (consola) (p. 139)
describe cómo activarlo más adelante.
Si un certificado se revoca cuando se registra, no se puede activar más tarde.
Después de elegir los archivos de certificado que desea registrar y seleccionar las acciones que desea
realizar después del registro, elija Register certificates.
Los certificados de cliente registrados correctamente aparecen en la lista de certificados.
136
Registrar manualmente un certificado de cliente (CLI)

Note
Antes de realizar este procedimiento, asegúrese de que tiene el archivo .pem de la entidad de
certificación y el archivo .pem del certificado de cliente. El certificado de cliente debe estar firmado
por una entidad de certificación que haya registrado con AWS IoT (p. 131).
Utilice el comando register-certificate para registrar, pero no activar, un certificado de cliente.
aws iot register-certificate \

--certificate-pem file://<device_cert_pem_filename> \
--ca-certificate-pem file://<ca_cert_pem_filename>
El certificado de cliente está registrado con AWS IoT, pero no está activo aún. Consulte Activar un
certificado de cliente (CLI) (p. 140) para obtener información sobre cómo activarlo más adelante.
También puede activar el certificado de cliente cuando lo registre utilizando este comando.
aws iot register-certificate \

--set-as-active \
--certificate-pem file://<device_cert_pem_filename> \
--ca-certificate-pem file://<ca_cert_pem_filename>
Para obtener más información acerca de cómo activar el certificado para que se pueda utilizar para
conectarse a AWS IoT, consulte Activar o desactivar un certificado de cliente (p. 139)
Registrar un certificado de cliente sin una entidad de certificación registrada (CLI)

Note
Antes de llevar a cabo este procedimiento, asegúrese de que tiene el archivo .pem del certificado.
Utilice el comando register-certificate-without-ca para registrar, pero no activar, un certificado de cliente.
aws iot register-certificate-without-ca \

--certificate-pem file://<device_cert_pem_filename>
El certificado de cliente está registrado con AWS IoT, pero no está activo aún. Consulte Activar un
certificado de cliente (CLI) (p. 140) para obtener información sobre cómo activarlo más adelante.
También puede activar el certificado de cliente cuando lo registre utilizando este comando.
aws iot register-certificate-without-ca \

--status ACTIVE \
--certificate-pem file://<device_cert_pem_filename>
Para obtener más información acerca de cómo activar el certificado para que se pueda utilizar para
conectarse a AWS IoT, consulte Activar o desactivar un certificado de cliente (p. 139)
Registrar un certificado de cliente cuando el cliente se conecta a AWS IoT (Registro justo a
tiempo)
Puede configurar un certificado de entidad de certificación para habilitar los certificados de cliente con
los que ha firmado para que se registren automáticamente con AWS IoT la primera vez que el cliente se
conecta a AWS IoT.
Para registrar certificados de cliente cuando un cliente se conecta a AWS IoT por primera vez, debe
habilitar el certificado de entidad de certificación para el registro automático y configurar la primera
conexión del cliente para proporcionar los certificados necesarios.
137
Configurar un certificado de entidad de certificación para admitir el registro automático (consola)
Para configurar un certificado de entidad de certificación para admitir el registro automático de

certificados de cliente mediante la consola de AWS IoT

2. En el panel de navegación de la izquierda, elija Secure (Seguridad) y, a continuación, elija CAs
(Entidades de certificación).
3. En la lista de entidades de certificación, busque aquella para la que desea habilitar el registro
automático y abra el menú de opciones mediante el icono de puntos suspensivos.
4. En el menú de opciones, elija Enable auto-registration (Habilitar registro automático).
Note
El estado de registro automático no se muestra en la lista de entidades de certificación. Para

ver el estado de registro automático de una entidad de certificación, debe abrir la página Details
(Detalles) de la entidad de certificación.
Configurar un certificado de entidad de certificación para admitir el registro automático (CLI)
Si ya ha registrado su certificado de entidad de certificación con AWS IoT, utilice el comando update-
ca-certificate para establecer autoRegistrationStatus del certificado de entidad de certificación en
ENABLE.

--certificate-id<caCertificateId> \
--new-auto-registration-status ENABLE
Si desea habilitar autoRegistrationStatus al registrar el certificado de entidad de certificación, utilice

el comando register-ca-certificate.
aws iot register-ca-certificate \

--allow-auto-registration \
--ca-certificate file://<root_CA_pem_filename> \
--verification-cert file://<verification_cert_pem_filename>
Configurar la primera conexión de un cliente para el registro automático
Cuando un cliente intenta conectar a AWS IoT por primera vez, como parte del protocolo de enlace TLS,
debe presentar un archivo que contenga el certificado de entidad de certificación registrado y el certificado
de cliente firmado por el certificado de entidad de certificación. Puede combinar los dos archivos utilizando
un comando como el siguiente:
cat <device_cert_filename> <ca_certificate_pem_filename> <combined_filename>
Cuando el cliente se conecta a AWS IoT, utilice el archivo <nombre_archivo_combinado> como

archivo de certificado. AWS IoT reconoce el certificado de entidad de certificación como certificado
de entidad de certificación registrado, registra el certificado de cliente y establece su estado en
PENDING_ACTIVATION. Esto significa que el certificado de cliente se registró automáticamente y que está
a la espera de su activación. El estado del certificado de cliente debe ser ACTIVE antes de que se pueda
usar para conectarse a AWS IoT.
Cuando AWS IoT registra automáticamente un certificado o cuando un cliente presenta un certificado en
estado PENDING_ACTIVATION, AWS IoT publica un mensaje en el tema MQTT siguiente:
138
$aws/events/certificates/registered/<caCertificateId>
Donde <caCertificateId> es el ID del certificado de entidad de certificación que generó el certificado

de cliente.
El mensaje publicado en este tema tiene la estructura siguiente:
{
"certificateId": "<certificateId>",
"caCertificateId": "<caCertificateId>",
"timestamp": <timestamp>,
"certificateStatus": "PENDING_ACTIVATION",
"awsAccountId": "<awsAccountId>",
"certificateRegistrationTimestamp": "<certificateRegistrationTimestamp>"
}
Puede crear una regla que escuche este tema y realice algunas acciones. Le recomendamos crear una
regla de Lambda que verifique que el certificado de cliente no se encuentre en una lista de revocación de
certificados (CRL), active el certificado y cree una política y la asocie a este. La política determina a qué
recursos puede tener acceso el cliente. Para obtener más información acerca de cómo crear una regla de
Lambda que escuche el tema $aws/events/certificates/registered/<caCertificateID> y
ejecute estas acciones, consulte Just-in-Time Registration of Client Certificates on AWS IoT.
Si se produce algún error o excepción durante el registro automático de los certificados de cliente, AWS
IoT envía eventos o mensajes a sus registros en CloudWatch Logs. Para obtener más información acerca
de cómo configurar los registros de su cuenta, consulte la documentación de Amazon CloudWatch.
Activar o desactivar un certificado de cliente

AWS IoT comprueba que un certificado de cliente está activo cuando autentica una conexión.
Puede crear y registrar certificados de cliente sin activarlos para que no se puedan usar hasta que desee
usarlos. También puede desactivar los certificados de cliente activos para deshabilitarlos temporalmente.
Por último, puede revocar certificados de cliente para evitar que se utilicen en el futuro.
Activar un certificado de cliente (consola)
Para activar un certificado de cliente mediante la consola de AWS IoT

2. En el panel de navegación de la izquierda, elija Secure (Seguridad) y, a continuación, elija Certificates
(Certificados).
3. En la lista de certificados, busque el certificado que desea activar y abra el menú de opciones
4. En el menú de opciones, elija Activate (Activar).
El certificado debe aparecer como Active (Activo) en la lista de certificados.
Desactivar un certificado de cliente (consola)
Para desactivar un certificado de cliente mediante la consola de AWS IoT

(Certificados).
3. En la lista de certificados, busque el certificado que desea desactivar y abra el menú de opciones
139
4. En el menú de opciones, elija Deactivate (Desactivar).
El certificado debe aparecer como Inactive (Inactivo) en la lista de certificados.
Activar un certificado de cliente (CLI)

La AWS CLI proporciona el comando update-certificate para activar un certificado.
aws iot update-certificate \

--new-status ACTIVE
Si el comando se realizó correctamente, el estado del certificado será ACTIVE. Ejecute describe-certificate
para ver el estado del certificado.
aws iot describe-certificate \

--certificate-id <certificateId>
Desactivar un certificado de cliente (CLI)

La AWS CLI proporciona el comando update-certificate para desactivar un certificado.

--new-status INACTIVE
Si el comando se realizó correctamente, el estado del certificado será INACTIVE. Ejecute describe-
certificate para ver el estado del certificado.

Revocar un certificado de cliente

Si detecta actividad sospechosa en un certificado de cliente registrado, puede revocarlo para que no se
pueda volver a utilizar.
Revocar un certificado de cliente (consola)
Para revocar un certificado de cliente mediante la consola de AWS IoT

(Certificados).
3. En la lista de certificados, busque el certificado que desea revocar y abra el menú de opciones
4. En el menú de opciones, elija Revoke (Revocar).
Si el certificado se revocó correctamente, se mostrará como Revoked (Revocado) en la lista de

certificados.
Revocar un certificado de cliente (consola)

La AWS CLI proporciona el comando update-certificate para revocar un certificado.
140

--new-status REVOKED
Si el comando se realizó correctamente, el estado del certificado será REVOKED. Ejecute describe-
certificate para ver el estado del certificado.

Usuarios, grupos y roles de IAM

Los usuarios, grupos y roles de IAM son los mecanismos estándar de administración de identidades y
autenticación en AWS. Puede utilizarlos para conectarse con las interfaces HTTP de AWS IoT mediante el
SDK y la AWS CLI de AWS.
Los roles de IAM también permiten a AWS IoT tener acceso a otros recursos de AWS de su cuenta en su
nombre. Por ejemplo, si desea que un dispositivo publique su estado en una tabla de DynamoDB, los roles
de IAM permiten a AWS IoT interactuar con Amazon DynamoDB. Para obtener más información, consulte
Roles de IAM.
En cuanto a las conexiones del agente de mensajes sobre HTTP, AWS IoT autentica a los usuarios,
grupos y roles de IAM mediante el proceso Signature Version 4. Para obtener más información, consulte
Firma de solicitudes de la API de AWS.
Cuando utilice AWS Signature Version 4 con AWS IoT, los clientes deben admitir lo siguiente en su
implementación de TLS:
• TLS 1.2, TLS 1.1, TLS 1.0

• Validación de la firma de certificado SHA-256 RSA
• Uno de los conjuntos de cifrado de la sección de compatibilidad del conjunto de cifrado TLS
Para obtener información, consulte Administración de identidad y acceso en AWS IoT (p. 189).
Identidades de Amazon Cognito

Identidad de Amazon Cognito le permite crear credenciales temporales de AWS con privilegios limitados
para su uso en aplicaciones móviles y web. Cuando se utiliza Identidad de Amazon Cognito, se crean
grupos de identidades que crean identidades únicas para los usuarios y se autentican con proveedores de
identidades como Login with Amazon, Facebook y Google. También puede usar identidades de Amazon
Cognito con sus propias identidades autenticadas por el desarrollador. Para obtener más información,
consulte Amazon Cognito Identity.
Para utilizar Identidad de Amazon Cognito, defina un grupo de identidades de Amazon Cognito asociado
a un rol de IAM. El rol de IAM está asociado a una política de IAM que concede a las identidades de su
grupo de identidades permiso para acceder a los recursos de AWS, como llamar a los servicios de AWS.
Identidad de Amazon Cognito crea identidades no autenticadas y autenticadas. Las identidades no

autenticadas se utilizan para los usuarios invitados de una aplicación móvil o web que desean usar la
aplicación sin iniciar sesión. Los usuarios no autenticados solo reciben los permisos especificados en la
política de IAM asociada al grupo de identidades.
Cuando utiliza identidades autenticadas, además de la política de IAM asociada al grupo de identidades,
puede asociar una política de AWS IoT a una Identidad de Amazon Cognito mediante la API AttachPolicy
141
Autenticación personalizada
y otorgar permisos detallados a un usuario individual de su aplicación de AWS IoT. De esta forma, puede
asignar permisos para clientes específicos y sus dispositivos. Para obtener más información acerca de la
creación de políticas para identidades de Amazon Cognito, consulte Ejemplos de política de publicación/
suscripción (p. 164).
AWS IoT le permite definir autorizadores personalizados para que pueda administrar su propia
autenticación y autorización de clientes. Para ello, se utilizan funciones AWS Lambda que envían
credenciales de cliente al servicio de autenticación.
Cuando se establece una conexión HTTP (y, opcionalmente, se actualiza a una conexión WebSocket)
y los encabezados Signature Version 4 no están presentes, la gateway de dispositivos de AWS IoT
comprueba si un autorizador personalizado está configurado para el punto de enlace. Si es así, la gateway
de dispositivos de AWS IoT utiliza el autorizador personalizado para autenticar la conexión y autorizar el
dispositivo. Los autorizadores personalizados pueden implementar varias estrategias de autenticación (por
ejemplo, verificación de JWT, llamada al proveedor de OAuth, etc.) y deben devolver los documentos de la
política que ha usado la puerta de enlace del dispositivo para autorizar las operaciones de MQTT.
Hay dos formas de implementar la autenticación personalizada:
• Autenticación personalizada: utiliza operaciones de publicación HTTP o MQTT a través de conexiones

WSS para recibir credenciales de cliente en un token portador (como un token web JSON (JWT) o un
token OAuth) dentro de un encabezado HTTP.
• Autenticación personalizada mejorada: amplía la autenticación personalizada para permitir pasar
credenciales de cliente a través de un mensaje MQTT CONNECT (en los campos username y
password) o como parámetros de consulta en una solicitud de publicación o actualización HTTP (en
el caso de MQTT a través de WSS). Esta función también le permite eliminar los requisitos de firma de
tokens para sus autorizadores personalizados. Esta característica está en versión beta.
Note
Puede definir hasta 10 autorizadores personalizados.
Temas
• Autorizadores personalizados (p. 143)
• Configuración de un autorizador personalizado (p. 144)
• Flujo de trabajo del autorizador personalizado (p. 145)
• Autenticación personalizada mejorada (beta) (p. 147)
142
Autorizadores personalizados
Los autorizadores personalizados constan de:
Nombre
Una única cadena arbitraria que identifica al autorizador.

ARN de función de Lambda
Un ARN de una función de Lambda que implementa la lógica de autenticación y devuelve las políticas
de autorización.
Clave pública
La clave pública de un par de claves que se utiliza para evitar llamadas no autorizadas a la función de
Lambda del autorizador.
Utilice el siguiente comando para generar un par de claves:
openssl genrsa -out myKeyPair.pem 2048
Utilice el siguiente comando para extraer la clave pública del par de claves:
openssl rsa -in myKeyPair.pem -pubout > mykey.pub

Nombre de clave de token
El nombre de clave que se utiliza para extraer tokens de encabezados de conexión WebSocket.
La lógica que realiza la autenticación se implementa en una función de Lambda.

Note
Se le cobra en función del número de solicitudes para sus funciones de Lambda y la duración, el
tiempo necesario para ejecutar el código. Para obtener más información acerca de AWS Lambda,
consulte Precios de AWS Lambda y AWS Lambda Developer Guide.
Esta función toma un token presentado por un cliente o dispositivo, autentica el dispositivo y devuelve la
siguiente información:
isAuthenticated
Un valor booleano que indica si el token se ha autenticado. Si es false, el resto de los campos de
respuesta deben ignorarse.
principalId
El ID de la entidad principal a la que se conceden los permisos descritos en policyDocuments.

policyDocuments
Una lista de documentos de políticas con formato JSON que siguen las mismas convenciones que
una política de AWS IoT. La lista incluye como máximo 10 documentos de políticas, cada uno de los
cuales puede tener un máximo de 2048 caracteres.
DisconnectAfterInSecs
La duración máxima (en segundos) de la conexión a la gateway de AWS IoT, después de la cual se
desconecta. El valor mínimo es de 300 segundos y el máximo es de 86 400 segundos.
RefreshAfterInSecs
El periodo entre las actualizaciones de las políticas. Cuando transcurre este periodo, el motor de
políticas de AWS vuelve a evaluar los documentos de políticas y la gateway de dispositivos de AWS
143
IoT invoca de nuevo la función de Lambda para permitir cambios en las políticas. El valor mínimo es
de 300 segundos y el máximo es de 86 400 segundos.
Contexto
Información derivada después de validar el token que está disponible en instrucciones de SQL del
motor de reglas de AWS IoT (p. 373) y variables de política de IAM/AWS IoT (p. 155).
Debe conceder permiso al principal del servicio de AWS IoT para invocar la función de Lambda que
implementa la lógica de autenticación/autorización personalizada. Puede hacer esto con el siguiente
comando de la AWS CLI:
aws lambda add-permission --function-name <lambda_function_name> --statement-id

<unique_identifier_string> --action 'lambda:InvokeFunction' --principal iot.amazonaws.com --
source-arn arn:aws:iot:<your-aws-region>:<account_id>: authorizer/<authorizer-name>
El comando add-permission usa los siguientes parámetros:
function-name
El nombre de la función Lambda a la que concede permiso de invocación.

statement-id
Un identificador de instrucción.
action
La acción de Lambda a la que se concede permiso.

principal
La entidad principal a la que se conceden los permisos.

source-arn
El ARN del autorizador personalizado. Especificar este valor garantiza que solo el autorizador
personalizado previsto puede invocar la función de Lambda.
Para obtener más información acerca de la concesión de permiso para llamar a las funciones de Lambda,
consulte Permisos de AWS Lambda.
Puede definir un autorizador predeterminado para que se utilice cuando la información del autorizador no
esté incluida en una solicitud de conexión:
aws iot set-default-authorizer --authorizer-name <my-authorizer>
Configuración de un autorizador personalizado

1. Cree una función de Lambda que implementa su lógica de autenticación/autorización (por ejemplo, el
MyAuthorizerFunction en el siguiente paso). A continuación, se muestra un ejemplo de lo que una
función personalizada de Lambda de autorización podría devolver:
{
"isAuthenticated": true,
"principalId": "xxxxxxxx",
"disconnectAfterInSeconds": 86400,
"refreshAfterInSeconds": 300,
"policyDocuments": [
"{\"Version\":\"2012-10-17\",\"Statement\":[{\"Action\":\"...\",\"Effect\":
\"Allow|Deny\",\"Resource\":\"...\"}]}"
],
144
"context": {
"username": "johnDoe123",
"city": "Seattle",
"country": "USA"
}
}
El valor de retorno de la función de Lambda debe ser similar a esta respuesta. Puede ser un objeto
JSON serializado o no serializado.
2. Utilice la API create-authorizer para registrar un autorizador personalizado con AWS IoT.
aws iot create-authorizer --authorizer-name MyAuthorizer

--authorizer-function-arn arn:aws:lambda:us-
west-2:<account_id>:function:MyAuthorizerFunction // Lambda ARN
--token-key-name MyAuthorizerToken // Key use to
extract token from headers
--token-signing-public-keys FIRST_KEY= // Public key
used to verify token signature
"-----BEGIN PUBLIC KEY-----
[...insert your public key here...]
-----END PUBLIC KEY-----"
--status ACTIVE // Authorizer
status - must be ACTIVE
--region us-west-2 // AWS region
Puede usar la API test-invoke-authorizer para probar si la función de Lambda de autorizador

personalizado se ha configurado correctamente, tal como se muestra a continuación:
aws iot test-invoke-authorizer --authorizer-name <NAME_OF_AUTHORIZER> --token

<TOKEN_VALUE> --token-signature <TOKEN_SIGNATURE>
Note
<FIRMA_TOKEN> debe firmarse con la clave privada del par de claves pública-privada
cargado en AWS IoT que se usó en la llamada a create-authorizer. A continuación se
indica un método de creación local de <TOKEN_SIGNATURE> desde una línea de comandos
de UNIX:
echo -n <TOKEN_VALUE> | openssl dgst -sha256 -sign <PRIVATE_KEY> | openssl

base64
Debe recortar todos los caracteres de línea nueva del resultado de este comando antes de
transferir el valor de <FIRMA_TOKEN> a la API test-invoke-authorizer.
Flujo de trabajo del autorizador personalizado

Para que un cliente o dispositivo se autentique con la gateway de dispositivos de AWS IoT mediante un
autorizador personalizado, es necesario un token y una firma utilizados por AWS para validar los tokens
antes de invocar el autorizador.
Cuando un cliente o dispositivo intenta conectarse a AWS IoT, envía la siguiente información en
encabezados HTTP:
• Un token generado por su servicio de autenticación.

• La firma generada por el servicio de autenticación.
• El autorizador utilizado para autenticar el token. Si se omite, se utiliza el autorizador predeterminado.
145
A continuación se muestra una solicitud HTTP de ejemplo para conectarse a AWS IoT a través del
protocolo WebSocket.
GET /mqtt HTTP/1.1

Host: <your-iot-endpoint>
Upgrade: WebSocket
Connection: Upgrade
x-amz-customauthorizer-name: <authorizer-name>
x-amz-customauthorizer-signature: <token-signature>
<token-key-name>: <some-token>
sec-WebSocket-Key: <any random base64 value>
sec-websocket-protocol: mqtt
sec-WebSocket-Version: <websocket version>
En este ejemplo, el encabezado x-amz-customauthorizer-name especifica el autorizador

personalizado que usar. El encabezado x-amz-customauthorizer-signature contiene la firma digital
usada para verificar el token y token-key-name es el nombre de clave de token especificado por --
token-key-name pasado a la API create-authorizer. El valor de x-amz-customauthorizer-
signature debe estar codificado en Base64.
Note
Es posible que algunos navegadores web no sean compatibles con los encabezados HTTP.
La puerta de enlace del dispositivo de AWS IoT valida la firma digital y, si es válida, llama al autorizador
especificado. A continuación se muestra una carga de ejemplo que AWS IoT envía a la función de Lambda
del autenticador personalizado.
{
"token": "<some-token>"
}
El autorizador valida el token y devuelve un ID principal, su política de AWS IoT/IAM asociada y la

información de tiempo de vida (TTL) para la conexión.
A continuación se muestra un ejemplo de la respuesta de un autorizador personalizado.
{
"isAuthenticated": true,
"{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Action\": \"...\", \"Effect\":
\"Allow|Deny\", \"Resource\": \"...\" } ] }"
]
}
El valor de retorno de la función de Lambda debería ser similar a esta respuesta y puede ser un objeto
JSON serializado o no serializado.
La gateway de dispositivos de AWS IoT establece a continuación la conexión WebSocket. AWS

IoT almacena en caché las políticas asociadas al principal, de manera que las llamadas siguientes
pueden autorizarse sin tener que volver a reautenticar el dispositivo. Un fallo durante la autenticación
personalizada genera un error de autenticación y la finalización de la conexión.
Para ver un ejemplo integral de este flujo de trabajo, consulte How to Use Your Own Identity and Access
Management Systems to Control Access to AWS IoT Resources.
146
Autenticación personalizada mejorada (beta)
Esta característica actualmente se encuentra en versión beta pública y solo está disponible en la región
de EE. UU. Este (Norte de Virginia).
La autenticación personalizada mejorada proporciona una mayor flexibilidad en los métodos de

autenticación que los autorizadores personalizados pueden utilizar cuando se implementan mediante
puntos de enlace configurables. Este conjunto de características en versión de vista previa le permite
pasar tokens a sus autorizadores mediante el uso de cadenas de consulta HTTP además de encabezados.
También hace que la firma de tokens sea opcional. Estas funciones permiten también la autenticación
pasando credenciales a los campos password y username de un mensaje MQTT CONNECT. En este
tema se describe cómo utilizar estas mejoras y cómo añadir autorizadores personalizados a los puntos de
enlace configurables. Para obtener más información, consultePuntos de enlace configurables (beta).
La autenticación personalizada mejorada envía credenciales de cliente a los autorizadores personalizados

mediante uno de los métodos siguientes:
• Publicación HTTP (campos de encabezado)

• Publicación HTTP (cadena de consulta)
• MQTT Connect (campos de nombre de usuario y contraseña)
• Actualización HTTP a MQTT (encabezados HTTP o cadena de consulta)
• Actualización HTTP a MQTT (nombre de usuario y contraseña de MQTT)
Note
Para pasar tokens sin firmar o utilizar la autenticación de nombre de usuario/contraseña de

MQTT, los clientes deben enviar la extensión TLS de indicación de nombre de servidor (SNI)
con un nombre de dominio completo correspondiente al nombre especificado en la configuración
del dominio. Para obtener más información sobre la configuración de la extensión SNI, consulte
Seguridad de transporte en AWS IoT (p. 187). Para probar este servicio, use la versión v2 de
cada SDK de dispositivo AWS IoT en GitHub.
Temas
• Creación de un autorizador personalizado para la autenticación personalizada mejorada (p. 147)
• Invocación de un autorizador personalizado con la autenticación personalizada mejorada (p. 148)
Creación de un autorizador personalizado para la autenticación personalizada

mejorada
Un autorizador personalizado para la autenticación personalizada mejorada se crea utilizando la misma

API CreateAuthorizer que se utiliza para crear un autorizador personalizado para la autenticación
personalizada. Para obtener información sobre los procedimientos para crear un autorizador
personalizado, consulte Configurar un autorizador personalizado.
Puede usar el parámetro signingDisabled de la API CreateAuthorizer. Esto le permite dejar de

utilizar la validación de firma de AWS IoT y usar en su lugar el token proporcionado en sus solicitudes
HTTP. Es absolutamente recomendable que utilice esta función solo en entornos de prueba. No se
147
puede actualizar el valor signingDisabled de un autorizador personalizado. Para cambiar este

comportamiento, debe crear un autorizador personalizado con un valor de signingDisabled diferente.
Los valores de tokenKeyName y tokenSigningPublicKeys son opcionales, pero tokenKeyName es
necesario cuando se especifica un valor para tokenSigningPublicKeys.
Incorporación de un autorizador personalizado a un punto de enlace configurable
Después de crear el autorizador personalizado, puede asociarlo a una configuración de dominio existente
como el autorizador predeterminado mediante la API UpdateDomainConfiguration . También puede crear
una configuración utilizando la API CreateDomainConfiguration y especificando el nombre del autorizador
personalizado en el parámetro defaultAuthorizerName.
Invocación de un autorizador personalizado con la autenticación personalizada

mejorada
En esta sección se explica cómo utilizar la autenticación personalizada mejorada para pasar credenciales
de cliente a su autorizador personalizado mediante encabezados HTTP y cadenas de consulta o nombres
de usuario y contraseñas de MQTT.
Los dispositivos y clientes que utilizan el protocolo de Transport Layer Security (TLS) para conectarse
a AWS IoT deben enviar la extensión TLS de indicación de nombre de servidor (SNI) con un valor que
coincida con el dominio de la configuración de dominio adecuada. Puede especificar un autorizador
personalizado distinto del autorizador predeterminado si el valor de allowAuthorizerOverride
de la configuración de su dominio está establecido en true. Para obtener más información sobre la
configuración de la extensión SNI, consulte Seguridad de transporte en AWS IoT (p. 187).
Para utilizar la autenticación personalizada mejorada en las conexiones MQTT, los clientes también deben
enviar la extensión TLS de negociación de protocolo de capa de aplicación (ALPN) con un valor de mqtt y
conectarse al puerto 443.
Note
Puede encontrar la configuración de estas extensiones TLS en la versión 2 de los SDK de

dispositivo de AWS IoT. Para obtener más información, consulte el repositorio de Labs GitHub de
AWS.
Solicitudes HTTPS
Las solicitudes a los autorizadores personalizados pueden pasar tokens utilizando uno de los siguientes
elementos: encabezados HTTP o cadenas de consulta en solicitudes de publicación HTTP o solicitudes
de actualización HTTP para establecer sesiones de MQTT a través de WSS. En el ejemplo siguiente se
utilizan encabezados HTTP para enviar una solicitud de actualización al gateway de dispositivos de AWS
IoT.
GET /mqtt HTTP/1.1

Host: <your-endpoint>
Upgrade: WebSocket
Connection: Upgrades
x-amz-customauthorizer-signature: <token-signature>
<token-key-name>: <some-token>
148
La solicitud no contiene un valor para x-amz-customauthorizer-name, por lo que AWS IoT utiliza
el autorizador predeterminado especificado en la configuración del dominio. El valor de x-amz-
customauthorizer-signature es opcional si la firma está deshabilitada en el autorizador.
El siguiente ejemplo muestra cómo realizar la misma solicitud mediante parámetros de cadena de consulta.
GET /mqtt?x-amz-customauthorizer-signature=${<sign>}&<token-name>=${<token-value>} HTTP/1.1

Host: <your-endpoint>
Connection: Upgrade
Upgrade: websocket
Nombre de usuario y contraseña de MQTT
Puede pasar nombres de usuario y contraseñas a sus autorizadores personalizados utilizando los campos
password y username de los mensajes MQTT. Los datos de contraseña están codificados en base64
para admitir valores binarios arbitrarios. El valor de username puede contener opcionalmente una cadena
de consulta que pase valores adicionales (incluido un token, una firma y un nombre de autorizador) al
autorizador.
El siguiente ejemplo contiene una cadena username con parámetros adicionales que especifican un token
y una firma. Puede utilizar este método para autenticar una conexión MQTT utilizando un token portador.
username?x-amz-customauthorizer-name=${<name>}&x-amz-customauthorizer-signature=
${<sign>}&token-name=${<token-value>}
Datos enviados al autorizador personalizado
Los datos que AWS IoT envía a la función Lambda del autorizador personalizado dependen de qué
protocolos y parámetros están presentes en la conexión. Para las solicitudes HTTP (publicación y
actualizaciones de WSS), AWS IoT envía todos los encabezados y parámetros de consulta (hasta 8 KB de
datos). Para las actualizaciones de WSS en MQTT Connect, AWS IoT también envía todos los datos de
MQTT.
Si la firma está habilitada y la solicitud contiene un token y una firma, AWS IoT no activará la función
Lambda de su autorizador personalizado a menos que la firma del token se pueda descifrar y coincida con
el token proporcionado en la solicitud. Puede utilizar este método para que otras personas que se conecten
a su dominio no activen excesivamente su función Lambda.
Important
Le recomendamos encarecidamente que utilice la función de verificación de firma que AWS IoT
ofrece.
A continuación, se muestra un ejemplo de carga útil que AWS IoT envía a la función Lambda del
autenticador personalizado. AWS IoT rellena solo los campos que contiene la solicitud.
{
"token" :"<aToken>",
"signatureVerified": <boolean>, // Indicates whether the device gateway has validated
the signature.
"protocols": ["tls", "http", "mqtt"], // Indicates which protocols to expect.
149
Administración de certificados de dispositivo
"protocolData": {
"tls" : {
"serverName": "<serverName>" // The SNI host_name string.
},
"http": {
"headers": {
"#{<name>}": "#{<value>}"
},
"queryString": "?#{<name>}=#{<value>}"
},
"mqtt": {
"username": "<myUserName>",
"password": "<myPassword>", // base64 encoded.
"clientId": "<myClientId>" // Provided only when the device sends it.
}
},
"connectionMetadata": {
"id": <UUID> // The connection ID. You can use this for logging.
},
}
Note
Todos los datos de contraseña están codificados en base64 y su función Lambda necesita
descodificarlos.
Al igual que con la autenticación personalizada normal, el autorizador personalizado debe devolver una
respuesta que indique si ha autorizado la solicitud a AWS IoT. A continuación, se muestra un ejemplo de
una respuesta correcta de un autorizador personalizado.
{
"isAuthenticated":true,
"{ \"Version\": \"2012-10-17\", \"Statement\": [ { \"Action\": \"...\", \"Effect\":
\"Allow|Deny\", \"Resource\": \"...\" } ] }"
]
}
AWS IoT almacena en caché las políticas asociadas con la entidad principal durante el tiempo especificado
en el valor de refreshAfterInSeconds. Durante este tiempo, las llamadas posteriores se autorizan
sin tener que volver a autenticar el dispositivo. Los errores que se producen durante la autenticación
personalizada dan como resultado un error de autenticación, que detiene la conexión.
Administración de certificados de dispositivo

Sus dispositivos pueden utilizar los certificados X.509 para autenticarse en AWS IoT Core.

El certificado de CA raíz de AWS IoT permite a sus dispositivos verificar que se están comunicando
con AWS IoT Core y no con otro servidor que suplante a AWS IoT Core. Para obtener más información,
consulte Certificados de CA para la autenticación de servicios.
150
Autorización
Autorización
Autorización es el proceso de concesión de permisos a una identidad autenticada. Concede permisos
en AWS IoT Core usando políticas de AWS IoT Core e IAM. En este tema se abordan las políticas de
AWS IoT Core. Para obtener más información acerca de las políticas deIAM, consulte Administración de
identidad y acceso en AWS IoT (p. 189) y Políticas de IAM (p. 193).
Las políticas de AWS IoT Core determinan lo que puede hacer una identidad autenticada. Los dispositivos
y las aplicaciones móviles, web y de escritorio utilizan identidades autenticadas. Una identidad autenticada
puede ser incluso un usuario que ejecute comandos de la CLI de AWS IoT Core. Una identidad puede
ejecutar operaciones de AWS IoT Core solo si cuenta con una política que le conceda permiso para dichas
operaciones.
Tanto las políticas de AWS IoT Core como las de IAM se utilizan con AWS IoT Core para controlar las
operaciones que una identidad (también denominada principal) puede realizar. El tipo de política que utilice
depende del tipo de identidad que esté utilizando para autenticarse en AWS IoT Core.
Las operaciones de AWS IoT Core se dividen en dos grupos:
• La API del plano de control le permite realizar tareas administrativas, como crear o actualizar
certificados, objetos, reglas, etc.
• La API del plano de datos le permite enviar datos a AWS IoT Core y recibir datos de este servicio.
El tipo de política que utilice depende de si utiliza la API del plano de control o la del plano de datos.
En la tabla siguiente se muestran los tipos de identidad, los protocolos que utilizan y los tipos de políticas
que se pueden utilizar para la autorización.
API del plano de datos de AWS IoT Core y tipos de políticas
Protocolo y
Tipo de
mecanismo de SDK Tipo de política
identidad
autenticación
MQTT sobre
TLS/TCP,
autenticación SDK de
Certificados Política de
mutua TLS dispositivos de
X.509 AWS IoT Core
(puerto 8883 o AWS IoT Core
† (p. 277)
443) )
Identidad
Políticas de
de Amazon
IAM y AWS IoT
Cognito
MQTT sobre Core
autenticada.
HTTPS/
WebSocket, AWS Mobile Identidad
autenticación SDK de Amazon
Política de IAM
AWS Sigv4 Cognito no
(puerto 443) autenticada
IAM o identidad
Política de IAM
federada
HTTPS, Amazon
AWS CLI Política de IAM
autenticación Cognito, IAM
151
Protocolo y
Tipo de
identidad
autenticación
AWS Signature
o identidad
Versión 4
federada
(puerto 443)
HTTPS,
Sin
autenticación Certificados Política de
compatibilidad
mutua TLS X.509 AWS IoT Core
de SDK
(puerto 8443)
HTTPS sobre
SDK de Política de
autenticación Autorizador
dispositivos de autorizador
personalizada personalizado
AWS IoT Core personalizada
(Puerto 443)
API del plano de control y tipos de política de AWS IoT Core
Protocolo y
Tipo de
identidad
autenticación
HTTPS, Identidad d
autenticación eAmazon Política de IAM
AWS Signature AWS CLI Cognito
Versión 4 IAM o identidad
(puerto 443) Política de IAM
federada
Las políticas de AWS IoT Core están asociadas a certificados X.509 o identidades de Amazon Cognito.
Las políticas de IAM se asocian a un usuario, grupo o rol de IAM. Si utiliza la consola de AWS IoT o la CLI
de AWS IoT Core para asociar la política (a un certificado o a Identidad de Amazon Cognito), utilice una
política de AWS IoT Core. De lo contrario, utilice una política de IAM.
Las autorizaciones basadas en políticas son una herramienta muy eficaz. Le dan un control completo
sobre lo que un dispositivo, usuario o aplicación puede hacer en AWS IoT Core. Por ejemplo, tomemos el
caso de un dispositivo que se conecte con AWS IoT Core mediante un certificado. Puede permitir que el
dispositivo tenga acceso a todos los temas MQTT, o bien puede restringir su acceso a un único tema. O
tomemos, por ejemplo, el caso de un usuario que ejecute comandos de la CLI en una línea de comandos.
Si aplica una política, puede permitirle o denegarle el acceso a cualquier comando o recurso de AWS IoT
Core. También puede controlar el acceso de una aplicación a los recursos de AWS IoT Core.

Para obtener información acerca de la autorización en AWS IoT Core, realice el curso Deep Dive into AWS
IoT Core Authentication and Authorization en el sitio web de AWS Training and Certification.
Políticas de AWS IoT Core

Las políticas de AWS IoT Core son documentos JSON. Siguen las mismas convenciones que las políticas
de IAM. AWS IoT Core admite políticas con un nombre que permita que muchas identidades puedan hacer
referencia al mismo documento de política. Las políticas con nombre cuentan con varias versiones para
facilitar su restauración.
152
Las políticas de AWS IoT Core le permiten controlar el acceso al plano de datos de AWS IoT Core. El
plano de datos de AWS IoT Core se compone de operaciones que le permiten conectarse con el agente
de mensajes de AWS IoT Core, enviar y recibir mensajes MQTT y obtener o actualizar la sombra de un
dispositivo.
Una política de AWS IoT Core es un documento JSON que contiene una o varias declaraciones de política.
Cada instrucción contiene:
• Effect, que especifica si se permite o se deniega la acción.

• Action, que especifica la acción que la política permite o deniega.
• Resource, que especifica los recursos en los que se permite o se deniega la acción.
Temas
• Acciones de política de AWS IoT Core (p. 153)
• Recursos de acción de AWS IoT Core (p. 154)
• Variables de las políticas de AWS IoT Core (p. 155)
• Ejemplos de políticas de AWS IoT (p. 161)
• Autorización con identidades de Amazon Cognito (p. 181)
Acciones de política de AWS IoT Core

AWS IoT Core define las siguientes acciones de política:
Acciones de política de MQTT
iot:Connect
Representa el permiso para conectarse con el agente de mensajes de AWS IoT Core. El permiso
iot:Connect se comprueba cada vez que se envía una solicitud CONNECT al agente. El agente de
mensajes no permite que haya dos clientes con el mismo ID de cliente conectados simultáneamente.
Después de que el segundo cliente se conecta, el agente cierra la conexión existente. El permiso
iot:Connect se puede utilizar para garantizar que solo puedan conectarse los clientes autorizados
que utilizan un ID de cliente específico.
iot:Publish
Representa el permiso de publicar en un tema MQTT. Este permiso se comprueba cada vez que
se envía una solicitud PUBLISH al agente. Se puede utilizar para permitir a los clientes publicar en
determinados patrones de tema.
Note
Para conceder el permiso iot:Publish, también debe otorgar el permiso iot:Connect.

iot:Receive
Representa el permiso para recibir un mensaje de AWS IoT Core. El permiso iot:Receive se
comprueba cada vez que se entrega un mensaje a un cliente. Dado que este permiso se comprueba
en cada entrega, se puede utilizar para revocar permisos a clientes que están suscritos en ese
momento a un tema.
iot:Subscribe
Representa el permiso para suscribirse a un filtro de temas. Este permiso se comprueba cada vez que
se envía una solicitud SUBSCRIBE al agente. Se puede utilizar para permitir a los clientes suscribirse
a temas que coinciden con patrones de tema específicos.
153
Note
Para conceder el permiso iot:Subscribe, también debe otorgar el permiso iot:Connect.
Acciones de política de sombra
iot:DeleteThingShadow
Representa el permiso para eliminar la sombra de un dispositivo. El permiso

iot:DeleteThingShadow se comprueba cada vez que se presenta una solicitud para eliminar el
contenido de la sombra.
iot:GetThingShadow
Representa el permiso para recuperar la sombra de un dispositivo. El permiso iot:GetThingShadow

se comprueba cada vez que se presenta una solicitud para recuperar el contenido de la sombra.
iot:UpdateThingShadow
Representa el permiso para actualizar la sombra de un dispositivo. El permiso

iot:UpdateThingShadow se comprueba cada vez que se presenta una solicitud para actualizar el
Note
Las acciones de política de ejecución de trabajo se aplican únicamente al punto de enlace HTTP
TLS. Si utiliza el punto de enlace MQTT, debe utilizar las acciones de política MQTT definidas en
este tema.
Acciones de política de AWS IoT Core de ejecución de trabajo
iot:DescribeJobExecution
Representa el permiso para recuperar una ejecución de trabajo para un objeto determinado. El
permiso iot:DescribeJobExecution se comprueba cada vez que se presenta una solicitud para
obtener la ejecución de un trabajo.
iot:GetPendingJobExecutions
Representa el permiso para recuperar la lista de trabajos que no están en un estado final para un
objeto. El permiso iot:GetPendingJobExecutions se comprueba cada vez que se presenta una
solicitud para recuperar la lista.
iot:UpdateJobExecution
Representa el permiso para actualizar una ejecución de trabajo. El permiso

iot:UpdateJobExecution se comprueba cada vez que se presenta una solicitud para actualizar el
estado de una ejecución de trabajo.
iot:StartNextPendingJobExecution
Representa el permiso para obtener e iniciar la próxima ejecución de trabajo pendiente para un objeto,
es decir, para actualizar una ejecución de trabajo con un estado QUEUED a IN_PROGRESS. El
permiso iot:StartNextPendingJobExecution se comprueba cada vez que se presenta una
solicitud para iniciar la siguiente ejecución de trabajo pendiente.
Recursos de acción de AWS IoT Core

Para especificar un recurso para una acción de política de AWS IoT Core, debe utilizar el ARN del recurso.
Todos los ARN de recursos tienen la forma siguiente:
154
arn:aws:iot:region:AWS account ID:resource type/resource name
En la tabla siguiente se muestra el recurso que debe especificarse para cada tipo de acción:
Acción Recurso
iot:DeleteThingShadow Un ARN de objeto: arn:aws:iot:us-

east-1:123456789012:thing/thingOne
iot:Connect Un ARN de ID de cliente: arn:aws:iot:us-

east1:123456789012:client/myClientId
iot:Publish Un ARN de tema: arn:aws:iot:us-

east-1:123456789012:topic/myTopicName
iot:Subscribe Un ARN de filtro de tema: arn:aws:iot:us-

east-1:123456789012:topicfilter/
myTopicFilter
iot:Receive Un ARN de tema: arn:aws:iot:us-

east-1:123456789012:topic/myTopicName
iot:UpdateThingShadow Un ARN de objeto: arn:aws:iot:us-

iot:GetThingShadow Un ARN de objeto: arn:aws:iot:us-

iot:DescribeJobExecution Un ARN de objeto: arn:aws:iot:us-

iot:GetPendingJobExecutions Un ARN de objeto: arn:aws:iot:us-

iot:UpdateJobExecution Un ARN de objeto: arn:aws:iot:us-

iot:StartNextPendingJobExecution Un ARN de objeto: arn:aws:iot:us-

Variables de las políticas de AWS IoT Core

AWS IoT Core define las variables de política que se pueden utilizar en las políticas de AWS IoT Core del
bloque Resource o Condition. Cuando se evalúa una política, las variables de política se sustituyen por
valores reales. Por ejemplo, si un dispositivo se ha conectado al agente de mensajes de AWS IoT Core
con un ID de cliente de 100-234-3456, la variable de política iot:ClientId se sustituye en el documento
de política por 100-234-3456. Para obtener más información acerca de las variables de política, consulte
las páginas IAM Policy Variables y Multi-Value Conditions.
Variables de política de AWS IoT Core básicas

AWS IoT Core define las siguientes variables de política básicas:
• iot:ClientId: el ID de cliente que se utiliza para conectarse con el agente de mensajes de AWS IoT
Core.
• aws:SourceIp: la dirección IP del cliente conectado con el agente de mensajes de AWS IoT Core.
155
La siguiente política de AWS IoT Core muestra una política que utiliza variables de política:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": ["iot:Connect"],
"Resource": [
"arn:aws:iot:us-east-1:123451234510:client/${iot:ClientId}"
]
},
{
"Effect": "Allow",
"Action": ["iot:Publish"],
"Resource": [
"arn:aws:iot:us-east-1:123451234510:topic/my/topic/${iot:ClientId}"
]
}
]
}
En estos ejemplos, ${iot:ClientId} se sustituirá por el ID del cliente conectado al agente de

mensajes de AWS IoT Core cuando se evalúa la política. Cuando utiliza variables de la política como
${iot:ClientId}, puede abrir de forma accidental el acceso a temas que no quería incluir. Por ejemplo,
si utiliza una política que utiliza ${iot:ClientId} para especificar un filtro de temas:
{
"Effect": "Allow",
"Action": ["iot:Subscribe"],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/${iot:ClientId}/topic"
]
}
Un cliente puede conectarse usando + como ID de cliente. Esto puede permitir al usuario suscribirse a
cualquier tema que coincida con el filtro de temas my/+/topic. Como protección contra estas deficiencias
de seguridad, utilice la acción de política iot:Connect para controlar los ID de cliente que pueden
conectarse. Por ejemplo, esta política permite conectarse únicamente a los clientes cuyo ID de cliente sea
clientid1:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/clientid1"
]
}
]
}
Variables de la política de objeto

Las variables de política de objeto le permiten escribir políticas de AWS IoT Core que concedan o
denieguen permisos en función de las propiedades del objeto como el nombre o el tipo de objeto, o
los valores de atributo del objeto. Puede usar variables de política de objeto para aplicar la misma
política para controlar muchos dispositivos de AWS IoT Core. Para obtener más información acerca del
156
aprovisionamiento de dispositivos, consulte Aprovisionamiento de dispositivos. El nombre de objeto se

obtiene a partir del ID de cliente en el mensaje Connect de MQTT que se envía cuando un objeto se
conecta con AWS IoT Core.
Tenga en cuenta lo siguiente cuando utilice variables en las políticas de AWS IoT Core.
• Utilice la API AttachThingPrincipal para asociar certificados y entidades de seguridad (identidades de

Amazon Cognito autenticadas) a un objeto.
• Si reemplaza los nombres de objeto con variables de política de objeto, el valor de clientId en el
mensaje de conexión MQTT o la conexión TLS debe coincidir exactamente con el nombre del objeto.
Las siguientes variables de política de objeto están disponibles:
• iot:Connection.Thing.ThingName
Esta variable se resuelve en el nombre del objeto en el registro de AWS IoT Core para el que se evalúa
la política. AWS IoT Core utiliza el certificado que presenta el dispositivo cuando se autentica para
determinar qué objeto que se va a utilizar para verificar la conexión. Esta variable de política solo está
disponible cuando un dispositivo se conecta utilizando MQTT o MQTT con el protocolo WebSocket.
• iot:Connection.Thing.ThingTypeName
Esta variable se resuelve en el tipo de objeto asociado al objeto para el que se evalúa la política. El
nombre de objeto se establece en el ID de cliente de la conexión MQTT/WebSocket. El nombre de tipo
de objeto se obtiene a partir de una llamada a la API DescribeThing. Esta variable de política solo
está disponible cuando la conexión se establece sobre MQTT o MQTT sobre protocolo WebSocket.
• iot:Connection.Thing.Attributes[attributeName]
Esta variable se resuelve en el valor del atributo especificado asociado al objeto para el que se evalúa
la política. Un objeto puede tener hasta 50 atributos. Cada atributo estará disponible como variable
de política: iot:Connection.Thing.Attributes[attributeName] donde attributeName
es el nombre del atributo. El nombre de objeto se establece en el ID de cliente de la conexión MQTT/
WebSocket. Esta variable de política solo está disponible cuando la conexión se establece sobre MQTT
o MQTT sobre protocolo WebSocket.
• iot:Connection.Thing.IsAttached
Esta variable se resuelve en true si el certificado o la identidad de Amazon Cognito para la que se
evalúa la política está asociada a un objeto de IoT. Puede utilizar esta variable para evitar que un
dispositivo se conecte a AWS IoT Core si presenta un certificado que no está asociado a un objeto de
IoT en el registro de AWS IoT Core.
Variables de política de AWS IoT Core de certificado X.509

Las variables de política de certificado X.509 le permiten escribir políticas de AWS IoT Core que concedan
permisos basados en los atributos de certificado X.509. En las secciones siguientes se describe cómo se
pueden utilizar estas variables de política de certificado.
CertificateId
En la API RegisterCertificate el certificateId aparece en el cuerpo de la respuesta. Para obtener

información sobre su certificado, puede usar el certificateId en DescribeCertificate.
Atributos de emisor
Las siguientes variables de política de AWS IoT Core le permiten autorizar o denegar permisos en función
de atributos de certificado establecidos por el emisor del certificado.
• iot:Certificate.Issuer.DistinguishedNameQualifier
157
• iot:Certificate.Issuer.Country
• iot:Certificate.Issuer.Organization
• iot:Certificate.Issuer.OrganizationalUnit
• iot:Certificate.Issuer.State
• iot:Certificate.Issuer.CommonName
• iot:Certificate.Issuer.SerialNumber
• iot:Certificate.Issuer.Title
• iot:Certificate.Issuer.Surname
• iot:Certificate.Issuer.GivenName
• iot:Certificate.Issuer.Initials
• iot:Certificate.Issuer.Pseudonym
• iot:Certificate.Issuer.GenerationQualifier
Atributos de sujeto
Las siguientes variables de política de AWS IoT Core le permiten conceder o denegar permisos en función
de atributos de sujeto de certificado establecidos por el emisor del certificado.
• iot:Certificate.Subject.DistinguishedNameQualifier
• iot:Certificate.Subject.Country
• iot:Certificate.Subject.Organization
• iot:Certificate.Subject.OrganizationalUnit
• iot:Certificate.Subject.State
• iot:Certificate.Subject.CommonName
• iot:Certificate.Subject.SerialNumber
• iot:Certificate.Subject.Title
• iot:Certificate.Subject.Surname
• iot:Certificate.Subject.GivenName
• iot:Certificate.Subject.Initials
• iot:Certificate.Subject.Pseudonym
• iot:Certificate.Subject.GenerationQualifier
Los certificados X.509 permiten que estos atributos contengan uno o varios valores. De forma
predeterminada, las variables de política de cada atributo de varios valores devuelven el primer valor. Por
ejemplo, el atributo Certificate.Subject.Country podría contener una lista de nombres de países,
pero cuando se evalúa en una política, iot:Certificate.Subject.Country se reemplaza por el
nombre del primer país. Puede solicitar un valor de atributo específico distinto del primero mediante un
índice de base uno. Por ejemplo, iot:Certificate.Subject.Country.1 se sustituye por el nombre
del segundo país en el atributo Certificate.Subject.Country. Si especifica un valor de índice que
no existe (por ejemplo, si pide un tercer valor cuando el atributo solo tiene dos valores asignados), no se
realizará ninguna sustitución y la autorización dará un resultado erróneo. Puede utilizar el sufijo .List en
el nombre de la variable de política para especificar todos los valores del atributo.
Registered devices (2)
Para los dispositivos registrados como objetos en el registro de AWS IoT Core, la siguiente política
permite que los clientes con un nombre de objeto registrado en el registro de AWS IoT Core se
conecten, pero limita el derecho a publicar en un tema específico del nombre de objeto a aquellos
clientes con certificados cuyo atributo Certificate.Subject.Organization se haya establecido
en "Example Corp" o en "AnyCompany". Esta restricción se lleva a cabo mediante un campo
158
"Condition" que especifica una condición que ha de cumplirse para permitir la acción anterior.
En este caso, la condición es que el atributo Certificate.Subject.Organization asociado al
certificado incluya uno de los valores de la lista:
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:Connect"
],
"Resource":[
"arn:aws:iot:us-east-1:123456789012:client/${iot:Connection.Thing.ThingName}"
]
},
{
"Effect":"Allow",
"Action":[
"iot:Publish"
],
"Resource":[
"arn:aws:iot:us-east-1:123456789012:topic/my/topic/
${iot:Connection.Thing.ThingName}"
],
"Condition":{
"ForAllValues:StringEquals":{
"iot:Certificate.Subject.Organization.List":[
"Example Corp",
"AnyCompany"
]
}
}
}
]
}
Unregistered devices (2)
Para los dispositivos no registrados como objetos en el registro de AWS IoT Core, la siguiente
política concede permiso para conectarse a AWS IoT Core con los ID de cliente client1, client2
y client3, pero limita el derecho a publicar en un tema específico del id de cliente a aquellos
clientes con certificados cuyo atributo Certificate.Subject.Organization se haya establecido
en "Example Corp" o en "AnyCompany". Esta restricción se lleva a cabo mediante un campo
"Condition" que especifica una condición que ha de cumplirse para permitir la acción anterior.
En este caso, la condición es que el atributo Certificate.Subject.Organization asociado al
certificado incluya uno de los valores de la lista:
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:Connect"
],
"Resource":[
"arn:aws:iot:us-east-1:123456789012:client/client1",
"arn:aws:iot:us-east-1:123456789012:client/client3"
]
},
{
159
"Effect":"Allow",
"Action":[
"iot:Publish"
],
"Resource":[
],
"Condition":{
"ForAllValues:StringEquals":{
"iot:Certificate.Subject.Organization.List":[
"Example Corp",
"AnyCompany"
]
}
}
}
]
}
Atributos de nombre alternativo del emisor
Las variables de política de AWS IoT Core siguientes le permiten conceder o denegar permisos en función
de los atributos de nombre alternativo del emisor establecidos por el emisor del certificado.
• iot:Certificate.Issuer.AlternativeName.RFC822Name
• iot:Certificate.Issuer.AlternativeName.DNSName
• iot:Certificate.Issuer.AlternativeName.DirectoryName
• iot:Certificate.Issuer.AlternativeName.UniformResourceIdentifier
• iot:Certificate.Issuer.AlternativeName.IPAddress
Atributos de nombre alternativo de sujeto
Las variables de política de AWS IoT Core siguientes le permiten conceder o denegar permisos en función
de los atributos de nombre alternativo del tema establecidos por el emisor del certificado.
• iot:Certificate.Subject.AlternativeName.RFC822Name
• iot:Certificate.Subject.AlternativeName.DNSName
• iot:Certificate.Subject.AlternativeName.DirectoryName
• iot:Certificate.Subject.AlternativeName.UniformResourceIdentifier
• iot:Certificate.Subject.AlternativeName.IPAddress
Otros atributos
Puede utilizar iot:Certificate.SerialNumber para permitir o denegar el acceso a recursos

de AWS IoT Core en función del número de serie de un certificado. La variable de política
iot:Certificate.AvailableKeys contiene el nombre de todas las variables de política de certificado
que contienen valores.
Limitaciones aplicables a las variables de política de certificado X.509
Las siguientes limitaciones se aplican a las variables de política de certificado X.509:
Comodines
Si los atributos de certificado contienen caracteres comodín, la variable de política no se sustituirá

por el valor de atributo de certificado y el texto ${policy-variable} figurará en el documento de
160
la política. Esto puede producir un error de autorización. Se pueden utilizar los siguientes caracteres
comodín: *, $, +, ? y #.
Campos de matriz
Los atributos de certificado que contienen matrices se limitan a cinco elementos. No se tendrán en
cuenta los elementos adicionales.
Longitud de cadena
Todos los valores de cadena están limitados a 1024 caracteres. Si un atributo de certificado contiene
una cadena de más de 1024 caracteres, la variable de política no se sustituirá por el valor de atributo
de certificado y el texto ${policy-variable} figurará en el documento de la política. Esto puede
producir un error de autorización.
Caracteres especiales
Cualquier carácter especial, como ,, ", \, +, =, <, > y ; debe tener el prefijo de una barra invertida (\)
cuando se utiliza en una variable de política. Por ejemplo, Amazon Web Services O=Amazon.com
Inc. L=Seattle ST=Washington C=US se convierte en Amazon Web Service O=
\Amazon.com Inc. L\=Seattle ST\=Washington C\=US.
Ejemplos de políticas de AWS IoT

Consulte los siguientes temas para obtener información sobre los elementos comunes de una política de
AWS IoT. Puede utilizar las políticas de ejemplo para completar tareas comunes en AWS IoT.
Temas
• Elementos de política de AWS IoT (p. 161)
• Ejemplos de política de conexión (p. 162)
• Ejemplos de política de publicación/suscripción (p. 164)
• Ejemplos de políticas de conexión y publicación (p. 176)
• Ejemplos de políticas de certificado (p. 176)
• Ejemplos de políticas de objeto (p. 180)
Ejemplos de políticas
Para obtener más ejemplos de políticas, consulte los siguientes temas en otras secciones de esta guía:
• the section called “Ejemplos de políticas basadas en identidades” (p. 208)

• the section called “Variables de política de AWS IoT Core básicas” (p. 155)
• the section called “Variables de política de AWS IoT Core de certificado X.509” (p. 157)
Elementos de política de AWS IoT

Las políticas de AWS IoT se especifican en un documento JSON. Una política de AWS IoT se compone de
los siguientes elementos:
Versión
Debe establecerse en "2012-10-17".

Efecto
Debe establecerse en "Allow" o "Deny".
161
Acción
Debe establecerse en "iot:operation-name" donde operation-name es una de las siguientes

opciones:
"iot:Connect": conectar a AWS IoT.
"iot:Receive": recepción de mensajes de AWS IoT
"iot:Publish": publicación MQTT.
"iot:Subscribe": suscripción MQTT.
"iot:UpdateThingShadow": actualización de la sombra de un dispositivo.
"iot:GetThingShadow": recuperación de la sombra de un dispositivo.
"iot:DeleteThingShadow": eliminación de la sombra de un dispositivo.

Recurso
Debe establecerse en uno de los valores siguientes:
Cliente: arn:aws:iot:region:account-id:client/client-id
ARN de tema: arn:aws:iot:region:account-id:topic/topic-name
ARN de filtro de temas: arn:aws:iot:region:account-id:topicfilter/topic-filter
Ejemplos de política de conexión

La siguiente política concede permiso para conectarse a AWS IoT Core con el ID de cliente client1:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
}
]
}
La siguiente política deniega el permiso a ID de clientes client1 y client2 para conectar a AWS IoT
Core, a la vez que permite a los dispositivos conectarse mediante un ID de cliente que coincida con el
nombre de un objeto registrado en el registro de AWS IoT Core:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Deny",
"Action": [
"iot:Connect"
162
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
}
]
}
La siguiente política concede permiso a un dispositivo para conectarse utilizando su nombre de objeto
como ID de cliente y para suscribirse al filtro de temas my/topic/filter. El dispositivo debe estar
registrado en AWS IoT Core. Cuando el dispositivo se conecta a AWS IoT Core, debe proporcionar el
certificado asociado con el objeto de IoT en el registro de AWS IoT Core:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/topic/filter"
]
}
]
}
Para los dispositivos no registrados como objetos en el registro de AWS IoT Core, la siguiente política
concede permiso para conectarse utilizando el ID de cliente client1 y para suscribirse al filtro de
temas my/topic:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
163
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/topic"
]
}
]
}
Ejemplos de política de publicación/suscripción

La política que utilice dependerá de cómo se conecte con AWS IoT Core. Puede conectarse con AWS IoT
Core mediante un cliente MQTT, HTTP o WebSocket. Al conectarse con un cliente MQTT, se autenticará
con un certificado X.509. Al conectarse mediante HTTP o el protocolo WebSocket, se autenticará con
Signature Version 4 y Amazon Cognito.
Políticas para clientes MQTT
Para especificar caracteres comodín en los nombres de los temas, utilice * en el atributo resource de la
política cuando el dispositivo publique y se suscriba a varios temas. La política siguiente permite que un
dispositivo publique en todos los subtemas que comiencen con el mismo nombre de objeto.
concede permiso para conectarse a AWS IoT Core utilizando un ID de cliente que coincide con el
nombre de objeto y para publicar en cualquier tema que tenga como prefijo el nombre del objeto:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/
${iot:Connection.Thing.ThingName}",
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/
${iot:Connection.Thing.ThingName}/*"
]
}
]
}
164
concede permiso para conectarse a AWS IoT Core utilizando el ID de cliente client1, client2 o
client3 y para publicar en cualquier tema que tenga como prefijo el ID de cliente:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
}
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:ClientId}/*"
]
}
]
}
También puede utilizar el comodín * al final del filtro de un tema. El uso de caracteres comodín podría dar
lugar a la concesión de privilegios no deseados, por lo que solo deben utilizarse teniendo especial cuidado.
Una situación en la que podrían ser útiles es cuando los dispositivos deben suscribirse a mensajes
con muchos temas distintos (por ejemplo si un dispositivo debe suscribirse a informes de sensores de
temperatura en varias ubicaciones).
concede permiso para conectarse a AWS IoT Core utilizando como ID de cliente el nombre de objeto
del dispositivo y para suscribirse a un tema que tenga como prefijo el nombre del objeto, seguido de
room, seguido de cualquier cadena. (Se espera que estos temas sean, por ejemplo thing1/room1,
thing1/room2, etc.):
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
165
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/
${iot:Connection.Thing.ThingName}/room*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/
${iot:Connection.Thing.ThingName}/room*"
]
}
]
}
concede permiso para conectarse a AWS IoT Core utilizando los ID de cliente client1, client2
y client3, y para suscribirse a un tema que tenga como prefijo el ID de cliente, seguido de room,
seguido de cualquier cadena. (Se espera que estos temas sean, por ejemplo client1/room1,
client1/room2, etc.):
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/${iot:ClientId}/room*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:ClientId}/room*"
]
}
]
}
166
Cuando especifique filtros de temas en políticas de AWS IoT Core para clientes MQTT, los caracteres
comodín "+" y "#" de MQTT se tratarán como caracteres literales. Su uso puede dar lugar a un
comportamiento inesperado.
concede permiso para conectarse a AWS IoT Core con un ID de cliente que coincida con el nombre
del objeto y para suscribirse únicamente al filtro de temas some/+/topic:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/some/+/topic"
]
}
]
}
concede permiso para conectarse a AWS IoT Core con el ID de cliente client1 y para suscribirse
únicamente al filtro de temas some/+/topic:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/some/+/topic"
]
}
]
167
Note
En una política, el carácter comodín de MQTT + se interpreta literalmente, no se considera un

carácter comodín. Los intentos de suscribirse a filtros de temas que coincidan con el patrón
some/+/topic dan un error y hacen que el cliente se desconecte.
concede permiso para conectarse a AWS IoT Core utilizando el nombre de objeto del dispositivo como
ID de cliente y para suscribirse a los temas my/topic y my/othertopic:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/topic",
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/othertopic"
]
}
]
}
política concede permiso para conectarse a AWS IoT Core utilizando el ID de cliente client1 y para
suscribirse a los temas my/topic y my/othertopic:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
168
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/topic",
"arn:aws:iot:us-east-1:123456789012:topicfilter/my/othertopic"
]
}
]
}
ID de cliente y para suscribirse a un tema único para dicho nombre de objeto o ID de cliente:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/my/topic/
${iot:Thing.ThingName}"
]
}
]
}
concede permiso para conectarse a AWS IoT Core utilizando el ID de cliente client1 y para publicar
en un tema único para dicho ID de cliente:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
169
"Action": [
"iot:Publish"
],
"Resource": [
]
}
]
}
concede permiso para conectarse a AWS IoT Core utilizando como ID de cliente el nombre de objeto
del dispositivo y para publicar en cualquier tema que lleve como prefijo el nombre del objeto o cliente
excepto en el caso de un tema que termine por bar:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:Thing.ThingName}/*"
]
},
{
"Effect": "Deny",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:Thing.ThingName}/bar"
]
}
]
}
concede permiso para conectarse a AWS IoT Core utilizando como ID de cliente client1 y client1,
y para publicar en cualquier tema que lleve como prefijo el ID de cliente utilizado para conectarse,
excepto en el caso de un tema que termine por bar:
{
"Version": "2012-10-17",
"Statement": [
170
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:ClientId}/*"
]
},
{
"Effect": "Deny",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:ClientId}/bar"
]
}
]
}
ID de cliente. El dispositivo se puede suscribir al tema my/topic, pero no puede publicar en <thing-
name> /bar, donde <thing-name> es el nombre del objeto de IoT que se conecta a AWS IoT Core:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
]
},
{
"Effect": "Deny",
"Action": [
171
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/${iot:Thing.ThingName}/bar"
]
}
]
}
política concede permiso para conectarse a AWS IoT Core utilizando el ID de cliente client1 y para
suscribirse al tema my/topic:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
]
}
]
}
Las variables de política de objeto también se sustituyen cuando se asocia un certificado o una Identidad
de Amazon Cognito autenticada a un objeto. La siguiente política concede permiso para conectarse
con AWS IoT Core con el ID del cliente client1 y para publicar y recibir el tema iotmonitor/
provisioning/987654321098. También permite que el titular del certificado se suscriba este tema.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
172
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/iotmonitor/
provisioning/987654321098"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/iotmonitor/
provisioning/987654321098"
]
}
]
}
Políticas para clientes de HTTP y WebSocket
Para las siguientes operaciones, AWS IoT Core utiliza políticas de AWS IoT Core asociadas a identidades
de Amazon Cognito (mediante la API AttachPolicy) para reducir el ámbito de los permisos asociados al
grupo de Identidad de Amazon Cognito con identidades autenticadas. Esto significa que una Identidad de
Amazon Cognito necesita el permiso de la política de rol de IAM asociada al grupo y la política de AWS IoT
Core asociada a la identidad de Identidad de Amazon Cognito mediante la API AttachPolicy de AWS
IoT Core.
• iot:Connect
• iot:Publish
• iot:Subscribe
• iot:Receive
• iot:GetThingShadow
• iot:UpdateThingShadow
• iot:DeleteThingShadow
Note
En el caso de otras operaciones de AWS IoT Core o de identidades sin autenticar, AWS IoT
Core no reduce el ámbito de los permisos asociados al rol del grupo de identidades de Amazon
Cognito. Para las identidades autenticadas y sin autenticar, esta es la política más permisiva que
recomendamos asociar al rol del grupo de Amazon Cognito.
HTTP
Para permitir que identidades de Amazon Cognito sin autenticar publiquen mensajes sobre HTTP en un
tema específico de Identidad de Amazon Cognito, asocie la política siguiente al rol de grupo de Identidad
de Amazon Cognito:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/${cognito-
identity.amazonaws.com:sub}"]
}
173
]
}
Para permitir usuarios autenticados, asocie la política anterior al rol del grupo de Identidad de Amazon
Cognito y al Identidad de Amazon Cognito utilizando la API AttachPolicy de AWS IoT Core.
Note
Al autorizar identidades de Amazon Cognito, AWS IoT Core tendrá en cuenta ambas políticas y
concederá los mínimos privilegios especificados. Solo se permite una acción si ambas políticas
permiten la acción solicitada. Si una de ellas no permite una acción, esa acción no se autoriza.
MQTT
Para permitir que identidades de Amazon Cognito sin autenticar publiquen mensajes de MQTT sobre
WebSockets en un tema específico de Identidad de Amazon Cognito en su cuenta, asocie la política
siguiente al rol de grupo de Identidad de Amazon Cognito:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/${cognito-
},
{
"Effect": "Allow",
"Action": [
"iot:Connect",
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:client/${cognito-
}
]
}
Para permitir usuarios autenticados, asocie la política anterior al rol del grupo de Identidad de Amazon
Cognito y al Identidad de Amazon Cognito utilizando la API AttachPolicy de AWS IoT Core.
Note
Al autorizar identidades de Amazon Cognito, AWS IoT Core tendrá en cuenta ambas y concederá
los mínimos privilegios especificados. Solo se permite una acción si ambas políticas permiten la
acción solicitada. Si una de ellas no permite una acción, esa acción no se autoriza.
Ejemplos de políticas de recepción
Para los dispositivos registrados en el registro de AWS IoT Core, la siguiente política concede permiso
para conectarse a AWS IoT Core con un ID de cliente que coincide con el nombre de objeto y para
suscribirse y recibir mensajes en el tema my/topic:
{
"Version": "2012-10-17",
"Statement": [
{
174
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:client/
${iot:Connection.Thing.ThingName}"]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/my/topic"
]
}
]
}
Para los dispositivos no registrados en el registro de AWS IoT Core, la siguiente política concede
permiso para conectarse a AWS IoT Core con un ID de cliente client1 y para suscribirse y recibir
mensajes en un tema:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:client/client1"]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/my/topic"
]
}
]
}
175
Ejemplos de políticas de conexión y publicación

concede permiso para conectarse a AWS IoT Core con un ID de cliente que coincida con el nombre de
objeto y limita las publicaciones del dispositivo a un tema de MQTT específico del ID de cliente o nombre
de objeto. Para que una conexión se realice correctamente, el nombre del objeto debe estar registrado en
el registro de AWS IoT Core y se debe autenticar utilizando una identidad o entidad principal asociada al
objeto:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action":["iot:Publish"],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/
},
{
"Effect": "Allow",
}
]
}
concede permiso para conectarse a AWS IoT Core con un ID de cliente client1 y limita las publicaciones
del dispositivo a un tema de MQTT específico del ID de cliente:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/${iot:ClientId}"]
},
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:us-east-1:123456789012:client/client1"]
}
]
}
Ejemplos de políticas de certificado

para conectarse a AWS IoT Core con un ID de cliente que coincide con un nombre de objeto y para
publicar en un tema cuyo nombre sea igual al certificateId del certificado que el dispositivo utilizó
para autenticarse:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
176
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/${iot:CertificateId}"]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
}
]
}
Para los dispositivos no registrados en el registro de AWS IoT Core, la siguiente política concede permisos
para conectarse a AWS IoT Core con los ID de cliente client1, client2 y client3, y para publicar
en un tema cuyo nombre sea igual al certificateId del certificado que el dispositivo utilizó para
autenticarse:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/${iot:CertificateId}"]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
}
]
}
para conectarse a AWS IoT Core con un ID de cliente que coincide con el nombre de objeto y para publicar
en un tema cuyo nombre sea igual al campo CommonName del sujeto del certificado que el dispositivo
utilizó para autenticarse:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
${iot:Certificate.Subject.CommonName}"]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
177
],
}
]
}
Note
En este ejemplo, el nombre común del sujeto del certificado se utiliza como identificador de
tema, partiendo del supuesto de que el nombre común del sujeto es único para cada certificado
registrado. Si los certificados se comparten entre varios dispositivos, el nombre común del asunto
es el mismo para todos los dispositivos que comparten este certificado, lo que permite publicar
privilegios en el mismo tema desde varios dispositivos (no se recomienda).
Para los dispositivos no registrados en el registro de AWS IoT Core, la siguiente política concede permiso
para conectarse a AWS IoT Core con los ID de cliente client1, client2 y client3, y para publicar en
un tema cuyo nombre sea igual al campo CommonName del sujeto del certificado que el dispositivo utilizó
para autenticarse:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
${iot:Certificate.Subject.CommonName}"]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
}
]
}
Note
En este ejemplo, el nombre común del sujeto del certificado se utiliza como identificador de
tema, partiendo del supuesto de que el nombre común del sujeto es único para cada certificado
registrado. Si los certificados se comparten entre varios dispositivos, el nombre común del asunto
es el mismo para todos los dispositivos que comparten este certificado, lo que permite publicar
privilegios en el mismo tema desde varios dispositivos (no se recomienda).
para conectarse a AWS IoT Core con un ID de cliente que coincide con un nombre de objeto y para
publicar en un tema cuyo nombre tenga como prefijo admin/ cuando el certificado utilizado para autenticar
el dispositivo tenga el campo Subject.CommonName.2 definido en Administrator:
{
"Version": "2012-10-17",
"Statement": [
{
178
"Effect": "Allow",
"Action": [
"iot:Connect"
],
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/admin/*"],
"Condition": {
"StringEquals": {
"iot:Certificate.Subject.CommonName.2": "Administrator"
}
}
}
]
}
para conectarse a AWS IoT Core con los ID de cliente client1, client2 y client3, y para publicar
en un tema cuyo nombre tenga como prefijo admin/ cuando el certificado utilizado para autenticar el
dispositivo tenga el campo Subject.CommonName.2 definido en Administrator:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/admin/*"],
"Condition": {
"StringEquals": {
"iot:Certificate.Subject.CommonName.2": "Administrator"
}
}
}
]
}
Para los dispositivos registrados en el registro de AWS IoT Core, la siguiente política permite a un
dispositivo utilizar su nombre de objeto para publicar en un tema específico que consiste en admin/
seguido del ThingName cuando el certificado utilizado para autenticar el dispositivo tenga alguno de sus
campos Subject.CommonName establecido en Administrator:
{
"Version": "2012-10-17",
179
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/admin/
${iot:Connection.Thing.ThingName}"],
"Condition": {
"ForAnyValue:StringEquals": {
"iot:Certificate.Subject.CommonName.List": "Administrator"
}
}
}
]
}
para conectarse a AWS IoT Core con los ID de cliente client1, client2 y client3, y para publicar en
el tema admin cuando el certificado utilizado para autenticar el dispositivo tenga alguno de sus campos
Subject.CommonName definido en Administrator:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/admin"],
"Condition": {
"ForAnyValue:StringEquals": {
"iot:Certificate.Subject.CommonName.List": "Administrator"
}
}
}
]
}
Ejemplos de políticas de objeto

La siguiente política permite a un dispositivo conectarse si el certificado utilizado para realizar la
autenticación en AWS IoT Core está asociado al objeto cuya política se evalúa:
180
Autorización de llamadas directas a los servicios de AWS
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":["iot:Connect"],
"Resource":[ "*" ],
"Condition": {
"Bool": {
"iot:Connection.Thing.IsAttached": ["true"]
}
}
}
]
}
Autorización con identidades de Amazon Cognito

Hay dos tipos de identidades de Amazon Cognito: autenticadas y sin autenticar. Cuando la aplicación
admite identidades de Amazon Cognito no autenticadas, no se realiza ninguna autenticación, por lo que no
se sabe quién es el usuario. Para usuarios no autenticados, se concede permiso asociando un rol de IAM
a un grupo de identidades no autenticado. Debe conceder acceso solo a los recursos que desee que estén
disponibles para usuarios desconocidos.
Cuando la aplicación admite identidades de Amazon Cognito autenticadas, se especifica una política en
dos lugares. Se asocia una política de IAM al grupo de Identidad de Amazon Cognito autenticado y se
asocia una política de AWS IoT Core a la Identidad de Amazon Cognito. Se asocia una política de IAM a
un grupo de Identidad de Amazon Cognito mediante la consola de Identidad de Amazon Cognito al crear
un grupo de Identidad de Amazon Cognito. Para asociar una política de AWS IoT Core a una Identidad de
Amazon Cognito, debe definir una función de Lambda que llame AttachPolicy.
Autorización de llamadas directas a los servicios de

AWS
Los dispositivos pueden utilizar certificados X.509 para conectarse a AWS IoT Core mediante protocolos
de autenticación mutua de TLS. Otros servicios de AWS no admiten la autenticación de certificados,
sino que se pueden llamar a través de las credenciales de AWS en formato AWS Signature Version 4. El
algoritmo Signature Version 4 normalmente requiere que el intermediario tenga un ID de clave de acceso
y una clave de acceso secreta. AWS IoT Core tiene un proveedor de credenciales que le permite utilizar
el certificado X.509 integrado como la identidad de dispositivo única para autenticar solicitudes de AWS.
Así se elimina la necesidad de almacenar un ID de clave de acceso y una clave de acceso secreta en el
dispositivo.
El proveedor de credenciales autentica a un intermediario mediante un certificado X.509 y emite un token

de seguridad temporal con privilegios limitados. El token se puede utilizar para firmar y autenticar cualquier
solicitud de AWS. Esta forma de autenticación de sus solicitudes de AWS requiere que cree y configure un
rol de AWS Identity and Access Management (IAM) y asocie las políticas de IAM adecuadas para el rol, de
modo que el proveedor de credenciales pueda asumir el rol en su nombre. Para obtener más información
sobre AWS IoT Core y IAM, consulte Administración de identidad y acceso en AWS IoT (p. 189).
En el siguiente diagrama se ilustra el flujo de trabajo del proveedor de credenciales.
181
1. El dispositivo de AWS IoT Core realiza una solicitud HTTPS al proveedor de credenciales para un token
de seguridad. La solicitud incluye el certificado X.509 del dispositivo para autenticación.
2. El proveedor de credenciales reenvía la solicitud al módulo de autenticación y autorización de AWS
IoT Core para validar el certificado y verificar que el dispositivo tiene permiso para solicitar el token de
seguridad.
3. Si el certificado es válido y tiene permiso para solicitar un token de seguridad, el módulo de
autenticación y autorización de AWS IoT Core indica que se ha realizado correctamente. De lo contrario,
envía una excepción al dispositivo.
4. Después de validar correctamente el certificado, el proveedor de credenciales invoca a AWS Security
Token Service (AWS STS) para asumir el rol de IAM que creó para el mismo.
5. AWS STS devuelve un token de seguridad temporal con privilegios limitados al proveedor de
credenciales.
6. El proveedor de credenciales devuelve el token de seguridad al dispositivo.
7. El dispositivo utiliza el token de seguridad para firmar una solicitud de AWS con AWS Signature Version
4.
8. El servicio solicitado invoca a IAM para validar la firma y autorizar la solicitud frente a políticas de
acceso asociadas al rol de IAM que creó para el proveedor de credenciales.
9. Si IAM valida la firma correctamente y autoriza la solicitud, la solicitud se realiza correctamente. De lo
contrario, IAM envía una excepción.
En la siguiente sección se describe cómo utilizar un certificado para obtener un token de seguridad. Se
ha escrito suponiendo que ya ha registrado un dispositivo y creado y activado su propio certificado para el
mismo.
182
Cómo utilizar un certificado para obtener un token de seguridad

1. Configure el rol de IAM que el proveedor de credenciales asume en nombre de su dispositivo. Adjunte
la siguiente política de confianza al rol.
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Principal": {"Service": "credentials.iot.amazonaws.com"},
"Action": "sts:AssumeRole"
}
}
Para cada servicio de AWS que desee llamar, adjunte una política de acceso al rol. El proveedor de
credenciales admite las siguientes variables de políticas:
• credentials-iot:ThingName
• credentials-iot:ThingTypeName
• credentials-iot:AwsCertificateId
Cuando el dispositivo proporciona el nombre de objeto en su solicitud a un servicio de AWS,

el proveedor de credenciales añade credentials-iot:ThingName y credentials-
iot:ThingTypeName como variables de contexto para el token de seguridad. El proveedor de
credenciales proporciona credentials-iot:AwsCertificateId como una variable de contexto
incluso si el dispositivo no proporciona el nombre del objeto en la solicitud. Transfiera el nombre del
objeto como valor del encabezado de solicitud HTTP x-amzn-iot-thingname.
Estas tres variables solo funcionan para las políticas de IAM, no para las políticas de AWS IoT Core.
2. Asegúrese de que el usuario que realiza el siguiente paso (la creación de un alias de rol) tiene permiso
para transferir a AWS IoT Core el rol que se acaba de crear. La política siguiente otorga permisos
iam:GetRole y iam:PassRole a un usuario de AWS. El permiso iam:GetRole permite al usuario
obtener información acerca del rol que acaba de crear. El permiso iam:PassRole permite al usuario
transmitir el rol a otro servicio de AWS.
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::your aws account id:role/your role name"
}
}
3. Crear un alias de rol de AWS IoT Core. El dispositivo que va a realizar llamadas directas a servicios de
AWS debe saber qué ARN de rol usar cuando se conecta a AWS IoT Core. La codificación de forma
rígida de un ARN de rol no es una buena solución, ya que requiere actualizar el dispositivo cada vez
que el ARN del rol cambia. Una solución mejor consiste en utilizar la API CreateRoleAlias para
crear un alias de rol que apunte al ARN del rol. Si el ARN del rol cambia, solo tiene que actualizar el
alias de rol. No es necesario realizar ningún cambio en el dispositivo. Esta API adopta los siguiente
parámetros:
183
roleAlias
Obligatorio. Una cadena arbitraria que identifica el alias del rol. Sirve como clave principal en el
modelo de datos del alias de rol. Contiene 1-128 caracteres y debe incluir únicamente caracteres
alfanuméricos y los símbolos =, @ y -. Se permiten los caracteres alfabéticos en mayúsculas y
minúsculas.
roleArn
Obligatorio. El ARN del rol al que hace referencia el alias del rol.
credentialDurationInSeconds
Opcional. El tiempo (en segundos) que la credencial es válida. El valor mínimo es de 900
segundos (15 minutos). El valor máximo es de 3 600 segundos (60 minutos). El valor de
predeterminado es de 3600 segundos.
Para obtener más información sobre esta API, consulte CreateRoleAlias.

4. Adjunte una política al certificado de dispositivo. La política adjunta al certificado del dispositivo debe
conceder permiso al dispositivo para asumir el rol. Para ello, puede conceder permiso para la acción
iot:AssumeRoleWithCertificate al alias de rol, como en el ejemplo siguiente.
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iot:AssumeRoleWithCertificate",
"Resource": "arn:aws:iot:your region:your_aws_account_id:rolealias/your role
alias"
}
}
5. Realice una solicitud HTTPS al proveedor de credenciales para obtener un token de seguridad.
Proporcione la información siguiente:
• Certificado: dado que se trata de una solicitud HTTP a través de autenticación mutua de TLS, debe
proporcionar el certificado y la clave privada a su cliente al realizar la solicitud. Utilice el mismo
certificado y clave privada utilizados cuando registró su certificado con AWS IoT Core.
Para asegurarse de que un dispositivo se comunica con AWS IoT Core (y no con un servicio que lo
suplante), consulte Autenticación del servidor, siga los enlaces para descargar los certificados de
entidad de certificación apropiados y, a continuación, cópielos en el dispositivo.
• RoleAlias: el nombre del alias de rol que creó para el proveedor de credenciales.
• ThingName: el nombre de objeto que creó al registrar su objeto de AWS IoT Core. Esto se transfiere
como valor del encabezado HTTP x-amzn-iot-thingname. Este valor es obligatorio únicamente
si utiliza atributos de objetos como variables de política en políticas de AWS IoT Core o IAM.
Ejecute el siguiente comando en la AWS CLI para obtener el punto de enlace del proveedor de
credenciales para su cuenta de AWS. Para obtener más información sobre esta API, consulte
DescribeEndpoint.
aws iot describe-endpoint --endpoint-type iot:CredentialProvider
El siguiente objeto de JSON es la salida de ejemplo del comando describe-endpoint. Contiene el

endpointAddress que utiliza para solicitar un token de seguridad.
184
Acceso entre cuentas
"endpointAddress": "your_aws_account_specific_prefix.credentials.iot.your
region.amazonaws.com"
}
Utilice el punto de enlace para realizar una solicitud HTTPS al proveedor de credenciales para
devolver un token de seguridad. El ejemplo de comando siguiente utiliza curl, pero puede utilizar
cualquier cliente HTTP.
curl ‐‐cert your certificate --key your device certificate key pair -H "x-amzn-iot-
thingname: your thing name" --cacert AmazonRootCA1.pem https://your endpoint /role-
aliases/your role alias/credentials
Este comando devuelve un objeto de token de seguridad objeto que contiene un accessKeyId, una
secretAccessKey, un sessionToken y un vencimiento. El siguiente objeto de JSON es la salida de
ejemplo del comando curl.
{"credentials":{"accessKeyId":"access key","secretAccessKey":"secret access

key","sessionToken":"session token","expiration":"2018-01-18T09:18:06Z"}}
A continuación, puede utilizar los valores accessKeyId, secretAccessKey y sessionToken para

firmar solicitudes a los servicios de AWS. Para ver una demostración completa, consulte la publicación
del blog How to Eliminate the Need for Hardcoded AWS Credentials in Devices by Using the AWS IoT
Credential Provider en el Blog de seguridad de AWS.
Acceso entre cuentas

AWS IoT Core le permite habilitar un principal para publicar en un tema o suscribirse a un tema definido
en una cuenta de AWS que no es propiedad de la entidad principal. El acceso entre cuentas se configura
creando una política de IAM y un rol de IAM y, a continuación, asociando la política al rol.
En primer lugar, cree una política de IAM administrada por el cliente tal como se describe en Crear
políticas de IAM, como haría para otros usuarios y certificados en su cuenta de AWS.
Para los dispositivos registrados en el registro de AWS IoT Core, la siguiente política concede permiso a
los dispositivos para conectarse a AWS IoT Core utilizando un ID de cliente que coincide con el nombre de
objeto del dispositivo y para publicar en el tema my/topic/<thing-name> , donde <thing-name> es
el nombre de objeto del dispositivo:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/my/topic/
${iot:Connection.Thing.ThingName}"],
}
185
Protección de los datos
]
}
a un dispositivo para utilizar el nombre de objeto client1 registrado en el registro de AWS IoT Core de su
cuenta (123456789012) para conectarse a AWS IoT Core y para publicar en un tema específico del ID de
cliente cuyo nombre lleva el prefijo my/topic/:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
]
}
]
}
A continuación, siga los pasos que se indican en Creación de un rol para delegar permisos a un usuario de
IAM. Especifique el ID de la cuenta de AWS con la que quiere compartir el acceso. A continuación, en el
último paso, asocie al rol la política que acaba de crear. Si posteriormente debe modificar el ID de cuenta
de AWS al que concede acceso, puede utilizar el siguiente formato de política de confianza:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"AWS": "arn:aws:iam:us-east-1:567890123456:user:MyUser"
},
"Action": "sts:AssumeRole",
}
]
}
Protección de los datos en AWS IoT Core

AWS IoT cumple los requisitos del modelo de responsabilidad compartida de AWS, que incluye
reglamentos y directrices para la protección de los datos. AWS es responsable de proteger la
infraestructura global que ejecuta todos los servicios de AWS. AWS mantiene el control de los datos
alojados en esta infraestructura, incluidos los controles de configuración de la seguridad para el tratamiento
del contenido y los datos personales de los clientes. Los clientes de AWS y los socios de APN, que actúan
como controladores o procesadores de datos, son responsables de todos los datos personales que
colocan en la nube de AWS.
186
Seguridad de transporte en AWS IoT
En aras de la protección de datos, le recomendamos proteger las credenciales de la cuenta de AWS y

configurar cuentas de usuario individuales con AWS Identity and Access Management (IAM), de modo que
a cada usuario se le concedan únicamente los permisos necesarios para llevar a cabo su trabajo. También
le recomendamos proteger sus datos de las siguientes formas:
• Utilice la autenticación multifactor (MFA) con cada cuenta.

• Utilice SSL/TLS para comunicarse con los recursos de AWS.
• Configure la API y el registro de actividad del usuario con AWS CloudTrail.

• Utilice las soluciones de cifrado de AWS, junto con todos los controles de seguridad predeterminados en
los servicios de AWS.
• Utilice los servicios de seguridad administrados avanzados como, por ejemplo, Amazon Macie, que
ayudan a detectar y proteger los datos personales almacenados en Amazon S3.
Le recomendamos encarecidamente que nunca introduzca información de identificación confidencial,

como, por ejemplo, números de cuenta de sus clientes, en los campos de formato libre, como el campo
Name (Nombre). No debe introducir esta información cuando trabaje con AWS IoT u otros servicios de
AWS a través de la consola, la API, la AWS CLI de AWS o los SDK de AWS. Cualquier dato que escriba
en AWS IoT o en otros servicios se puede incluir en los registros de diagnóstico. Cuando proporcione una
URL a un servidor externo, no incluya información de credenciales en la URL para validar la solicitud para
ese servidor.
Para obtener más información sobre la protección de datos, consulte la entrada de blog relativa al modelo
de responsabilidad compartida de AWS y GDPR en el blog de seguridad de AWS.
Los dispositivos de AWS IoT recopilan datos, realizan alguna manipulación en dichos datos y, a
continuación, los envían a otro servicio web. Es posible que decida almacenar algunos datos en su
dispositivo durante un breve período de tiempo. Usted es responsable de proporcionar cualquier protección
de datos sobre dichos datos en reposo. Cuando el dispositivo le envía datos, AWS IoT lo hace a través de
una conexión TLS, como se explica más adelante en esta sección. Los dispositivos de AWS IoT pueden
enviar datos a cualquier servicio de AWS. Para obtener más información acerca de la seguridad de datos
de cada servicio, consulte la documentación de ese servicio. AWS IoT se puede configurar para escribir
registros en CloudWatch Logs y registrar llamadas a la API de AWS IoT en AWS CloudTrail. Para obtener
más información acerca de la seguridad de datos para estos servicios, consulte Autenticación y control de
acceso para Amazon CloudWatch y Cifrado de archivos de registro de CloudTrail con claves administradas
por AWS KMS.
Seguridad de transporte en AWS IoT

El agente de mensajes de AWS IoT y el servicio Device Shadow cifran todas las comunicaciones con
TLS versión 1.2. TLS se utiliza para garantizar la confidencialidad de los protocolos de aplicación (MQTT,
HTTP) que AWS IoT admite. TLS está disponible en una serie de lenguajes de programación y sistemas
operativos.
Para MQTT, TLS cifra la conexión entre el dispositivo y el agente. AWS IoT utiliza la autenticación de
cliente de TLS para identificar los dispositivos. Para HTTP, TLS cifra la conexión entre el dispositivo y el
agente. La autenticación se delega a AWS Signature Version 4.
AWS IoT requiere que los dispositivos envíen la extensión Indicación de nombre de servidor (SNI) al
protocolo Transport Layer Security (TLS) y proporcionen la dirección completa del punto de enlace en el
campo host_name. El campo host_name debe contener el punto de enlace al que está llamando y debe
ser:
• El valor de endpointAddress devuelto por aws iot describe-endpoint --endpoint-type iot:Data-ATS
o bien
187
Cifrado de datos
• El valor de domainName devuelto por aws iot describe-domain-configuration –-domain-configuration-

name "<domain_configuration_name>"
Las conexiones que intenten realizar los dispositivos sin el valor de host_name correcto se rechazarán y
se registrarán en CloudWatch.
Compatibilidad con el conjunto de cifrado de TLS

AWS IoT admite los conjuntos de cifrado siguientes:
• ECDHE-ECDSA-AES128-GCM-SHA256 (recomendado)
• ECDHE-RSA-AES128-GCM-SHA256 (recomendado)
• ECDHE-ECDSA-AES128-SHA256
• ECDHE-RSA-AES128-SHA256
• ECDHE-ECDSA-AES128-SHA
• ECDHE-RSA-AES128-SHA
• ECDHE-ECDSA-AES256-GCM-SHA384
• ECDHE-RSA-AES256-GCM-SHA384
• ECDHE-ECDSA-AES256-SHA384
• ECDHE-RSA-AES256-SHA384
• ECDHE-RSA-AES256-SHA
• ECDHE-ECDSA-AES256-SHA
• AES128-GCM-SHA256
• AES128-SHA256
• AES128-SHA
• AES256-GCM-SHA384
• AES256-SHA256
• AES256-SHA
Cifrado de datos en AWS IoT

La protección de datos se refiere a salvaguardarlos en tránsito (al desplazarse desde y hacia AWS IoT)
y en reposo (almacenado en dispositivos o mediante otros servicios de AWS). Todos los datos enviados
a AWS IoT se envían a través de una conexión TLS utilizando protocolos MQTT o HTTPS, por lo que es
seguro de forma predeterminada en tránsito. Los dispositivos de AWS IoT recopilan datos y luego los
envían a otros servicios de AWS para su posterior procesamiento. Para obtener más información acerca
del cifrado de datos en otros servicios de AWS, consulte la documentación de seguridad de ese servicio.
FreeRTOS proporciona una biblioteca PKCS #11 que resume el almacenamiento de claves, el acceso
a objetos criptográficos y la administración de sesiones. Es su responsabilidad utilizar esta biblioteca
para cifrar los datos en reposo en sus dispositivos. Para obtener más información, consulte https://
docs.aws.amazon.com/freertos/latest/userguide/security-pkcs.htmlBiblioteca de estándar de criptografía de
clave pública (PKCS) 11 de FreeRTOS
Administración de claves en AWS IoT

Todas las conexiones a AWS IoT se realizan mediante TLS, por lo que no se necesitan claves de
cifrado del lado del cliente para la conexión TLS inicial. Los dispositivos deben autenticarse mediante un
certificado X.509 o una Identidad de Amazon Cognito. Puede hacer que AWS IoT genere un certificado
para usted, en cuyo caso generará un par de claves públicas/privadas. Si está utilizando la consola de
AWS IoT, se le pedirá que descargue el certificado y las claves. Si utiliza el comando create-keys-
188
Administración de identidades y accesos
and-certificate de CLI, este devuelve el certificado y las claves. Usted es responsable de copiar el
certificado y la clave privada en su dispositivo y mantenerlos seguros.
Administración de identidad y acceso en AWS IoT

AWS Identity and Access Management (IAM) es un servicio de AWS que ayuda a un administrador a
controlar de forma segura el acceso a los recursos de AWS. Los administradores de IAM controlan quién
puede ser autenticado (iniciar sesión) y estar autorizado (tener permisos) para utilizar los recursos de AWS
IoT. IAM es un servicio de AWS que se puede utilizar sin costo adicional.
Temas
• Público (p. 189)
• Autenticación con identidades de IAM (p. 189)
• Administración de acceso mediante políticas (p. 191)
• Funcionamiento de AWS IoT con IAM (p. 193)
• Ejemplos de políticas basadas en identidades de AWS IoT (p. 208)
• Solución de problemas de identidad y acceso en AWS IoT (p. 211)
Público
La forma en que utilice AWS Identity and Access Management (IAM) difiere, en función del trabajo que
realice en AWS IoT.
Usuario de servicio: si utiliza el servicio AWS IoT para realizar su trabajo, su administrador le proporciona
las credenciales y los permisos que necesita. A medida que utilice más características de AWS IoT
para realizar su trabajo, es posible que necesite permisos adicionales. Entender cómo se administra el
acceso puede ayudarle a solicitar los permisos correctos a su administrador. Si no puede acceder a una
característica en AWS IoT, consulte Solución de problemas de identidad y acceso en AWS IoT (p. 211).
Administrador de servicio: si está a cargo de los recursos de AWS IoT en su empresa, probablemente
tenga acceso completo a AWS IoT. Su trabajo consiste en determinar qué a características y recursos
de AWS IoT deben acceder sus empleados. A continuación, debe enviar solicitudes a su administrador
de IAM para cambiar los permisos de los usuarios de su servicio. Revise la información de esta página
para conocer los conceptos básicos de IAM. Para obtener más información sobre cómo su empresa puede
utilizar IAM con AWS IoT, consulte Funcionamiento de AWS IoT con IAM (p. 193).
Administrator de IAM: si es un administrador de IAM, es posible que quiera conocer información sobre
cómo escribir políticas para administrar el acceso a AWS IoT. Para ver ejemplos de políticas basadas en la
identidad de AWS IoT que puede utilizar en IAM, consulte Ejemplos de políticas basadas en identidades de
AWS IoT (p. 208).
Autenticación con identidades de IAM

En AWS IoT las identidades pueden ser certificados de dispositivo (X.509), identidades de Amazon
Cognito o usuarios o grupos de IAM. En este tema se analizan únicamente identidades de IAM. Para
obtener más información acerca de las otras identidades compatibles con AWS IoT, consulte Autenticación
del cliente (p. 126).
La autenticación es la manera de iniciar sesión en AWS mediante credenciales de identidad. Para obtener
más información acerca del inicio de sesión con la Consola de administración de AWS, consulte La
consola de IAM y la página de inicio de sesión en la Guía del usuario de IAM.
Debe estar autenticado (haber iniciado sesión en AWS) como Usuario de la cuenta raíz de AWS, usuario
de IAM o asumiendo un rol de IAM. También puede utilizar la autenticación de inicio de sesión único de
189
Autenticación con identidades de IAM
su empresa o incluso iniciar sesión con Google o Facebook. En estos casos, su administrador habrá
configurado previamente la federación de identidad mediante roles de IAM. Cuando obtiene acceso a AWS
mediante credenciales de otra empresa, asume un rol indirectamente.
Para iniciar sesión directamente en la Consola de administración de AWS, use su contraseña con su
correo electrónico usuario raíz o su nombre de usuario de IAM. Puede obtener acceso a AWS mediante
programación utilizando sus claves de acceso usuario raíz o de usuario de IAM. AWS proporciona SDK y
herramientas de línea de comandos para firmar criptográficamente su solicitud con sus credenciales. Si no
utiliza las herramientas de AWS, debe firmar usted mismo la solicitud. Para ello, utilice Signature Version
4, un protocolo para autenticar solicitudes de API de entrada. Para obtener más información acerca de la
autenticación de solicitudes, consulte Proceso de firma Signature Version 4 en la AWS General Reference.
Independientemente del método de autenticación que utilice, es posible que también deba proporcionar
información de seguridad adicional. Por ejemplo, AWS le recomienda el uso de la autenticación multifactor
(MFA) para aumentar la seguridad de su cuenta. Para obtener más información, consulte Uso de Multi-
Factor Authentication (MFA) en AWS en la Guía del usuario de IAM.
Usuario raíz de la cuenta de AWS

Cuando se crea por primera vez una cuenta de AWS, se comienza con una única identidad de inicio de
sesión que tiene acceso completo a todos los servicios y recursos de AWS de la cuenta. Esta identidad
recibe el nombre de AWS de la cuenta de usuario raíz y se obtiene acceso a ella iniciando sesión con la
dirección de correo electrónico y la contraseña que utilizó para crear la cuenta. Le recomendamos que
no utilice usuario raíz en sus tareas cotidianas, ni siquiera en las tareas administrativas. En lugar de ello,
es mejor ceñirse a la práctica recomendada de utilizar exclusivamente usuario raíz para crear el primer
usuario de IAM. A continuación, guarde las credenciales de usuario raíz en un lugar seguro y utilícelas
únicamente para algunas tareas de administración de cuentas y servicios.
Usuarios y grupos de IAM

Un usuario de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos para una
sola persona o aplicación. Un usuario de IAM puede tener credenciales a largo plazo, como un nombre
de usuario y una contraseña o un conjunto de claves de acceso. Para obtener más información acerca de
cómo generar claves de acceso, consulte Administración de las claves de acceso de los usuarios de IAM
en la Guía del usuario de IAM. Al generar claves de acceso para un usuario de IAM, asegúrese de ver y
guardar de forma segura el par de claves. No puede recuperar la clave de acceso secreta en el futuro. En
su lugar, debe generar un nuevo par de claves de acceso.
Un grupo de IAM es una identidad que especifica un conjunto de usuarios de IAM. No puede iniciar sesión
como grupo. Puede usar los grupos para especificar permisos para varios usuarios a la vez. Los grupos
facilitan la administración de los permisos de grandes conjuntos de usuarios. Por ejemplo, podría tener un
grupo cuyo nombre fuese Administradores de IAM y conceder permisos a dicho grupo para administrar los
recursos de IAM.
Los usuarios son diferentes de los roles. Un usuario se asocia exclusivamente a una persona o aplicación,
pero la intención es que cualquier usuario pueda asumir un rol que necesite. Los usuarios tienen
credenciales permanentes a largo plazo y los roles proporcionan credenciales temporales. Para obtener
más información, consulte Cuándo crear un usuario de IAM (en lugar de un rol) en la Guía del usuario de
IAM.
Roles de IAM
Un rol de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos. Es similar a
un usuario de IAM, pero no está asociado a una determinada persona. Puede asumir temporalmente un
rol de IAM en la Consola de administración de AWS cambiando de roles. Puede asumir un rol llamando
a una operación de la AWS CLI o de la API de AWS, o utilizando una URL personalizada. Para obtener
más información acerca de los métodos para el uso de roles, consulte Uso de roles de IAM en la Guía del
usuario de IAM.
190
Administración de acceso mediante políticas
Los roles de IAM con credenciales temporales son útiles en las siguientes situaciones:
• Permisos de usuario temporales de IAM: un usuario de IAM puede asumir un rol de IAM para recibir
temporalmente permisos distintos que le permitan realizar una tarea concreta.
• Acceso de usuario federado: En lugar de crear un usuario de IAM, puede utilizar identidades existentes
de AWS Directory Service, del directorio de usuarios de la empresa o de un proveedor de identidades
web. A estas identidades se les llama usuarios federados. AWS asigna una función a un usuario
federado cuando se solicita acceso a través de un proveedor de identidad. Para obtener más
información acerca de los usuarios federados, consulte Usuarios federados y roles en la Guía del
usuario de IAM.
• Acceso entre cuentas: puede utilizar un rol de IAM para permitir que alguien (una entidad principal de
confianza) de otra cuenta obtenga acceso a los recursos de su cuenta. Los roles son la forma principal
de conceder acceso entre cuentas. Sin embargo, con algunos servicios de AWS, puede asociar una
política directamente a un recurso (en lugar de utilizar un rol como proxy). Para obtener información
acerca de la diferencia entre los roles y las políticas basadas en recursos para el acceso entre cuentas,
consulte Cómo los roles de IAM difieren de las políticas basadas en recursos en la Guía del usuario de
IAM.
• Acceso a servicios de AWS: Un rol de servicio es un rol de IAM que un servicio asume para realizar
acciones en su cuenta en su nombre. Al configurar algunos de los entornos de los servicios de AWS,
debe definir un rol que el servicio asumirá. Este rol de servicio debe incluir todos los permisos que
son necesarios para que el servicio pueda acceder a los recursos de AWS que necesita. Los roles de
servicio varían de servicio a servicio, pero muchos le permiten elegir sus permisos, siempre y cuando
se cumplan los requisitos documentados para dicho servicio. Los roles de servicio ofrecen acceso solo
dentro de su cuenta y no se pueden utilizar para otorgar acceso a servicios en otras cuentas. Puede
crear, modificar y eliminar un rol de servicio desde IAM. Por ejemplo, puede crear un rol que permita
a Amazon Redshift tener acceso a un bucket de Amazon S3 en su nombre y, a continuación, cargar
los datos de ese bucket en un clúster de Amazon Redshift. Para obtener más información, consulte
Creación de un rol para delegar permisos a un servicio de AWS en la Guía del usuario de IAM.
• Aplicaciones que se ejecutan en Amazon EC2: Puede utilizar un rol de IAM para administrar
credenciales temporales para las aplicaciones que se ejecutan en una instancia EC2 y realizan
solicitudes de la AWS CLI o la API de AWS. Es preferible hacerlo de este modo a almacenar claves de
acceso en la instancia EC2. Para asignar un rol de AWS a una instancia EC2 y ponerla a disposición de
todas las aplicaciones, cree un perfil de instancia asociado a la misma. Un perfil de instancia contiene el
rol y permite a los programas que se ejecutan en la instancia EC2 obtener credenciales temporales. Para
obtener más información, consulte Uso de un rol de IAM para conceder permisos a aplicaciones que se
ejecutan en instancias Amazon EC2 en la Guía del usuario de IAM.
Para obtener información acerca del uso de los roles de IAM, consulte Cuándo crear un rol de IAM (en vez
de un usuario) en la Guía del usuario de IAM.

Para controlar el acceso en AWS, se crean políticas y se asocian a identidades de IAM o recursos de
AWS. Una política es un objeto de AWS que, cuando se asocia a una identidad o un recurso, define
sus permisos. AWS evalúa estas políticas cuando una entidad principal (usuario raíz, usuario de IAM o
rol de IAM) realiza una solicitud. Los permisos en las políticas determinan si la solicitud se permite o se
deniega. Las mayoría de las políticas se almacenan en AWS como documentos JSON. Para obtener
más información acerca de la estructura y el contenido de los documentos de política JSON, consulte
Información general de las políticas de JSON en la Guía del usuario de IAM.
Un administrador de IAM puede utilizar las políticas para especificar quién tiene acceso a los recursos de
AWS y qué acciones se pueden realizar en dichos recursos. Cada entidad de IAM (usuario o rol) comienza
sin permisos. En otras palabras, de forma predeterminada, los usuarios no pueden hacer nada, ni siquiera
cambiar sus propias contraseñas. Para conceder permiso a un usuario para hacer algo, el administrador
debe asociarle una política de permisos. O bien el administrador puede añadir al usuario a un grupo que
191
tenga los permisos necesarios. Cuando el administrador concede permisos a un grupo, todos los usuarios
de ese grupo obtienen los permisos.
Las políticas de IAM definen permisos para una acción independientemente del método que se utilice
para realizar la operación. Por ejemplo, suponga que dispone de una política que permite la acción
iam:GetRole. Un usuario con dicha política puede obtener información del usuario de la Consola de
administración de AWS, la AWS CLI o la API de AWS.
Políticas basadas en identidad

Las políticas basadas en identidad son documentos de políticas de permisos JSON que puede asociar
a una identidad, como por ejemplo un usuario, un rol o un grupo de IAM. Estas políticas controlan qué
acciones puede realizar dicha identidad, en qué recursos y en qué condiciones. Para obtener más
información acerca de cómo crear una política basada en identidad, consulte Creación de políticas de IAM
en la Guía del usuario de IAM.
Las políticas basadas en identidad pueden clasificarse además como políticas insertadas o políticas
administradas. Las políticas insertadas se integran directamente en un único usuario, grupo o rol. Las
políticas administradas son políticas independientes que puede asociar a varios usuarios, grupos y roles
de su cuenta de AWS. Las políticas administradas incluyen las políticas administradas por AWS y las
políticas administradas por el cliente. Para obtener más información acerca de cómo elegir una política
administrada o una política insertada, consulte Elegir entre políticas administradas y políticas insertadas en
la Guía del usuario de IAM.
Políticas basadas en recursos

Las políticas basadas en recursos son documentos de política JSON que puede asociar a un recurso
como, por ejemplo, un bucket de Amazon S3. Los administradores de servicios pueden utilizar estas
políticas para definir qué acciones puede realizar un principal especificado (miembro de cuenta, usuario o
rol) en dicho recurso y bajo qué condiciones. Las políticas basadas en recursos son políticas insertadas.
No existen políticas basadas en recursos que sean administradas.
Listas de control de acceso (ACL)

Las listas de control de acceso (ACL) son un tipo de política que controlan qué entidades principales
(cuentas, miembros, usuarios o roles) tienen permisos para obtener acceso a un recurso. Las ACL son
similares a las políticas basadas en recursos, aunque no utilizan el formato de documento de política
JSON. Amazon S3, AWS WAF y Amazon VPC son ejemplos de servicios que admiten ACL. Para obtener
más información sobre las ACL, consulte Información general de las Access Control Lists (ACL, Listas de
control de acceso) en la Guía para desarrolladores de Amazon Simple Storage Service.
Otros tipos de políticas

AWS admite otros tipos de políticas menos frecuentes. Estos tipos de políticas pueden establecer el
máximo de permisos que los tipos de políticas más frecuentes le otorgan.
• Límites de permisos: un límite de permisos es una característica avanzada que le permite definir los
permisos máximos que una política basada en identidad puede conceder a una entidad de IAM (usuario
o rol de IAM). Puede establecer un límite de permisos para una identidad. Los permisos resultantes son
la intersección de las políticas basadas en identidades de la entidad y los límites de sus permisos. Las
políticas basadas en recursos que especifiquen el usuario o rol en el campo Principal no estarán
restringidas por el límite de permisos. Una denegación explícita en cualquiera de estas políticas anulará
el permiso. Para obtener más información acerca de los límites de permisos, consulte see Límites de
permisos para las entidades de IAM en la Guía del usuario de IAM.
• Políticas de control de servicios (SCP): las SCP son políticas de JSON que especifican los permisos
máximos para una organización o unidad organizativa (OU) en AWS Organizations. AWS Organizations
es un servicio que le permite agrupar y administrar de forma centralizada varias cuentas de AWS
192
Funcionamiento de AWS IoT con IAM
que posee su negocio. Si habilita todas las funciones en una organización, entonces podrá aplicar
políticas de control de servicio (SCP) a una o todas sus cuentas. Una SCP limita los permisos para las
entidades de las cuentas de miembros, incluido cada Usuario de la cuenta raíz de AWS. Para obtener
más información acerca de Organizaciones y las SCP, consulte Funcionamiento de las SCP en la Guía
del usuario de AWS Organizations.
• Políticas de sesión: las políticas de sesión son políticas avanzadas que se pasan como parámetro
cuando se crea una sesión temporal mediante programación para un rol o un usuario federado. Los
permisos de la sesión resultantes son la intersección de las políticas basadas en identidades del rol y las
políticas de la sesión. Los permisos también pueden proceder de una política basada en recursos. Una
denegación explícita en cualquiera de estas políticas anulará el permiso. Para obtener más información,
consulte Políticas de sesión en la Guía del usuario de IAM.
Varios tipos de políticas

Cuando se aplican varios tipos de políticas a una solicitud, los permisos resultantes son más complicados
de entender. Para obtener información acerca de cómo AWS determina si permitir una solicitud cuando
hay varios tipos de políticas implicados, consulte Lógica de evaluación de políticas en la Guía del usuario
de IAM.

Antes de utilizar IAM para administrar el acceso a AWS IoT, debe saber qué características de IAM están
disponibles para usarse con AWS IoT. Para obtener una perspectiva general de cómo AWS IoT y otros
servicios de AWS funcionan con IAM, consulte Servicios de AWS que funcionan con IAM en la Guía del
usuario de IAM.
Temas
• Políticas de IAM (p. 193)
• Políticas basadas en identidades de AWS IoT (p. 194)
• Políticas basadas en recursos de AWS IoT (p. 207)
• Autorización basada en etiquetas de AWS IoT (p. 208)
• Roles de IAM de AWS IoT: (p. 208)
Políticas de IAM
AWS IoT funciona con políticas de AWS IoT e IAM. En este tema solo se describen las políticas de IAM.
Para obtener más información, consulte Políticas de AWS IoT Core (p. 152). AWS Identity and Access
Management define una acción de política para cada operación que AWS IoT defina, incluidas las API de
plano de control y de plano de datos.
Políticas administradas de IAM

AWS IoT proporciona un conjunto de políticas administradas de IAM que puede utilizar tal y como están,
o bien como punto de partida para crear políticas de IAM personalizadas. Estas políticas le permiten tener
acceso a operaciones de configuración y de datos. Las operaciones de configuración le permiten crear
objetos, certificados, políticas y reglas. Las operaciones de datos envían datos sobre protocolos MQTT y
HTTP. En la tabla siguiente se describen estas plantillas.
Plantilla de política Descripción
AWSIoTConfigAccess Permite a la identidad asociada tener acceso a

todas las operaciones de configuración de AWS
193
Plantilla de política Descripción

IoT. Esta política puede afectar al procesamiento y
al almacenamiento de datos.
AWSIoTConfigReadOnlyAccess Permite a la identidad asociada obtener acceso a

operaciones de configuración de solo lectura.
AWSIoTDataAccess Permite a la identidad asociada tener acceso

completo a todas las operaciones de datos de
AWS IoT. Las operaciones de datos envían datos
sobre protocolos MQTT y HTTP.
AWSIoTEventsFullAccess Permite el acceso completo de la identidad

asociada a los eventos de AWS IoT.
AWSIoTEventsReadOnlyAccess Permite el acceso de solo lectura de la identidad

asociada a los eventos de AWS IoT.
AWSIoTFullAccess Permite a la identidad asociada tener acceso

completo a todas las operaciones de mensajería y
de configuración de AWS IoT.
AWSIoTLogging Permite a la identidad asociada crear grupos de

Amazon CloudWatch Logs y enviar registros de
flujo a los grupos. Esta política se asocia al rol de
registro de CloudWatch.
AWSIoTOTAUpdate Permite que la identidad asociada cree trabajos de

AWS IoT, trabajos de firma de código de AWS IoT
y describir trabajos de firmante de código de AWS.
AWSIoTRuleActions Permite que la identidad asociada tenga acceso

a todos los servicios de AWS admitidos en las
acciones de regla de AWS IoT.
AWSIoTThingsRegistration Permite a la identidad asociada registrar

objetos en bloque mediante la API
StartThingRegistrationTask. Esta política puede
afectar al procesamiento y al almacenamiento de
datos.
Políticas basadas en identidades de AWS IoT

Con las políticas basadas en identidad de IAM, puede especificar las acciones permitidas o denegadas y
los recursos además de las condiciones en las que se permiten o deniegan las acciones. AWS IoT admite
acciones, recursos y claves de condiciones específicos. Para obtener más información acerca de los
elementos que utiliza en una política de JSON, consulte Referencia de los elementos de las políticas de
JSON de IAM en la Guía del usuario de IAM.
Acciones
El elemento Action de una política basada en la identidad de IAM describe la acción o las acciones
específicas que la política permitirá o denegará. Las acciones de la política generalmente tienen el mismo
nombre que la operación de API de AWS asociada. La acción se utiliza en una política para otorgar
permisos para realizar la operación asociada.
En la siguiente tabla se enumeran las acciones de IAM IoT, la API de AWS IoT asociada y el recurso que
manipula la acción.
194
Acciones de API de AWS IoT Recursos

política
iot:AcceptCertificateTransfer
AcceptCertificateTransfer
arn:aws:iot:region:account-id:cert/cert-id
Note
La cuenta de AWS especificada en el ARN debe ser

la cuenta a la que se transfiere el certificado.
iot:AddThingToThingGroup
AddThingToThingGroup
arn:aws:iot:region:account-id:thinggroup/thing-group-
name
arn:aws:iot:region:account-id:thing/thing-name
iot:AssociateTargetsWithJob
AssociateTargetsWithJob
ninguno
iot:AttachPolicy AttachPolicy arn:aws:iot:region:account-id:thinggroup/thing-group-

name
o bien
iot:AttachPrincipalPolicy
AttachPrincipalPolicy arn:aws:iot:region:account-id:cert/cert-id
iot:AttachSecurityProfile
AttachSecurityProfile arn:aws:iot:región:ID-cuenta:securityprofile/nombre-
perfil-seguridad
arn:aws:iot:región:ID-cuenta:dimension/nombre-
dimensión
iot:AttachThingPrincipal
AttachThingPrincipal arn:aws:iot:region:account-id:cert/cert-id
iot:CancelCertificateTransfer
CancelCertificateTransfer
Note

iot:CancelJob CancelJob arn:aws:iot:region:account-id:job/job-id
iot:CancelJobExecution
CancelJobExecution arn:aws:iot:region:account-id:job/job-id
iot:ClearDefaultAuthorizer
ClearDefaultAuthorizer
Ninguno
iot:CreateAuthorizer CreateAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-

function-name
iot:CreateCertificateFromCsr
CreateCertificateFromCsr
*
iot:CreateDimension CreateDimension arn:aws:iot:región:ID-cuenta:dimension/nombre-

dimensión
iot:CreateJob CreateJob arn:aws:iot:region:account-id:job/job-id
iot:CreateKeysAndCertificate
CreateKeysAndCertificate
*
iot:CreatePolicy CreatePolicy *
195

política
iot:CreatePolicyVersion
CreatePolicyVersion arn:aws:iot:region:account-id:policy/policy-name
Note
Debe ser una política de AWS IoT y no una política

de IAM.
iot:CreateRoleAlias CreateRoleAlias (parámetro: roleAlias)
arn:aws:iot:region:account-id:rolealias/role-alias-
name
iot:CreateSecurityProfile
CreateSecurityProfilearn:aws:iot:región:ID-cuenta:securityprofile/nombre-
perfil-seguridad
dimensión
iot:CreateThing CreateThing arn:aws:iot:region:account-id:thing/thing-name
iot:CreateThingGroupCreateThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
para el grupo que se está crenado y para el grupo principal, si

se utiliza
iot:CreateThingType CreateThingType arn:aws:iot:region:account-id:thingtype/thing-type-

name
iot:CreateTopicRule CreateTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:DeleteAuthorizer DeleteAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-

name
iot:DeleteCACertificate
DeleteCACertificate arn:aws:iot:region:account-id:cacert/cert-id
iot:DeleteCertificate DeleteCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:DeleteDimension DeleteDimension arn:aws:iot:región:ID-cuenta:dimension/nombre-

dimensión
iot:DeleteJob DeleteJob arn:aws:iot:region:account-id:job/job-id
iot:DeleteJobExecution
DeleteJobExecution arn:aws:iot:region:account-id:job/job-id
iot:DeletePolicy DeletePolicy arn:aws:iot:region:account-id:policy/policy-name
iot:DeletePolicyVersion
DeletePolicyVersion arn:aws:iot:region:account-id:policy/policy-name
iot:DeleteRegistrationCode
DeleteRegistrationCode
*
iot:DeleteRoleAlias DeleteRoleAlias arn:aws:iot:region:account-id:rolealias/role-alias-

name
196

política
iot:DeleteSecurityProfile
DeleteSecurityProfile arn:aws:iot:región:ID-cuenta:securityprofile/nombre-
perfil-seguridad
dimensión
iot:DeleteThing DeleteThing arn:aws:iot:region:account-id:thing/thing-name
iot:DeleteThingGroupDeleteThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:DeleteThingType DeleteThingType arn:aws:iot:region:account-id:thingtype/thing-type-

name
iot:DeleteTopicRule DeleteTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:DeleteV2LoggingLevel
DeleteV2LoggingLevel
name
iot:DeprecateThingType
DeprecateThingType arn:aws:iot:region:account-id:thingtype/thing-type-
name
iot:DescribeAuthorizerDescribeAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-
function-name
(parámetro: authorizerName)
ninguno
iot:DescribeCACertificate
DescribeCACertificatearn:aws:iot:region:account-id:cacert/cert-id
iot:DescribeCertificateDescribeCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:DescribeDefaultAuthorizer
DescribeDefaultAuthorizer
Ninguno
iot:DescribeEndpoint DescribeEndpoint *
iot:DescribeEventConfigurations
DescribeEventConfigurations
ninguno
iot:DescribeIndex DescribeIndex arn:aws:iot:region:account-id:index/index-name
iot:DescribeJob DescribeJob arn:aws:iot:region:account-id:job/job-id
DescribeJobExecutionNinguno
iot:DescribeRoleAliasDescribeRoleAlias arn:aws:iot:region:account-id:rolealias/role-alias-
name
iot:DescribeThing DescribeThing arn:aws:iot:region:account-id:thing/thing-name
iot:DescribeThingGroup
DescribeThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:DescribeThingRegistrationTask
DescribeThingRegistrationTask
Ninguno
iot:DescribeThingTypeDescribeThingType arn:aws:iot:region:account-id:thingtype/thing-type-
name
197

política
iot:DetachPolicy DetachPolicy arn:aws:iot:region:account-id:cert/cert-id
o bien
name
iot:DetachPrincipalPolicy
DetachPrincipalPolicyarn:aws:iot:region:account-id:cert/cert-id
iot:DetachSecurityProfile
DetachSecurityProfilearn:aws:iot:región:ID-cuenta:securityprofile/nombre-
perfil-seguridad
dimensión
iot:DetachThingPrincipal
DetachThingPrincipalarn:aws:iot:region:account-id:cert/cert-id
iot:DisableTopicRule DisableTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:EnableTopicRule EnableTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:GetEffectivePolicies
GetEffectivePolicies arn:aws:iot:region:account-id:cert/cert-id
iot:GetIndexingConfiguration
GetIndexingConfiguration
Ninguno
iot:GetJobDocument GetJobDocument arn:aws:iot:region:account-id:job/job-id
iot:GetLoggingOptionsGetLoggingOptions *
iot:GetPolicy GetPolicy arn:aws:iot:region:account-id:policy/policy-name
iot:GetPolicyVersion GetPolicyVersion arn:aws:iot:region:account-id:policy/policy-name
iot:GetRegistrationCode
GetRegistrationCode *
iot:GetTopicRule GetTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:ListAttachedPolicies
ListAttachedPolicies arn:aws:iot:region:account-id:thinggroup/thing-group-
name
o bien
iot:ListAuthorizers ListAuthorizers Ninguno
iot:ListCACertificates ListCACertificates *
iot:ListCertificates ListCertificates *
iot:ListCertificatesByCA
ListCertificatesByCA *
iot:ListIndices ListIndices Ninguno
iot:ListJobExecutionsForJob
ListJobExecutionsForJob
Ninguno
iot:ListJobExecutionsForThing
ListJobExecutionsForThing
Ninguno
198

política
iot:ListJobs ListJobs arn:aws:iot:region:account-id:thinggroup/thing-group-

name
si se usa el parámetro thingGroupName
iot:ListOutgoingCertificates
ListOutgoingCertificates
*
iot:ListPolicies ListPolicies *
iot:ListPolicyPrincipalsListPolicyPrincipals arn:aws:iot:region:account-id:policy/policy-name
iot:ListPolicyVersionsListPolicyVersions arn:aws:iot:region:account-id:policy/policy-name
iot:ListPrincipalPolicies
ListPrincipalPolicies arn:aws:iot:region:account-id:cert/cert-id
iot:ListPrincipalThingsListPrincipalThings arn:aws:iot:region:account-id:cert/cert-id
iot:ListRoleAliases ListRoleAliases Ninguno
iot:ListTargetsForPolicy
ListTargetsForPolicy arn:aws:iot:region:account-id:policy/policy-name
iot:ListThingGroups ListThingGroups Ninguno
iot:ListThingGroupsForThing
ListThingGroupsForThing
iot:ListThingPrincipalsListThingPrincipals arn:aws:iot:region:account-id:thing/thing-name
iot:ListThingRegistrationTaskReports
ListThingRegistrationTaskReports
Ninguno
iot:ListThingRegistrationTasks
ListThingRegistrationTasks
Ninguno
iot:ListThingTypes ListThingTypes *
iot:ListThings ListThings *
iot:ListThingsInThingGroup
ListThingsInThingGroup
name
iot:ListTopicRules ListTopicRules *
iot:ListV2LoggingLevels
ListV2LoggingLevels Ninguno
iot:RegisterCACertificate
RegisterCACertificate*
iot:RegisterCertificateRegisterCertificate *
iot:RegisterThing RegisterThing Ninguno
iot:RejectCertificateTransfer
RejectCertificateTransfer
iot:RemoveThingFromThingGroup
RemoveThingFromThingGroup
name
iot:ReplaceTopicRuleReplaceTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:SearchIndex SearchIndex arn:aws:iot:region:account-id:index/index-id
199

política
iot:SetDefaultAuthorizer
SetDefaultAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-
function-name
iot:SetDefaultPolicyVersion
SetDefaultPolicyVersion
arn:aws:iot:region:account-id:policy/policy-name
iot:SetLoggingOptionsSetLoggingOptions arn:aws:iot:region:account-id:role/role-name
iot:SetV2LoggingLevelSetV2LoggingLevel arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:SetV2LoggingOptions
SetV2LoggingOptionsarn:aws:iot:region:account-id:role/role-name
iot:StartThingRegistrationTask
StartThingRegistrationTask
Ninguno
iot:StopThingRegistrationTask
StopThingRegistrationTask
Ninguno
iot:TestAuthorization TestAuthorization arn:aws:iot:region:account-id:cert/cert-id
iot:TestInvokeAuthorizer
TestInvokeAuthorizerNinguno
iot:TransferCertificateTransferCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:UpdateAuthorizer UpdateAuthorizer arn:aws:iot:region:account-

id:authorizerfunction/authorizer-function-name
iot:UpdateCACertificate
UpdateCACertificate arn:aws:iot:region:account-id:cacert/cert-id
iot:UpdateCertificate UpdateCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:UpdateDimension UpdateDimension arn:aws:iot:región:ID-cuenta:dimension/nombre-

dimensión
iot:UpdateEventConfigurations
UpdateEventConfigurations
Ninguno
iot:UpdateIndexingConfiguration
UpdateIndexingConfiguration
Ninguno
iot:UpdateRoleAlias UpdateRoleAlias arn:aws:iot:region:account-id:rolealias/role-alias-

name
iot:UpdateSecurityProfile
UpdateSecurityProfilearn:aws:iot:región:ID-cuenta:securityprofile/nombre-
perfil-seguridad
dimensión
iot:UpdateThing UpdateThing arn:aws:iot:region:account-id:thing/thing-name
iot:UpdateThingGroupUpdateThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:UpdateThingGroupsForThing
UpdateThingGroupsForThing
Las acciones de políticas de AWS IoT utilizan el siguiente prefijo antes de la acción: iot:. Por ejemplo,
para conceder a alguien permiso para obtener una lista de todos los objetos de IoT registrados en su
cuenta de AWS con la API ListThings, debe incluir la acción iot:ListThings en su política. Las
instrucciones de política deben incluir un elemento NotAction o Action. AWS IoT define su propio
conjunto de acciones que describen las tareas que se pueden realizar con este servicio.
200
Para especificar varias acciones en una única instrucción, sepárelas con comas del siguiente modo:
"Action": [
"ec2:action1",
"ec2:action2"
Puede utilizar caracteres comodín para especificar varias acciones (*). Por ejemplo, para especificar todas
las acciones que comiencen con la palabra Describe, incluya la siguiente acción:
"Action": "iot:Describe*"
Para ver una lista de acciones de AWS IoT, consulte Actions Defined by AWS IoT en la Guía del usuario
de IAM.
Recursos
El elemento Resource especifica el objeto u objetos a los que se aplica la acción. Las instrucciones deben
contener un elemento Resource o NotResource. Especifique un recurso con un ARN o el carácter
comodín (*) para indicar que la instrucción se aplica a todos los recursos.
Recursos de AWS IoT

política
iot:AcceptCertificateTransfer
AcceptCertificateTransfer
Note

iot:AddThingToThingGroup
AddThingToThingGroup
name
iot:AssociateTargetsWithJob
ninguno
iot:AttachPolicy AttachPolicy arn:aws:iot:region:account-id:thinggroup/thing-group-

name
o bien
iot:AttachPrincipalPolicy
AttachPrincipalPolicy arn:aws:iot:region:account-id:cert/cert-id
iot:AttachThingPrincipal
AttachThingPrincipal arn:aws:iot:region:account-id:cert/cert-id
iot:CancelCertificateTransfer
CancelCertificateTransfer
Note

iot:CancelJob CancelJob arn:aws:iot:region:account-id:job/job-id
iot:CancelJobExecution
CancelJobExecution arn:aws:iot:region:account-id:job/job-id
201

política
iot:ClearDefaultAuthorizer
ClearDefaultAuthorizer
Ninguno
iot:CreateAuthorizer CreateAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-

function-name
iot:CreateCertificateFromCsr
*
iot:CreateJob CreateJob arn:aws:iot:region:account-id:job/job-id
iot:CreateKeysAndCertificate
*
iot:CreatePolicy CreatePolicy *
CreatePolicyVersion iot:CreatePolicyVersion
Note
Debe ser una política de AWS IoT y no una política

de IAM.
iot:CreateRoleAlias CreateRoleAlias (parámetro: roleAlias)
arn:aws:iot:region:account-id:rolealias/role-alias-
name
iot:CreateThing CreateThing arn:aws:iot:region:account-id:thing/thing-name
iot:CreateThingGroupCreateThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
para el grupo que se está crenado y para el grupo principal, si

se utiliza
iot:CreateThingType CreateThingType arn:aws:iot:region:account-id:thingtype/thing-type-

name
iot:CreateTopicRule CreateTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:DeleteAuthorizer DeleteAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-

name
iot:DeleteCACertificate
DeleteCACertificate arn:aws:iot:region:account-id:cacert/cert-id
iot:DeleteCertificate DeleteCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:DeleteJob DeleteJob arn:aws:iot:region:account-id:job/job-id
iot:DeleteJobExecution
DeleteJobExecution arn:aws:iot:region:account-id:job/job-id
iot:DeletePolicy DeletePolicy arn:aws:iot:region:account-id:policy/policy-name
iot:DeletePolicyVersion
DeletePolicyVersion arn:aws:iot:region:account-id:policy/policy-name
iot:DeleteRegistrationCode
DeleteRegistrationCode
*
202

política
iot:DeleteRoleAlias DeleteRoleAlias arn:aws:iot:region:account-id:rolealias/role-alias-

name
iot:DeleteThing DeleteThing arn:aws:iot:region:account-id:thing/thing-name
iot:DeleteThingGroupDeleteThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:DeleteThingType DeleteThingType arn:aws:iot:region:account-id:thingtype/thing-type-

name
iot:DeleteTopicRule DeleteTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:DeleteV2LoggingLevel
DeleteV2LoggingLevel
name
iot:DeprecateThingType
DeprecateThingType arn:aws:iot:region:account-id:thingtype/thing-type-
name
iot:DescribeAuthorizerDescribeAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-
function-name
(parámetro: authorizerName)
ninguno
iot:DescribeCACertificate
DescribeCACertificatearn:aws:iot:region:account-id:cacert/cert-id
iot:DescribeCertificateDescribeCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:DescribeDefaultAuthorizer
DescribeDefaultAuthorizer
Ninguno
iot:DescribeEndpoint DescribeEndpoint *
iot:DescribeEventConfigurations
DescribeEventConfigurations
ninguno
iot:DescribeIndex DescribeIndex arn:aws:iot:region:account-id:index/index-name
iot:DescribeJob DescribeJob arn:aws:iot:region:account-id:job/job-id
DescribeJobExecutionNinguno
iot:DescribeRoleAliasDescribeRoleAlias arn:aws:iot:region:account-id:rolealias/role-alias-
name
iot:DescribeThing DescribeThing arn:aws:iot:region:account-id:thing/thing-name
iot:DescribeThingGroup
DescribeThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:DescribeThingRegistrationTask
DescribeThingRegistrationTask
Ninguno
iot:DescribeThingTypeDescribeThingType arn:aws:iot:region:account-id:thingtype/thing-type-
name
203

política
iot:DetachPolicy DetachPolicy arn:aws:iot:region:account-id:cert/cert-id
o bien
name
iot:DetachPrincipalPolicy
DetachPrincipalPolicyarn:aws:iot:region:account-id:cert/cert-id
iot:DetachThingPrincipal
DetachThingPrincipalarn:aws:iot:region:account-id:cert/cert-id
iot:DisableTopicRule DisableTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:EnableTopicRule EnableTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:GetEffectivePolicies
GetEffectivePolicies arn:aws:iot:region:account-id:cert/cert-id
iot:GetIndexingConfiguration
GetIndexingConfiguration
Ninguno
iot:GetJobDocument GetJobDocument arn:aws:iot:region:account-id:job/job-id
iot:GetLoggingOptionsGetLoggingOptions *
iot:GetPolicy GetPolicy arn:aws:iot:region:account-id:policy/policy-name
iot:GetPolicyVersion GetPolicyVersion arn:aws:iot:region:account-id:policy/policy-name
iot:GetRegistrationCode
GetRegistrationCode *
iot:GetTopicRule GetTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:ListAttachedPolicies
ListAttachedPolicies arn:aws:iot:region:account-id:thinggroup/thing-group-
name
o bien
iot:ListAuthorizers ListAuthorizers Ninguno
iot:ListCACertificates ListCACertificates *
iot:ListCertificates ListCertificates *
iot:ListCertificatesByCA
ListCertificatesByCA *
iot:ListIndices ListIndices Ninguno
iot:ListJobExecutionsForJob
Ninguno
iot:ListJobExecutionsForThing
Ninguno
iot:ListJobs ListJobs arn:aws:iot:region:account-id:thinggroup/thing-group-

name
si se usa el parámetro thingGroupName
iot:ListOutgoingCertificates
ListOutgoingCertificates
*
204

política
iot:ListPolicies ListPolicies *
iot:ListPolicyPrincipalsListPolicyPrincipals arn:aws:iot:region:account-id:policy/policy-name
iot:ListPolicyVersionsListPolicyVersions arn:aws:iot:region:account-id:policy/policy-name
iot:ListPrincipalPolicies
ListPrincipalPolicies arn:aws:iot:region:account-id:cert/cert-id
iot:ListPrincipalThingsListPrincipalThings arn:aws:iot:region:account-id:cert/cert-id
iot:ListRoleAliases ListRoleAliases Ninguno
iot:ListTargetsForPolicy
ListTargetsForPolicy arn:aws:iot:region:account-id:policy/policy-name
iot:ListThingGroups ListThingGroups Ninguno
iot:ListThingGroupsForThing
ListThingGroupsForThing
iot:ListThingPrincipalsListThingPrincipals arn:aws:iot:region:account-id:thing/thing-name
iot:ListThingRegistrationTaskReports
ListThingRegistrationTaskReports
Ninguno
iot:ListThingRegistrationTasks
ListThingRegistrationTasks
Ninguno
iot:ListThingTypes ListThingTypes *
iot:ListThings ListThings *
iot:ListThingsInThingGroup
ListThingsInThingGroup
name
iot:ListTopicRules ListTopicRules *
iot:ListV2LoggingLevels
ListV2LoggingLevels Ninguno
iot:RegisterCACertificate
RegisterCACertificate*
iot:RegisterCertificateRegisterCertificate *
iot:RegisterThing RegisterThing Ninguno
iot:RejectCertificateTransfer
RejectCertificateTransfer
iot:RemoveThingFromThingGroup
RemoveThingFromThingGroup
name
iot:ReplaceTopicRuleReplaceTopicRule arn:aws:iot:region:account-id:rule/rule-name
iot:SearchIndex SearchIndex arn:aws:iot:region:account-id:index/index-id
iot:SetDefaultAuthorizer
SetDefaultAuthorizer arn:aws:iot:region:account-id:authorizer/authorizer-
function-name
iot:SetDefaultPolicyVersion
SetDefaultPolicyVersion
iot:SetLoggingOptionsSetLoggingOptions arn:aws:iot:region:account-id:role/role-name
205

política
iot:SetV2LoggingLevelSetV2LoggingLevel arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:SetV2LoggingOptions
SetV2LoggingOptionsarn:aws:iot:region:account-id:role/role-name
iot:StartThingRegistrationTask
StartThingRegistrationTask
Ninguno
iot:StopThingRegistrationTask
StopThingRegistrationTask
Ninguno
iot:TestAuthorization TestAuthorization arn:aws:iot:region:account-id:cert/cert-id
iot:TestInvokeAuthorizer
TestInvokeAuthorizerNinguno
iot:TransferCertificateTransferCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:UpdateAuthorizer UpdateAuthorizer arn:aws:iot:region:account-

id:authorizerfunction/authorizer-function-name
iot:UpdateCACertificate
UpdateCACertificate arn:aws:iot:region:account-id:cacert/cert-id
iot:UpdateCertificate UpdateCertificate arn:aws:iot:region:account-id:cert/cert-id
iot:UpdateEventConfigurations
UpdateEventConfigurations
Ninguno
iot:UpdateIndexingConfiguration
UpdateIndexingConfiguration
Ninguno
iot:UpdateRoleAlias UpdateRoleAlias arn:aws:iot:region:account-id:rolealias/role-alias-

name
iot:UpdateThing UpdateThing arn:aws:iot:region:account-id:thing/thing-name
iot:UpdateThingGroupUpdateThingGroup arn:aws:iot:region:account-id:thinggroup/thing-group-
name
iot:UpdateThingGroupsForThing
UpdateThingGroupsForThing
Para obtener más información acerca del formato de los ARN, consulte Nombres de recursos de Amazon
(ARN) y espacios de nombres de servicios de AWS.
Algunas acciones de AWS IoT, como las empleadas para la creación de recursos, no se pueden llevar a
cabo en un recurso específico. En dichos casos, debe utilizar el carácter comodín (*).
"Resource": "*"
Para ver una lista de los tipos de recursos de AWS IoT y sus ARN, consulte Resources Defined by AWS
IoT en la Guía del usuario de IAM. Para obtener información acerca de con qué acciones puede especificar
los ARN de cada recurso, consulte Actions Defined by AWS IoT.
Claves de condición
El elemento Condition (o bloque de Condition) permite especificar condiciones en las que entra en
vigor una instrucción. El elemento Condition es opcional. Puede crear expresiones condicionales que
utilizan operadores de condición, tales como igual o menor que, para que coincida la condición de la
política con valores de la solicitud.
Si especifica varios elementos de Condition en una instrucción o varias claves en un único elemento de
Condition, AWS las evalúa mediante una operación AND lógica. Si especifica varios valores para una
206
única clave de condición, AWS evalúa la condición con una operación lógica OR. Se deben cumplir todas
las condiciones antes de que se concedan los permisos de la instrucción.
También puede utilizar variables de marcador de posición al especificar condiciones. Por ejemplo, puede
conceder un permiso de usuario de IAM para acceder a un recurso solo si está etiquetado con su nombre
de usuario de IAM. Para obtener más información, consulte Elementos de la política de IAM: Variables y
etiquetas en la Guía del usuario de IAM.
AWS IoT define su propio conjunto de claves de condición y también admite el uso de algunas claves de
condición globales. Para ver todas las claves de condición globales de AWS, consulte Claves de contexto
de condición globales de AWS en la Guía del usuario de IAM.
Claves de condición de AWS IoT
Claves de Descripción Tipo

condición de AWS
IoT
aws:RequestTag/ Una clave de Cadena

${<tag-key>} etiqueta que está
presente en la
solicitud que el
usuario realiza a
AWS IoT.
aws:ResourceTag/El componente de Cadena

${<tag-key>} clave de etiqueta
de una etiqueta
asociada a un
recurso de AWS
IoT.
aws:TagKeys La lista de todos Cadena

los nombres de
clave de etiqueta
asociados con
el recurso de la
solicitud.
Para ver una lista de claves de condición de AWS IoT, consulte Condition Keys for AWS IoT en la Guía del
usuario de IAM. Para obtener más información acerca de las acciones y los recursos con los que puede
utilizar una clave de condición, consulte Actions Defined by AWS IoT.
Ejemplos
Para ver ejemplos de políticas basadas en identidad de AWS IoT, consulte Ejemplos de políticas basadas
en identidades de AWS IoT (p. 208).
Políticas basadas en recursos de AWS IoT

Las políticas basadas en recursos son documentos de política JSON que especifican qué acciones puede
realizar una entidad principal especificada en el recurso AWS IoT y en qué condiciones.
AWS IoT no admite las políticas basadas en recursos de IAM. Sin embargo, admite políticas basadas en
los recursos de AWS IoT.
207
Ejemplos de políticas basadas en identidades
Autorización basada en etiquetas de AWS IoT

Puede adjuntar etiquetas a los recursos de AWS IoT o transferirlas en una solicitud a AWS IoT. Para
controlar el acceso según las etiquetas, debe proporcionar información de las etiquetas en el elemento
de condición de una política mediante las claves de condición iot:ResourceTag/key-name,
aws:RequestTag/key-name o aws:TagKeys. Para obtener más información, consulte Uso de etiquetas
con políticas de IAM (p. 118). Para obtener más información acerca del etiquetado de recursos de AWS
IoT, consulte Etiquetado de los recursos de AWS IoT (p. 117).
Para ver un ejemplo de política basada en la identidad para limitar el acceso a un recurso basado
en las etiquetas de dicho recurso, consulte Visualización de recursos de AWS IoT basados en
etiquetas (p. 210).
Roles de IAM de AWS IoT:

Un rol de IAM es una entidad de la cuenta de AWS que dispone de permisos específicos.
Uso de credenciales temporales con AWS IoT

Puede utilizar credenciales temporales para iniciar sesión con federación, asumir un rol de IAM o asumir un
rol de acceso entre cuentas. Las credenciales de seguridad temporales se obtienen mediante una llamada
a operaciones de la API de AWS STS, como AssumeRole o GetFederationToken.
AWS IoT admite el uso de credenciales temporales.
Roles vinculados a servicios

Los roles vinculados a servicios permiten a los servicios de AWS obtener acceso a los recursos de otros
servicios para completar una acción en su nombre. Los roles vinculados a servicios aparecen en la cuenta
de IAM y son propiedad del servicio. Un administrador de IAM puede ver, pero no editar, los permisos de
los roles vinculados a servicios.
AWS IoT no admite roles vinculados a servicios
Roles de servicio
Esta característica permite que un servicio asuma un rol de servicio en nombre de usted. Este rol permite
que el servicio obtenga acceso a los recursos de otros servicios para completar una acción en su nombre.
Los roles de servicio aparecen en su cuenta de IAM y son propiedad de la cuenta. Esto significa que un
administrador de IAM puede cambiar los permisos de este rol. Sin embargo, hacerlo podría deteriorar la
funcionalidad del servicio.
AWS IoT no admite roles de servicio.
Ejemplos de políticas basadas en identidades de AWS

IoT
De forma predeterminada, los usuarios y roles de IAM no tienen permiso para crear, ver ni modificar
recursos de AWS IoT. Tampoco pueden realizar tareas mediante la Consola de administración de AWS, la
AWS CLI, o la API de AWS. Un administrador de IAM debe crear políticas de IAM que concedan permisos
a los usuarios y a los roles para realizar operaciones de la API concretas en los recursos especificados
que necesiten. El administrador debe adjuntar esas políticas a los usuarios o grupos de IAM que necesiten
esos permisos.
Para obtener más información acerca de cómo crear una política basada en identidad de IAM con estos
documentos de políticas de JSON de ejemplo, consulte Creación de políticas en la pestaña JSON en la
Guía del usuario de IAM.
208
Temas
• Prácticas recomendadas relativas a políticas (p. 209)
• Mediante la consola de AWS IoT (p. 209)
• Permitir a los usuarios consultar sus propios permisos (p. 209)
• Visualización de recursos de AWS IoT basados en etiquetas (p. 210)
Prácticas recomendadas relativas a políticas

Las políticas basadas en identidad son muy eficaces. Determinan si alguien puede crear, acceder o
eliminar los recursos de AWS IoT de su cuenta. Estas acciones pueden generar costes adicionales para su
cuenta de AWS. Siga estas directrices y recomendaciones al crear o editar políticas basadas en identidad:
• Introducción sobre el uso de políticas administradas de AWS: para comenzar a utilizar AWS IoT
rápidamente, utilice las políticas administradas de AWS para proporcionar a los empleados los permisos
necesarios. Estas políticas ya están disponibles en su cuenta y las mantiene y actualiza AWS. Para
obtener más información, consulte Introducción sobre el uso de permisos con políticas administradas de
AWS en la Guía del usuario de IAM.
• Conceder privilegios mínimos: al crear políticas personalizadas, conceda solo los permisos necesarios
para llevar a cabo una tarea. Comience con un conjunto mínimo de permisos y conceda permisos
adicionales según sea necesario. Por lo general, es más seguro que comenzar con permisos que son
demasiado tolerantes e intentar hacerlos más severos más adelante. Para obtener más información,
consulte Conceder privilegios mínimos en la Guía del usuario de IAM.
• Habilitar MFA para operaciones confidenciales: para mayor seguridad, obligue a los usuarios de
IAM a que utilicen la autenticación multifactor (MFA) para acceder a recursos u operaciones de API
confidenciales. Para obtener más información, consulte Uso de Multi-Factor Authentication (MFA) en
AWS en la Guía del usuario de IAM.
• Utilizar condiciones de política para mayor seguridad: en la medida en que sea práctico, defina las
condiciones en las que sus políticas basadas en identidad permitan el acceso a un recurso. Por ejemplo,
puede escribir condiciones para especificar un rango de direcciones IP permitidas desde el que debe
proceder una solicitud. También puede escribir condiciones para permitir solicitudes solo en un intervalo
de hora o fecha especificado o para solicitar el uso de SSL o MFA. Para obtener más información,
consulte Elementos de la política de JSON de IAM: condición en la Guía del usuario de IAM.
Mediante la consola de AWS IoT

Para acceder a la consola de AWS IoT, debe tener un conjunto mínimo de permisos. Estos permisos
deben permitirle registrar y consultar los detalles sobre los recursos de AWS IoT en su cuenta de AWS.
Si crea una política basada en identidad que sea más restrictiva que el mínimo de permisos necesarios,
la consola no funcionará del modo esperado para las entidades (usuarios o roles de IAM) que tengan esa
política.
Para asegurarse de que esas entidades puedan seguir usando la consola de AWS IoT, asocie también
la política administrada de AWS siguiente a las entidades AWSIoTFullAccess. Para obtener más
información, consulte Adición de permisos a un usuario en la Guía del usuario de IAM:
No es necesario que conceda permisos mínimos para la consola a los usuarios que solo realizan llamadas
a la AWS CLI o a la API de AWS. En su lugar, permite acceso únicamente a las acciones que coincidan
con la operación de API que intenta realizar.
Permitir a los usuarios consultar sus propios permisos

En este ejemplo, se muestra cómo podría crear una política que permita a los usuarios de IAM ver las
políticas administradas e insertadas que se asocian a la identidad de sus usuarios. Esta política incluye
209
permisos para llevar a cabo esta acción en la consola o mediante programación con la AWS CLI o la API
de AWS.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ViewOwnUserInfo",
"Effect": "Allow",
"Action": [
"iam:GetUserPolicy",
"iam:ListGroupsForUser",
"iam:ListAttachedUserPolicies",
"iam:ListUserPolicies",
"iam:GetUser"
],
"Resource": ["arn:aws:iam::*:user/${aws:username}"]
},
{
"Sid": "NavigateInConsole",
"Effect": "Allow",
"Action": [
"iam:GetGroupPolicy",
"iam:GetPolicyVersion",
"iam:GetPolicy",
"iam:ListAttachedGroupPolicies",
"iam:ListGroupPolicies",
"iam:ListPolicyVersions",
"iam:ListPolicies",
"iam:ListUsers"
],
"Resource": "*"
}
]
}
Visualización de recursos de AWS IoT basados en etiquetas

Puede utilizar las condiciones de su política basada en identidad para controlar el acceso a los recursos
de AWS IoT en función de las etiquetas. En este ejemplo, se muestra cómo crear una política que permita
visualizar un objeto. Sin embargo, los permisos solo se conceden si la etiqueta del objeto Owner tiene el
valor del nombre de usuario de dicho usuario. Esta política también proporciona los permisos necesarios
para llevar a cabo esta acción en la consola.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "ListBillingGroupsInConsole",
"Effect": "Allow",
"Action": "iot:ListBillingGroups",
"Resource": "*"
},
{
"Sid": "ViewBillingGroupsIfOwner",
"Effect": "Allow",
"Action": "iot:DescribeBillingGroup",
"Resource": "arn:aws:iot:*:*:billinggroup/*",
"Condition": {
"StringEquals": {"aws:ResourceTag/Owner": "${aws:username}"}
}
}
210
Solución de problemas
]
}
También puede adjuntar esta política al usuario de IAM en su cuenta. Si un usuario llamado richard-
roe intenta ver un grupo de facturación de AWS IoT, el grupo de facturación debe estar etiquetado como
Owner=richard-roe o como owner=richard-roe. De lo contrario, se le deniega el acceso. La clave
de la etiqueta de condición Owner coincide con los nombres de las claves de condición Owner y owner
porque no distinguen entre mayúsculas y minúsculas. Para obtener más información, consulte Elementos
de la política de JSON de IAM: condición en la Guía del usuario de IAM.
Solución de problemas de identidad y acceso en AWS

IoT
Utilice la información siguiente para diagnosticar y solucionar los problemas comunes que puedan surgir
cuando trabaje con AWS IoT e IAM.
Temas
• No tengo autorización para realizar una acción en AWS IoT (p. 211)
• No tengo autorización para realizar la operación iam:PassRole (p. 211)
• Quiero ver mis claves de acceso (p. 212)
• Soy administrador y deseo permitir que otros obtengan acceso a AWS IoT (p. 212)
• Quiero permitir a personas externas a mi cuenta de AWS el acceso a mis recursos de AWS
IoT (p. 212)
No tengo autorización para realizar una acción en AWS IoT

Si la Consola de administración de AWS le indica que no está autorizado para llevar a cabo una acción,
debe ponerse en contacto con su administrador para recibir ayuda. Su administrador es la persona que le
facilitó su nombre de usuario y contraseña.
En el siguiente ejemplo, el error se produce cuando el usuario de IAM, mateojackson, intenta utilizar la
consola para ver detalles sobre una cosa, pero no tiene permisos iot:DescribeThing.
User: arn:aws:iam::123456789012:user/mateojackson is not authorized to perform:

iot:DescribeThing
on resource: MyIoTThing
En este caso, Mateo pide a su administrador que actualice sus políticas de forma que pueda obtener
acceso al recurso MyIoTThing mediante la acción iot:DescribeThing.
No tengo autorización para realizar la operación iam:PassRole

Si recibe un error que indica que no está autorizado para llevar a cabo la acción iam:PassRole, debe
ponerse en contacto con su administrador para recibir ayuda. Su administrador es la persona que le facilitó
su nombre de usuario y contraseña. Pida a la persona que actualice sus políticas de forma que pueda
transferir un rol a AWS IoT.
Algunos servicios de AWS le permiten transferir un rol existente a dicho servicio en lugar de crear un nuevo
rol de servicio o uno vinculado al servicio. Para ello, debe tener permisos para transferir el rol al servicio.
En el siguiente ejemplo, el error se produce cuando un usuario de IAM denominado marymajor intenta
utilizar la consola para realizar una acción en AWS IoT. Sin embargo, la acción requiere que el servicio
cuente con permisos otorgados por un rol de servicio. Mary no tiene permisos para transferir el rol al
servicio.
211
Solución de problemas
User: arn:aws:iam::123456789012:user/marymajor is not authorized to perform: iam:PassRole
En este caso, Mary pide a su administrador que actualice sus políticas para que pueda realizar la acción
iam:PassRole.
Quiero ver mis claves de acceso

Después de crear sus claves de acceso de usuario de IAM, puede ver su ID de clave de acceso en
cualquier momento. Sin embargo, no puede volver a ver su clave de acceso secreta. Si pierde la clave de
acceso secreta, debe crear un nuevo par de claves de acceso.
Las claves de acceso se componen de dos partes: un ID de clave de acceso (por ejemplo,
AKIAIOSFODNN7EXAMPLE) y una clave de acceso secreta (por ejemplo, wJalrXUtnFEMI/K7MDENG/
bPxRfiCYEXAMPLEKEY). El ID de clave de acceso y la clave de acceso secreta se utilizan juntos, como un
nombre de usuario y contraseña, para autenticar sus solicitudes. Administre sus claves de acceso con el
mismo nivel de seguridad que para el nombre de usuario y la contraseña.
Important
No proporcione las claves de acceso a terceras personas, ni siquiera para que le ayuden a buscar
el ID de usuario canónico. Si lo hace, podría conceder a otra persona acceso permanente a su
cuenta.
Cuando cree un par de claves de acceso, se le pide que guarde el ID de clave de acceso y la clave de
acceso secreta en un lugar seguro. La clave de acceso secreta solo está disponible en el momento de su
creación. Si pierde la clave de acceso secreta, debe añadir nuevas claves de acceso a su usuario de IAM.
Puede tener un máximo de dos claves de acceso. Si ya cuenta con dos, debe eliminar un par de claves
antes de crear uno nuevo. Para ver las instrucciones, consulte Administración de las claves de acceso en
la Guía del usuario de IAM.
Soy administrador y deseo permitir que otros obtengan acceso a

AWS IoT
Para permitir que otros obtengan acceso a AWS IoT, debe crear una entidad de IAM (usuario o rol) para
la persona o aplicación que necesita acceso. Esta persona utilizará las credenciales de la entidad para
obtener acceso a AWS. A continuación, debe asociar una política a la entidad que le conceda los permisos
correctos en AWS IoT.
Para comenzar de inmediato, consulte Creación del primer grupo y usuario delegado de IAM en la Guía del
usuario de IAM.
Quiero permitir a personas externas a mi cuenta de AWS el

acceso a mis recursos de AWS IoT
Puede crear un rol que los usuarios de otras cuentas o las personas externas a la organización puedan
utilizar para acceder a sus recursos. Puede especificar una persona de confianza para que asuma el rol.
En el caso de los servicios que admitan las políticas basadas en recursos o las listas de control de acceso
(ACL), puede utilizar dichas políticas para conceder a las personas acceso a sus recursos.
Para obtener más información, consulte lo siguiente:
• Para obtener información acerca de si AWS IoT admite estas características, consulte Funcionamiento
de AWS IoT con IAM (p. 193).
• Para aprender cómo proporcionar acceso a sus recursos en cuentas de AWS de su propiedad, consulte
Proporcionar acceso a un usuario de IAM a otra cuenta de AWS de la que es propietario en la Guía del
usuario de IAM.
212
Registro y monitorización
• Para obtener información acerca de cómo ofrecer acceso a sus recursos a cuentas de AWS de terceros,
consulte Proporcionar acceso a las cuentas de AWS propiedad de terceros en la Guía del usuario de
IAM.
• Para obtener información acerca de cómo ofrecer acceso a la identidad federada, consulte Proporcionar
acceso a usuarios autenticados externamente (identidad federada) en la Guía del usuario de IAM.
• Para obtener información acerca de la diferencia entre utilizar los roles y las políticas basadas en
recursos para el acceso entre cuentas, consulte Cómo los roles de IAM difieren de las políticas basadas
en recursos en la Guía del usuario de IAM.
Registro y monitorización
La monitorización es una parte importante del mantenimiento de la fiabilidad, la disponibilidad y el
rendimiento de AWS IoT; y sus soluciones de AWS. Debe recopilar datos de monitorización de todas las
partes de su solución de AWS para que le resulte más sencillo depurar cualquier error que se produzca en
distintas partes del código, en caso de que ocurra. Para obtener información sobre los procedimientos de
registro y monitoreo, consulte Monitorización de AWS IoT (p. 220)
Antes de empezar a monitorizar AWS IoT, debe crear un plan de monitorización que incluya respuestas a
las siguientes preguntas:
Herramientas de monitorización
AWS proporciona herramientas que puede utilizar para monitorizar AWS IoT. Puede configurar algunas de
estas herramientas para que realicen la monitorización por usted. Algunas de las herramientas requieren
intervención manual. Le recomendamos que automatice las tareas de monitorización en la medida de lo
posible.
Herramientas de monitorización automatizadas

Puede utilizar las siguientes herramientas de monitorización automatizado para vigilar AWS IoT e informar
cuando haya algún problema:
• Amazon CloudWatch Alarms (Alarmas de Amazon CloudWatch): observe una sola métrica durante
el periodo que especifique y realice una o varias acciones según el valor de la métrica relativo a un
determinado umbral durante varios periodos de tiempo. La acción es una notificación que se envía
a un tema de Amazon Simple Notification Service (Amazon SNS) o a una política de Amazon EC2
Auto Scaling. Las alarmas de CloudWatch no invocan acciones simplemente por tener un estado
determinado. El estado debe haber cambiado y debe mantenerse durante el número de periodos
especificado. Para obtener más información, consulte Monitoreo de alarmas y métricas de AWS IoT
mediante Amazon CloudWatch (p. 227).
• Amazon CloudWatch Logs: monitorice, almacene y obtenga acceso a los archivos de registro desde
AWS CloudTrail o de otras fuentes. Para obtener más información, consulte Monitoreo de AWS IoT
mediante CloudWatch Logs (p. 239). Para obtener más información acerca del uso de Amazon
CloudWatch, consulte Monitoreo de archivos de registro en la Guía del usuario de Amazon CloudWatch.
• Amazon CloudWatch Events –: seleccione los eventos y diríjalos a uno o varios flujos o funciones de
destino para realizar cambios, capturar información de estado y aplicar medidas correctivas. Para
obtener más información, consulte ¿Qué es Amazon CloudWatch Events? en la Guía del usuario de
Amazon CloudWatch.
• Monitorización de registros de AWS CloudTrail: compartir archivos de registro entre cuentas, monitorizar
archivos de registro de CloudTrail en tiempo real mediante su envío a CloudWatch Logs, escribir
aplicaciones de procesamiento de registros en Java y validar que sus archivos de registro no hayan
cambiado después de que CloudTrail los entregue. Para obtener más información, consulte Registre las
213
Validación de la conformidad
llamadas a la API de AWS IoT con AWS CloudTrail. (p. 257) y también Uso de archivos de registro de
CloudTrail en la AWS CloudTrail User Guide.
Herramientas de monitorización manual

Otra parte importante de la monitorización de AWS IoT implica la monitorización manual de los elementos
que no cubren las alarmas de CloudWatch. Los paneles de las consolas de AWS IoT, CloudWatch y otros
servicios de AWS proporcionan una vista rápida del estado del entorno de AWS. Le recomendamos que
también compruebe los archivos de registro en AWS IoT.
• El panel de AWS IoT muestra lo siguiente:

• Certificados de CA
• Certificados
• Políticas
• Reglas
• Objetos
• La página de inicio de CloudWatch muestra:
• Alarmas y estado actual.
• Gráficos de alarmas y recursos.
• Estado de los servicios.
Puede utilizar CloudWatch para hacer lo siguiente:

• Crear paneles personalizados para monitorizar los servicios que le interesan.
• Realizar un gráfico con los datos de las métricas para resolver problemas y descubrir tendencias.
• Buscar y examinar todas sus métricas de recursos de AWS.
• Crear y editar las alarmas de notificación de problemas.
Validación de conformidad para AWS IoT Core

Auditores externos evalúan la seguridad y la conformidad de AWS IoT Core como parte de varios
programas de conformidad de AWS. Estos incluye SOC, PCI, FedRAMP, HIPAA y otros.
Para obtener una lista de los servicios de AWS en el ámbito de programas de conformidad específicos,
consulte Servicios de AWS en el ámbito del programa de conformidad. Para obtener información general,
consulte Programas de conformidad de AWS.
Puede descargar los informes de auditoría de terceros utilizando AWS Artifact. Para obtener más
información, consulte la sección Descarga de informes en AWS Artifact.
Su responsabilidad de conformidad al utilizar AWS IoT se determina en función de la sensibilidad de los

datos, los objetivos de cumplimiento de su empresa y la legislación y los reglamentos correspondientes.
AWS proporciona los siguientes recursos para ayudar con la conformidad:
• Guías de inicio rápido de seguridad y conformidad – estas guías de implementación tratan

consideraciones sobre arquitectura y ofrecen pasos para implementar los entornos de referencia
centrados en la seguridad y la conformidad en AWS.
• Documento técnico sobre arquitectura para seguridad y conformidad de HIPAA – este documento
técnico describe cómo las empresas pueden utilizar AWS para crear aplicaciones conformes con HIPAA.
• Recursos de conformidad de AWS – este conjunto de manuales y guías podría aplicarse a su sector y
ubicación.
• AWS Config – este servicio de AWS evalúa en qué medida las configuraciones de los recursos cumplen
las prácticas internas, las directrices del sector y las normativas.
214
Resiliencia
• AWS Security Hub – Este servicio de AWS ofrece una vista integral de su estado de seguridad en
AWS que le ayuda a comprobar la conformidad con las normas del sector de seguridad y las prácticas
recomendadas.
Resiliencia de AWS IoT Core

La infraestructura global de AWS está conformada por regiones y zonas de disponibilidad de AWS. Las
regiones de AWS proporcionan varias zonas de disponibilidad físicamente independientes y aisladas
que se encuentran conectadas mediante redes con un alto nivel de rendimiento y redundancia, además
de baja latencia. Con las zonas de disponibilidad, puede diseñar y utilizar aplicaciones y bases de datos
que realizan una conmutación por error automática entre zonas de disponibilidad sin interrupciones. Las
zonas de disponibilidad tienen una mayor disponibilidad, tolerancia a errores y escalabilidad que las
infraestructuras tradicionales de centros de datos únicos o múltiples.
Para obtener más información sobre zonas de disponibilidad y las regiones de AWS, consulte
Infraestructura global de AWS.
AWS IoT Core guarda la información sobre los dispositivos en el registro de dispositivos. También
almacena certificados de CA, certificados de dispositivo y datos de sombra de dispositivos. Estos datos no
se replican automáticamente si se producen errores de hardware o de red. AWS IoT Core publica eventos
MQTT cuando se actualiza el registro de un dispositivo. Puede utilizar estos mensajes para realizar una
copia de seguridad de los datos del registro y guardarlos en algún lugar, como una tabla de DynamoDB.
Usted es responsable de guardar los certificados que AWS IoT Core cree para usted o los que cree usted
mismo. La sombra del dispositivo almacena datos de estado sobre sus dispositivos y se pueden volver a
enviar cuando un dispositivo vuelve a conectarse.
Los recursos de AWS IoT Core son específicos de la región y no se replican entre regiones de AWS a
menos que lo haga específicamente.
Seguridad de la infraestructura en AWS IoT

Al tratarse de una colección de servicios administrados, AWS IoT está protegido por los procedimientos
de seguridad de red globales de AWS que se describen en el documento técnico Amazon Web Services:
Información general sobre procesos de seguridad.
Puede utilizar llamadas a la API publicadas en AWS para obtener acceso a AWS IoT a través de la red.
Los clientes deben ser compatibles con Transport Layer Security (TLS) 1.2 o una versión posterior. Los
clientes también deben ser compatibles con conjuntos de cifrado con confidencialidad directa total (PFS)
tales como Ephemeral Diffie-Hellman (DHE) o Elliptic Curve Ephemeral Diffie-Hellman (ECDHE). La
mayoría de los sistemas modernos, como Java 7 y posteriores, son compatibles con estos modos. Para
obtener más información, consulte Seguridad de transporte en AWS IoT (p. 187).
Las solicitudes deben estar firmadas mediante un ID de clave de acceso y una clave de acceso secreta
que esté asociada a una entidad principal de IAM. También puede utilizar AWS Security Token Service
(AWS STS) para generar credenciales de seguridad temporales para firmar solicitudes.
Análisis y administración de vulnerabilidades en

AWS IoT Core
Las flotas de IoT pueden constar de un gran número de dispositivos que tienen diversas funcionalidades,
son de larga duración y están distribuidos geográficamente. Estas características hacen que la
215
Prácticas recomendadas de seguridad
configuración de la flota sea compleja y propensa a errores. Y dado que los dispositivos a menudo están
limitados en potencia informática, memoria y capacidades de almacenamiento, esto limita el uso del cifrado
y otras formas de seguridad en los propios dispositivos. Además, los dispositivos a menudo usan software
con vulnerabilidades conocidas. Estos factores hacen que las flotas de IoT sean un objetivo atractivo para
los piratas informáticos y dificultan la protección continuada de la flota de dispositivos.
AWS IoT Device Defender afronta estos desafíos proporcionando herramientas para identificar los
problemas de seguridad y las desviaciones de las prácticas recomendadas. Puede utilizar AWS IoT Device
Defender para analizar, auditar y supervisar los dispositivos conectados para detectar comportamientos
anómalos y mitigar los riesgos de seguridad. AWS IoT Device Defender puede auditar las flotas de
dispositivos para asegurarse de que cumplan con las prácticas recomendadas de seguridad y detecten
un comportamiento anómalo en los dispositivos. Esto posibilita aplicar políticas de seguridad coherentes
en toda su flota de dispositivos AWS IoT y responder rápidamente cuando los dispositivos sufren ataques.
Para obtener más información, consulte AWS IoT Device Defender (p. 580).
Prácticas de seguridad recomendadas para AWS

IoT Core
Esta sección contiene información sobre las prácticas de seguridad recomendadas para AWS IoT Core.
Para obtener más información, consulte Ten security golden rules for IoT solutions.
Protección de conexiones MQTT en AWS IoT

AWS IoT Core es un servicio administrado en la nube que permite que los dispositivos conectados
interactúen de forma sencilla y segura con las aplicaciones en la nube. AWS IoT Core admite HTTP,
WebSocket y MQTT, un protocolo de comunicación ligero especialmente diseñado para admitir conexiones
intermitentes. Si se conecta al Agente de mensajes de AWS IoT (p. 266) con MQTT, cada una de sus
conexiones debe asociarse con un identificador conocido como ID de cliente. Los ID de cliente MQTT
identifican de forma exclusiva conexiones MQTT. Si se establece una nueva conexión mediante un ID
de cliente que ya se ha solicitado para otra conexión, el agente de mensajes de AWS IoT interrumpe la
conexión anterior para permitir la nueva conexión. Los identificadores de cliente deben ser únicos dentro
de cada cuenta de AWS y cada región de AWS. Esto significa que no es necesario imponer la exclusividad
global de los identificadores de cliente fuera de la cuenta de AWS o entre las regiones de la cuenta de
AWS.
El impacto y la gravedad de la interrupción de las conexiones MQTT en su flota de dispositivos depende de

muchos factores. Entre ellas se incluyen:
• Su caso de uso (por ejemplo, los datos que los dispositivos envían a AWS IoT, la cantidad de datos y la
frecuencia con la que se envían).
• Su configuración de cliente MQTT (por ejemplo, configuración de reconexión automática,
temporizaciones de interrupción asociadas y uso de sesiones persistentes de MQTT (p. 278)).
• Las restricciones de recursos de dispositivos.
• La causa principal de las desconexiones, su agresividad y persistencia.
Para evitar conflictos del ID de cliente y sus posibles efectos negativos, asegúrese de que cada dispositivo
o aplicación móvil tiene una política de AWS IoT o IAM que restrinja qué identificadores de cliente pueden
usarse en conexiones de MQTT con el agente de mensajes de AWS IoT. Por ejemplo, puede usar una
política de IAM para evitar que un dispositivo cierre por error la conexión de otro dispositivo utilizando un ID
de cliente que ya está en uso. Para obtener más información, consulte Autorización (p. 151).
Todos los dispositivos de la flota deben tener credenciales con privilegios que autoricen únicamente las
acciones previstas; por ejemplo, acciones MQTT de AWS IoT, como la publicación de mensajes o la
216
Protección de conexiones MQTT en AWS IoT
suscripción a temas con un ámbito y un contexto específicos. Las políticas de permisos específicas pueden
variar en función de los casos de uso. Identifique las políticas de permisos que se ajusten mejor a sus
requisitos empresariales y de seguridad.
Para simplificar la creación y la administración de políticas de permisos, puede utilizar Variables de las
políticas de AWS IoT Core (p. 155) y Variables de las políticas de IAM. Las variables de la política
se pueden colocar en una política y cuando se evalúa la política las variables se sustituyen por valores
procedentes de la solicitud del dispositivo. Al usar variables de la política, puede crear una única
política para la concesión de permisos a varios dispositivos. Puede identificar las variables de la política
relevantes para su caso de uso en función de su configuración de la cuenta de AWS IoT, el mecanismo
de autenticación y el protocolo de red utilizado en la conexión al agente de mensajes de AWS IoT. Sin
embargo, para escribir las mejores políticas de permisos, deben tenerse en cuenta los detalles concretos
de su caso de uso y el modelo de amenazas.
Por ejemplo, si ha registrado los dispositivos en el registro de AWS IoT (p. 6), puede utilizar variables
de la política de objetos (p. 156) en las políticas de AWS IoT para conceder o denegar permisos en
función de las propiedades de un objeto, como el nombre o el tipo de objeto, o los valores de atributo
del objeto. El nombre del objeto se obtiene a partir del ID de cliente del mensaje de MQTT Connect que
se envía cuando un objeto se conecta a AWS IoT. Las variables de la política de objeto se sustituyen
cuando un objeto se conecta con AWS IoT sobre MQTT empleando la autenticación mutua de TLS o
MQTT sobre WebSocket mediante identidades de Amazon Cognito autenticadas. Puede usar la API
AttachThingPrincipal para asociar certificados e identidades de Amazon Cognito autenticadas a un objeto.
iot:Connection.Thing.ThingName es una variable de política de objetos útil para forzar la aplicación
de las restricciones del ID de cliente. La siguiente política de AWS IoT de ejemplo requiere un nombre
del objeto registrado que se va a utilizar como el ID de cliente para las conexiones MQTT al agente de
mensajes de AWS IoT:
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":"iot:Connect",
"Resource":[
]
}
]
}
Si desea identificar conflictos de ID de cliente en curso, puede habilitar y utilizar CloudWatch Logs para
AWS IoT (p. 239). Por cada conexión MQTT que el agente de mensajes de AWS IoT desconecta debido
a conflictos de ID de cliente, se genera un registro parecido a lo siguiente:
{
"timestamp": "2019-04-28 22:05:30.105",
"logLevel": "ERROR",
"traceId": "02a04a93-0b3a-b608-a27c-1ae8ebdb032a",
"accountId": "123456789012",
"status": "Failure",
"eventType": "Disconnect",
"protocol": "MQTT",
"clientId": "clientId01",
"principalId": "1670fcf6de55adc1930169142405c4a2493d9eb5487127cd0091ca0193a3d3f6",
"sourceIp": "203.0.113.1",
"sourcePort": 21335,
"reason": "DUPLICATE_CLIENT_ID",
"details": "A new connection was established with the same client ID"
}
217
Mantener sincronizado el reloj del dispositivo
Puede utilizar un filtros de CloudWatch Logs como {$.reason= "DUPLICATE_CLIENT_ID" } para

buscar instancias de conflictos de ID de cliente o para configurar filtros de métricas de CloudWatch y sus
correspondientes alarmas de CloudWatch para la continua monitorización y generación de inforrmes.
Puede utilizar AWS IoT Device Defender para identificar políticas de AWS IoT e IAM demasiado
permisivas. AWS IoT Device Defender también ofrece una comprobación de auditoría que le notifica si
varios dispositivos en la flota se conecta al agente de mensajes de AWS IoT con el mismo ID de cliente.
Véase también
• AWS IoT Core
• Características de seguridad de AWS IoT (p. 123)
• Variables de las políticas de AWS IoT Core (p. 155)
• Variables de las políticas de IAM
• Identidad de Amazon Cognito
• Registro de AWS IoT (p. 6)
• AWS IoT Device Defender
• CloudWatch Logs para AWS IoT (p. 239)
Mantener sincronizado el reloj del dispositivo

Es importante que la hora del dispositivo sea precisa. Los certificados X.509 tienen una fecha y una hora
de caducidad. El reloj del dispositivo se utiliza para comprobar que un certificado de servidor sigue siendo
válido. Si está creando dispositivos IoT comerciales, recuerde que sus productos pueden permanecer
en el almacén durante largos períodos de tiempo antes de venderse. Los relojes en tiempo real pueden
retrasarse durante este tiempo y las baterías pueden descargarse, por lo que no es suficiente fijar el
tiempo en fábrica.
En la mayoría de los sistemas, esto significa que el software del dispositivo debe incluir un cliente NTP
(Protocolo de tiempo de red). El dispositivo debe esperar hasta que se sincronice con un servidor NTP
antes de intentar conectarse a AWS IoT Core. Si esto no es posible, el sistema debería proporcionar un
mecanismo para que el usuario establezca la hora del dispositivo, de forma que las conexiones posteriores
se realicen correctamente.
Una vez que el dispositivo se haya sincronizado con un servidor NTP, podrá abrir una conexión con AWS
IoT Core. La cantidad de sesgo de reloj permitida dependerá de lo que esté tratando de hacer con la
conexión.
Validar el certificado de servidor

Lo primero que un dispositivo hace para interactuar con AWS IoT es abrir una conexión segura. Cuando
conecte el dispositivo a AWS IoT, asegúrese de que está hablando con otro servidor AWS IoT y no a
otro servidor que esté suplantando la identidad de AWS IoT. Cada uno de los servidores de AWS IoT se
aprovisiona con un certificado emitido para el dominio iot.amazonaws.com. Este certificado fue emitido
218
Usar una identidad única por dispositivo
para AWS IoT por una autoridad de certificación de confianza que verificó nuestra identidad y propiedad
del dominio.
Una de las primeras cosas que AWS IoT Core hace cuando se conecta un dispositivo es enviar al
dispositivo un certificado de servidor. Los dispositivos pueden comprobar que estaban esperando para
conectarse a iot.amazonaws.com y que el servidor al final de dicha conexión posee un certificado de
una autoridad de confianza para ese dominio.
Los certificados TLS tienen formato X.509 e incluyen información diversa, como el nombre de la
organización, la ubicación, el nombre de dominio y un período de validez. El período de validez se
especifica como un par de valores de tiempo llamados notBefore y notAfter. Algunos servicios como
AWS IoT Core utilizan períodos de validez limitados (por ejemplo, un año) para los certificados de servidor
y comienzan a proporcionar otros nuevos antes de que caduquen los antiguos.
Usar una identidad única por dispositivo

Utilice una identidad única por cliente. Los dispositivos generalmente usan certificados de cliente X.509.
Aplicaciones web y móviles utilizan Identidad de Amazon Cognito Esto le permite aplicar permisos
detallados a sus dispositivos.
Por ejemplo, suponga que tiene una aplicación que se compone de un dispositivo de teléfono móvil que
recibe actualizaciones de estado de dos objetos inteligentes del hogar diferentes: una bombilla y un
termostato. La bombilla envía el estado de su nivel de batería y el termostato envía mensajes que informan
de la temperatura.
AWS IoT autentica los dispositivos por separado y trata cada conexión individualmente. Puede aplicar
controles de acceso detallados a través de políticas de autorización. Puede definir una política para
el termostato que le permita publicar en un espacio de tema. Puede definir una política independiente
para la bombilla que le permita publicar en un espacio de tema diferente. Por último, puede definir una
política para la aplicación móvil que solo le permita conectarse y suscribirse a los temas del termostato y la
bombilla para recibir mensajes de estos dispositivos.
Aplique el principio de privilegios mínimos y amplíe los permisos por dispositivo tanto como sea posible.
Todos los dispositivos o usuarios deben tener una política de AWS IoT en AWS IoT que solo les permita
conectarse con un ID de cliente conocido, así como publicar y suscribirse a un conjunto de temas
identificado y fijo.
Usar aprovisionamiento justo a tiempo

Crear y aprovisionar manualmente cada dispositivo puede llevar mucho tiempo. AWS IoT proporciona una
forma de definir una plantilla para aprovisionar dispositivos cuando se conectan por primera vez a AWS
IoT. Para obtener más información, consulte Aprovisionamiento justo a tiempo (p. 543).

Siga el siguiente curso para conocer los conceptos clave de seguridad de AWS IoT: AWS IoT Security
Primer.
219
Monitorización de AWS IoT

La monitorización es una parte importante del mantenimiento de la fiabilidad, la disponibilidad y el
rendimiento de AWS IoT; y sus soluciones de AWS.
Le recomendamos encarecidamente que recopile datos de monitoreo de todas las partes de su solución
de AWS para que le resulte más sencillo depurar cualquier error que se produzca en distintas partes del
código, en caso de que ocurra. Comience por crear un plan de monitoreo que responda a las siguientes
preguntas. Si no está seguro de cómo responderlas, puede continuar habilitando el registro (p. 221) y
estableciendo las líneas base de rendimiento.
• ¿Cuáles son los objetivos de la monitorización?

• ¿Qué recursos va a monitorizar?
• ¿Con qué frecuencia va a monitorizar estos recursos?
• ¿Qué herramientas de monitorización va a utilizar?
• ¿Quién se encargará de realizar las tareas de monitorización?
• ¿Quién debería recibir una notificación cuando surjan problemas?
El siguiente paso consiste en habilitar el registro (p. 221) y establecer un punto de referencia de
rendimiento de AWS IoT normal en el entorno midiendo el rendimiento varias veces y bajo distintas
condiciones de carga. A medida que monitorea AWS IoT, mantenga los datos de monitoreo históricos para
que pueda compararlos con los datos de rendimiento actuales. Esto le ayudará a identificar patrones de
rendimiento normales y anomalías de rendimiento, así como a idear métodos para abordarlos.
Para establecer el rendimiento previsto para AWS IoT, debe monitorear estas métricas para comenzar.
Siempre puede monitorear más métricas más adelante.
• PublishIn.Success (p. 232)

• PublishOut.Success (p. 232)
• Subscribe.Success (p. 232)
• Ping.Success (p. 232)
• Connect.Success (p. 232)
• GetThingShadow.Accepted (p. 235)
• UpdateThingShadow.Accepted (p. 235)
• DeleteThingShadow.Accepted (p. 235)
• RulesExecuted (p. 231)
Los temas de esta sección pueden ayudarle a iniciar el registro y el monitoreo de AWS IoT.
Temas
• Configuración de registros de AWS IoT (p. 221)
• Monitoreo de alarmas y métricas de AWS IoT mediante Amazon CloudWatch (p. 227)
• Monitoreo de AWS IoT mediante CloudWatch Logs (p. 239)
• Registre las llamadas a la API de AWS IoT con AWS CloudTrail. (p. 257)
220
Configuración de registros de AWS IoT
Configuración de registros de AWS IoT

Debe habilitar el registro mediante la consola de AWS IoT, la CLI o la API antes de poder monitorear y
registrar la actividad de AWS IoT.
Puede habilitar el registro para todo AWS IoT o solo para grupos de objetos específicos. Puede configurar
el registro de AWS IoT mediante la consola de AWS IoT, la CLI o la API; sin embargo, debe usar la CLI o
la API para configurar el registro para grupos de objetos específicos.
Al considerar cómo configurar el registro de AWS IoT, la configuración predeterminada de registro

determina cómo se registrará la actividad de AWS IoT a menos que se especifique lo contrario.
Para empezar, es posible que desee obtener registros detallados con un nivel de registro (p. 226)
predeterminado de INFO o DEBUG. Después de revisar los registros iniciales, puede cambiar el nivel de
registro predeterminado a un nivel menos detallado, como WARN o ERROR y establecer un nivel de registro
específico de recursos más detallado en los recursos que puedan necesitar más atención. Los niveles de
registro se pueden cambiar cuando lo desee.
Configuración del rol y la política de registro

Antes de habilitar el inicio de sesión en AWS IoT, debe crear un rol y una política de IAM que otorgue a
AWS permiso para monitorear la actividad de AWS IoT en su nombre.
Note
Antes de habilitar el registro de AWS IoT, asegúrese de comprender bien los permisos de acceso
a CloudWatch Logs. Los usuarios con acceso a CloudWatch Logs podrán consultar la información
de depuración desde sus dispositivos. Para obtener más información, consulte Autenticación y
control de acceso de Amazon CloudWatch Logs.
Creación de un rol de registro

Utilice la consola de IAM para crear un rol de registro.
Para crear un rol de registro mediante la consola de IAM
1. En el panel de navegación, seleccione Roles (Roles) y, a continuación, seleccione Create role (Crear
rol).
2. En Seleccionar tipo de entidad de confianza, elija Servicio de AWS, IoT.
3. En Select your use case (Seleccione su caso de uso), elija IoT y, a continuación, Next: Permissions
(Siguiente: Permisos).
4. En la página que muestra las políticas que se asocian automáticamente al rol de servicio, elija Next:
Tags (Siguiente: Etiquetas).
5. Elija Next: Review.
6. Escriba un Nombre de rol y una Descripción de rol para el rol y, a continuación, elija Crear rol.
7. En la lista de Roles, busque el rol que creó, ábralo y copie el ARN del rol (<logging-role-arn>)
para utilizarlo más adelante.
Política de rol de registro

Los documentos de política siguientes proporcionan la política de rol y de confianza que permiten a AWS
IoT enviar registros a CloudWatch en su nombre.
221
Configure el registro predeterminado en AWS IoT (consola)
Note
Estos documentos se crearon para usted cuando creó el rol de registro.
Política de roles:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"logs:CreateLogGroup",
"logs:CreateLogStream",
"logs:PutLogEvents",
"logs:PutMetricFilter",
"logs:PutRetentionPolicy"
],
"Resource": [
"*"
]
}
]
}
Política de confianza:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": "iot.amazonaws.com"
},
}
]
}
Configure el registro predeterminado en AWS IoT

(consola)
En esta sección se describe cómo utilizar la consola de AWS IoT para configurar el registro para todo
AWS IoT. Para configurar el registro solo para grupos de objetos específicos, debe usar la CLI o la API.
Para obtener información sobre cómo configurar el registro para grupos de objetos específicos, consulte
Configurar el inicio de sesión específico de recursos en AWS IoT (CLI) (p. 225).
Para usar la consola de AWS IoT para configurar el registro predeterminado para todo AWS IoT
1. Inicie sesión en la consola de AWS IoT. Para obtener más información, consulte Inicie sesión en la
consola de AWS IoT. (p. 5).
2. En el panel de navegación izquierdo, elija Configuración. En la sección Registros de la página
Configuración, elija Editar.
La sección Registros muestra el rol de registro y el nivel de detalle utilizado por todo AWS IoT.
222
Configurar el registro predeterminado en AWS IoT (CLI)
3. En la página Configurar ajustes del rol, elija el Nivel de detalle que describe el nivel de
detalle (p. 226) de las entradas de registro que desea que aparezcan en los registros de
CloudWatch.
4. Elija Seleccionar para especificar un rol que creó en Creación de un rol de registro (p. 221) o Crear
rol para crear un nuevo rol para utilizarlo para registro.
5. Elija Actualizar para guardar los cambios.
Después de habilitar el registro, visite Visualización de registros de AWS IoT en la consola de

CloudWatch (p. 239) para obtener más información sobre cómo ver las entradas del registro.
Configurar el registro predeterminado en AWS IoT

(CLI)
En esta sección se describe cómo configurar el registro global para AWS IoT mediante la CLI.
223
Configurar el registro predeterminado en AWS IoT (CLI)
Note
Necesita el nombre de recurso de Amazon (ARN) del rol que desea utilizar. Si necesita crear un
rol para usar en el registro, consulte Creación de un rol de registro (p. 221) antes de continuar.
La entidad principal que se utiliza para realizar la llamada a la API debe tener Transmisión de los
permisos de rol (p. 287) para el rol de registro.
También puede realizar este procedimiento con la API utilizando los métodos de la API de AWS que
corresponden a los comandos CLI que se muestran aquí.
Para usar la CLI para configurar el registro predeterminado para AWS IoT
1. Utilice el comando set-v2-logging-options para establecer las opciones de registro para su cuenta.
aws iot set-v2-logging-options \

--role-arn <logging-role-arn> \
--default-log-level <log-level>
donde:
--role-arn
El ARN de rol que concede permiso a AWS IoT para escribir en los registros CloudWatch Logs.
--default-log-level
El nivel de registro (p. 226) que se debe usar. Los valores válidos son: ERROR, WARN, INFO,
DEBUG o DISABLED
--no-disable-all-logs
Un parámetro opcional que habilita todo el registro de AWS IoT. Utilice este parámetro para
habilitar el registro cuando esté deshabilitado actualmente.
--disable-all-logs
Un parámetro opcional que deshabilita todo el registro de AWS IoT. Utilice este parámetro para
deshabilitar el registro cuando esté habilitado actualmente.
2. Utilice el comando get-v2-logging-options para obtener las opciones de registro actuales.
aws iot get-v2-logging-options

Note
AWS IoT sigue siendo compatible con los comandos más antiguos (set-logging-options y get-
logging-options) para establecer y obtener el registro global en su cuenta. Tenga en cuenta
que, cuando se utilizan estos comandos, los registros resultantes contienen texto sin formato,
en lugar de cargas JSON y que la latencia de registro normalmente es mayor. No se realizarán
mejoras en la implementación de estos comandos más antiguos. Le recomendamos que utilice las
versiones "v2" para configurar las opciones de registro y, cuando sea posible, que modifique las
aplicaciones heredadas que utilizan las versiones más antiguas.
224
Configurar el inicio de sesión específico
de recursos en AWS IoT (CLI)
Configurar el inicio de sesión específico de recursos

en AWS IoT (CLI)
En esta sección se describe cómo configurar el registro específico de recursos para AWS IoT mediante
la CLI. El registro específico de recursos le permite especificar un nivel de registro para un grupo de
objetos (p. 102) específico.
Los grupos de objetos pueden contener otros grupos de objetos para crear una relación jerárquica. Este
procedimiento describe cómo configurar el registro de un solo grupo de objetos. Puede aplicar este
procedimiento al grupo de objetos principal de una jerarquía para configurar el registro de todos los grupos
de objetos de la jerarquía. También puede aplicar este procedimiento a un grupo de objetos secundario
para anular la configuración de registro de su principal.
Note
Necesita el nombre de recurso de Amazon (ARN) del rol que desea utilizar. Si necesita crear un
rol para usar en el registro, consulte Creación de un rol de registro (p. 221) antes de continuar.
La entidad principal que se utiliza para realizar la llamada a la API debe tener Transmisión de los
permisos de rol (p. 287) para el rol de registro.
También puede realizar este procedimiento con la API utilizando los métodos de la API de AWS que
corresponden a los comandos CLI que se muestran aquí.
Para usar la CLI para configurar el registro específico de recursos para AWS IoT
1. Utilice el comando set-v2-logging-options para establecer las opciones de registro para su cuenta.
aws iot set-v2-logging-options \

--role-arn <logging-role-arn> \
--default-log-level <log-level>
donde:
--role-arn
El ARN de rol que concede permiso a AWS IoT para escribir en los registros CloudWatch Logs.
--default-log-level
El nivel de registro (p. 226) que se debe usar. Los valores válidos son: ERROR, WARN, INFO,
DEBUG o DISABLED
--no-disable-all-logs
Un parámetro opcional que habilita todo el registro de AWS IoT. Utilice este parámetro para
habilitar el registro cuando esté deshabilitado actualmente.
--disable-all-logs
Un parámetro opcional que deshabilita todo el registro de AWS IoT. Utilice este parámetro para
deshabilitar el registro cuando esté habilitado actualmente.
2. Utilice el comando set-v2-logging-level para configurar el registro específico de recursos para un grupo
de objetos.
aws iot set-v2-logging-level \

--log-target targetType=THING_GROUP,targetName=<thing_group_name> \
--log-level <log_level>
225
Niveles de registro
--log-target
El tipo y nombre del recurso para el que está configurando el registro. El valor target_type
debe ser THING_GROUP. El valor del parámetro log-target puede ser texto, como se muestra en el
ejemplo de comando anterior, o una cadena JSON, como en el ejemplo siguiente.
aws iot set-v2-logging-level \

--log-target '{"targetType": "THING_GROUP","targetName":
"<thing_group_name>"}' \
--log-level <log_level>
--log-level
El nivel de registro utilizado cuando se generan registros para el recurso especificado. Los valores
válidos son: DEBUG, INFO, ERROR, WARN y DISABLED.
3. Utilice el comando list-v2-logging-levels para enumerar los niveles de registro configurados
actualmente.
aws iot list-v2-logging-levels
4. Utilice el comando delete-v2-logging-level para eliminar un nivel de registro específico de recursos.
aws iot delete-v2-logging-level \

--targetType "THING_GROUP" \
--targetName "<thing_group_name>"
--targetType
El valor target_type debe ser THING_GROUP

--targetName
El nombre del grupo de objetos para el que se va a quitar el nivel de registro.

Niveles de registro
Estos niveles de registro determinan los eventos que se registran y se aplican a los niveles de registro
predeterminados y específicos de recursos.
ERROR
Cualquier error que provoque el fracaso de una operación.
Los registros solo incluirán información de ERROR.

WARN
Todo lo que pueda llegar a producir incoherencias en el sistema, aunque no el fracaso de la

operación.
Los registros incluirán información de ERROR y WARN.

INFO
Información general acerca del flujo de objetos.
226
Monitoreo de alarmas y métricas de
AWS IoT mediante Amazon CloudWatch
Los registros incluirán información de INFO, ERROR y WARN.

DEBUG
Información que puede ser útil para depurar un problema.
Los registros incluirán información de DEBUG, INFO, ERROR y WARN.

DISABLED
Todos los registros están desactivados.
Monitoreo de alarmas y métricas de AWS IoT

mediante Amazon CloudWatch
Puede monitorizar AWS IoT mediante CloudWatch, que recopila y procesa los datos sin formato de AWS
IoT en métricas legibles y casi en tiempo real. Estas estadísticas se registran durante un periodo de dos
semanas, de forma que pueda acceder a información histórica y obtener una mejor perspectiva sobre el
rendimiento de su aplicación web o servicio. De forma predeterminada, los datos de las métricas de AWS
IoT se envían automáticamente a CloudWatch a intervalos de un minuto. Para obtener más información,
consulte ¿Qué son Amazon CloudWatch, Amazon CloudWatch Events y Amazon CloudWatch Logs? en la
Guía del usuario de Amazon CloudWatch.
Uso de las métricas de AWS IoT

Las métricas mostradas por AWS IoT proporcionan información que puede analizar de diferentes maneras.
Los siguientes casos de uso se basan en una situación en la que tiene diez objetos que se conectan a
Internet una vez al día. Cada día:
• Diez objetos se conectan con AWS IoT casi al mismo tiempo.

• Cada objeto se suscribe a un filtro de temas y, a continuación, espera una hora antes de desconectarse.
Durante este período, los objetos se comunican entre sí y obtienen más información sobre el estado del
mundo.
• Cada objeto publica alguna percepción que tenga según los datos que acaba de encontrar utilizando
UpdateThingShadow.
• Cada objeto se desconecta de AWS IoT.
Estos temas exploran algunas de las preguntas que podría tener en esta situación para comenzar.
• ¿Cómo se me puede enviar una notificación si mis objetos no se conectan correctamente cada
día? (p. 228)
• ¿Cómo se me puede enviar una notificación si mis objetos no publican datos cada día? (p. 229)
• ¿Cómo se me puede enviar una notificación si las actualizaciones de la sombra de mi objeto se
rechazan cada día? (p. 229)
Más información sobre alarmas y métricas de CloudWatch

• Creación de alarmas de CloudWatch para monitorizar AWS IoT (p. 228)
• Métricas y dimensiones de AWS IoT (p. 230)
227
Creación de alarmas de CloudWatch en AWS IoT
Creación de alarmas de CloudWatch para monitorizar

AWS IoT
Puede crear una alarma de CloudWatch que envíe un mensaje de Amazon SNS cuando la alarma cambie
de estado. Una alarma vigila una métrica individual durante un periodo de tiempo que usted especifica.
Cuando el valor de la métrica supera un umbral determinado en un número de períodos de tiempo, se
realizan una o varias acciones. La acción puede ser una notificación enviada a un tema de Amazon SNS
o una política de Auto Scaling. Las alarmas desencadenan acciones únicamente para cambios de estado
prolongados. Las alarmas de CloudWatch no desencadenan acciones simplemente por tener un estado
determinado. Es necesario que el estado haya cambiado y se mantenga durante un número determinado
de períodos.
En los temas siguientes se describen algunos ejemplos del uso de alarmas de CloudWatch.
• ¿Cómo se me puede enviar una notificación si mis objetos no se conectan correctamente cada
día? (p. 228)
• ¿Cómo se me puede enviar una notificación si mis objetos no publican datos cada día? (p. 229)
• ¿Cómo se me puede enviar una notificación si las actualizaciones de la sombra de mi objeto se
rechazan cada día? (p. 229)
Puede ver todas las métricas en las que las alarmas de CloudWatch pueden monitorear en Métricas y
dimensiones de AWS IoT (p. 230).
¿Cómo se me puede enviar una notificación si mis objetos no se

conectan correctamente cada día?
1. Cree un tema de Amazon SNS denominado things-not-connecting-successfully y registre
su nombre de recurso de Amazon (ARN). Este procedimiento se referirá al ARN de su tema como
<sns-topic-arn>.
Para obtener más información sobre cómo crear una notificación de Amazon SNS, consulte
Introducción a Amazon SNS.
2. Cree la alarma.
aws cloudwatch put-metric-alarm \

--alarm-name ConnectSuccessAlarm \
--alarm-description "Alarm when my Things don't connect successfully" \
--namespace AWS/IoT \
--metric-name Connect.Success \
--dimensions Name=Protocol,Value=MQTT \
--statistic Sum \
--threshold 10 \
--comparison-operator LessThanThreshold \
--period 86400 \
--unit Count \
--evaluation-periods 1 \
--alarm-actions <sns-topic-arn>
3. Pruebe la alarma.
aws cloudwatch set-alarm-state --alarm-name ConnectSuccessAlarm --state-reason

"initializing" --state-value OK
228
Creación de alarmas de CloudWatch en AWS IoT
aws cloudwatch set-alarm-state --alarm-name ConnectSuccessAlarm --state-reason

"initializing" --state-value ALARM
4. Compruebe que la alarma aparece en la consola de CloudWatch.
¿Cómo se me puede enviar una notificación si mis objetos no

publican datos cada día?
1. Cree un tema de Amazon SNS denominado things-not-publishing-data y registre su nombre
de recurso de Amazon (ARN). Este procedimiento se referirá al ARN de su tema como <sns-topic-
arn>.
2. Cree la alarma.

--alarm-name PublishInSuccessAlarm\
--alarm-description "Alarm when my Things don't publish their data \
--metric-name PublishIn.Success \
--statistic Sum \
--threshold 10 \
--period 86400 \
--unit Count \
aws cloudwatch set-alarm-state --alarm-name PublishInSuccessAlarm --state-reason

"initializing" --state-value OK
aws cloudwatch set-alarm-state --alarm-name PublishInSuccessAlarm --state-reason

"initializing" --state-value ALARM
¿Cómo se me puede enviar una notificación si las

actualizaciones de la sombra de mi objeto se rechazan cada día?
1. Cree un tema de Amazon SNS denominado things-shadow-updates-rejected y registre su
nombre de recurso de Amazon (ARN). Este procedimiento se referirá al ARN de su tema como <sns-
topic-arn>.
2. Cree la alarma.

--alarm-name UpdateThingShadowSuccessAlarm \
229
Métricas y dimensiones de AWS IoT
--alarm-description "Alarm when my Things Shadow updates are getting rejected" \

--metric-name UpdateThingShadow.Success \
--statistic Sum \
--threshold 10 \
--period 86400 \
--unit Count \
aws cloudwatch set-alarm-state --alarm-name UpdateThingShadowSuccessAlarm --state-

reason "initializing" --state-value OK
aws cloudwatch set-alarm-state --alarm-name UpdateThingShadowSuccessAlarm --state-

reason "initializing" --state-value ALARM

Cuando se interactúa con AWS IoT, el servicio envía las siguientes métricas y dimensiones a CloudWatch
cada minuto. Puede seguir los siguientes procedimientos para ver las métricas de AWS IoT.
Para ver las métricas (consola de CloudWatch)
Las métricas se agrupan en primer lugar por el espacio de nombres de servicio y, a continuación, por las
diversas combinaciones de dimensiones dentro de cada espacio de nombres.
1. Abra la consola de CloudWatch en https://console.aws.amazon.com/cloudwatch/.

2. En el panel de navegación, seleccione Metrics.
3. En el panel Métricas de CloudWatch por categoría, en la categoría de métricas de AWS IoT, elija una
categoría de métricas y, a continuación, en el panel superior, desplácese hasta ver la lista completa de
métricas.
Para ver las métricas (CLI)
• En el símbolo del sistema, ejecute el siguiente comando:
aws cloudwatch list-metrics --namespace "AWS/IoT"
CloudWatch muestra los siguientes grupos de métricas para AWS IoT:

• Métricas de AWS IoT (p. 231)
• Métricas de reglas (p. 231)
• Métricas de acciones de reglas (p. 231)
• Métricas específicas de acciones HTTP (p. 232)
• Métricas del agente de mensajes (p. 232)
• Métricas de sombras de dispositivos (p. 235)
• Métricas de trabajos (p. 235)
230
• Métricas de auditoría de Device Defender (p. 237)

• Métricas de detección de Device Defender (p. 237)
• Métricas de aprovisionamiento de dispositivos (p. 238)
• Dimensiones de las métricas (p. 238)
Métricas de AWS IoT
Métrica Descripción
AddThingToDynamicThingGroupsFailed Número de eventos de error asociados a la incorporación

de un objeto en un grupo de objetos dinámico. La
dimensión DynamicThingGroupName contiene el
nombre de los grupos dinámicos que no pudieron
agregar objetos correctamente.
El lote de eventos de registro único que no se pudieron

NumLogBatchesFailedToPublishThrottled
publicar debido a errores de limitación controlada.
NumLogEventsFailedToPublishThrottledEl número de eventos de registro en el lote que no

se pudieron publicar debido a errores de limitación
controlada.
RulesExecuted El número de reglas de AWS IoT ejecutadas.
Métricas de reglas
ParseError El número de errores de análisis JSON que se

produjeron en los mensajes publicados en un tema en el
que hay una regla a la escucha. La dimensión RuleName
contiene el nombre de la regla.
RuleMessageThrottled El número de mensajes limitados por el motor de reglas

por un comportamiento malintencionado o porque el
número de mensajes supera el límite del motor de reglas.
La dimensión RuleName contiene el nombre de la regla
que activar.
RuleNotFound No se ha podido encontrar la regla que activar. La

dimensión RuleName contiene el nombre de la regla.
TopicMatch El número de mensajes entrantes publicados en un tema

en el que hay una regla a la escucha. La dimensión
RuleName contiene el nombre de la regla.
Métricas de acciones de reglas
Failure El número de llamadas a una acción de regla que

produjeron un error. La dimensión RuleName contiene
231
el nombre de la regla que especifica la acción. La
dimensión RuleName contiene el nombre de la regla que
especifica la acción. La dimensión ActionType contiene
el tipo de acción que se invocó.
Success El número de llamadas correctas a una acción de regla.

La dimensión RuleName contiene el nombre de la regla
que especifica la acción. La dimensión ActionType
contiene el tipo de acción que se invocó.
Métricas específicas de acciones HTTP
HttpCode_Other Se genera si el código de estado de la respuesta del

servicio o aplicación web de salida no es 2xx, 4xx o 5xx.
HttpCode_4XX Se genera si el código de estado de la respuesta del

servicio o aplicación web de salida está comprendido en
el intervalo 400 y 499.
HttpCode_5XX Se genera si el código de estado de la respuesta del

servicio o aplicación web de salida está comprendido en
el intervalo 500 y 599.
HttpInvalidUrl Se genera si una URL de punto de enlace, una vez

reemplazadas las plantillas de sustitución, no comienza
por https://.
HttpRequestTimeout Se genera si el servicio o la aplicación web de salida no

devuelve ninguna respuesta dentro del límite de tiempo
de espera de solicitud. Para obtener más información,
consulte Cuotas de servicio.
HttpUnknownHost Se genera si la URL es válida, pero el servicio no existe

o no está accesible.
Métricas del agente de mensajes
Connect.AuthError El número de solicitudes de conexión que el agente de

mensajes no pudo autorizar. La dimensión Protocol
contiene el protocolo usado para enviar el mensaje
CONNECT.
Connect.ClientError El número de solicitudes de conexión rechazadas porque

el mensaje MQTT no cumplía los requisitos definidos en
Cuotas de AWS IoT (p. 774). La dimensión Protocol
CONNECT.
232
Connect.ClientIDThrottle El número de solicitudes de conexión que se rechazaron

porque el cliente superó el límite de solicitudes de
conexión permitidas para un ID de cliente específico. La
dimensión Protocol contiene el protocolo usado para
enviar el mensaje CONNECT.
Connect.ServerError El número de solicitudes de conexión que fracasaron

porque se produjo un error interno. La dimensión
Protocol contiene el protocolo usado para enviar el
mensaje CONNECT.
Connect.Success El número de conexiones realizadas correctamente al

agente de mensajes. La dimensión Protocol contiene
el protocolo usado para enviar el mensaje CONNECT.
Connect.Throttle Número de solicitudes de conexión que se rechazaron

porque la cuenta superó el límite permitido. La dimensión
mensaje CONNECT.
Ping.Success El número de mensajes ping recibidos por el agente de

mensajes. La dimensión Protocol contiene el protocolo
usado para enviar el mensaje ping.
PublishIn.AuthError El número de solicitudes de publicación que el agente de

mensajes no pudo autorizar. La dimensión Protocol
contiene el protocolo usado para publicar el mensaje.
PublishIn.ClientError El número de solicitudes de publicación rechazadas por

el agente de mensajes porque el mensaje no cumplía los
requisitos definidos en Cuotas de AWS IoT (p. 774). La
publicar el mensaje.
PublishIn.ServerError El número de solicitudes de publicación que el agente de

mensajes no pudo procesar porque se produjo un error
interno. La dimensión Protocol contiene el protocolo
usado para enviar el mensaje PUBLISH.
PublishIn.Success El número de solicitudes de publicación que el agente

de mensajes procesó correctamente. La dimensión
mensaje PUBLISH.
PublishIn.Throttle El número de solicitudes de publicación que se

rechazaron porque el cliente superó el límite de
mensajes entrantes permitidos. La dimensión Protocol
PUBLISH.
PublishOut.AuthError El número de solicitudes de publicación realizadas por el

agente de mensajes que AWS IoT no pudo autorizar. La
enviar el mensaje PUBLISH.
233
PublishOut.ClientError El número de solicitudes de publicación realizadas

por el agente de mensajes que se rechazaron porque
el mensaje no cumplía los requisitos definidos en
Cuotas de AWS IoT (p. 774). La dimensión Protocol
PUBLISH.
PublishOut.Success El número de solicitudes de publicación realizadas

correctamente por el agente de mensajes. La dimensión
mensaje PUBLISH.
Subscribe.AuthError El número de solicitudes de suscripción realizadas por

un cliente que no se pudieron autorizar. La dimensión
mensaje SUBSCRIBE.
Subscribe.ClientError El número de solicitudes de suscripción que se

rechazaron porque el mensaje SUBSCRIBE no cumplía
los requisitos definidos en Cuotas de AWS IoT (p. 774).
La dimensión Protocol contiene el protocolo usado
para enviar el mensaje SUBSCRIBE.
Subscribe.ServerError El número de solicitudes de suscripción que se

rechazaron porque se produjo un error interno. La
enviar el mensaje SUBSCRIBE.
Subscribe.Success El número de solicitudes de suscripción que el agente

de mensajes procesó correctamente. La dimensión
mensaje SUBSCRIBE.
Subscribe.Throttle El número de solicitudes de suscripción que se

rechazaron porque el cliente superó el límite de
solicitudes de suscripción permitidas. La dimensión
mensaje SUBSCRIBE.
Unsubscribe.ClientError Número de solicitudes de cancelación de suscripción

que se rechazaron porque el mensaje UNSUBSCRIBE
no cumplía los requisitos definidos en Cuotas de AWS
IoT (p. 774). La dimensión Protocol contiene el
protocolo usado para enviar el mensaje UNSUBSCRIBE.
Unsubscribe.ServerError El número de solicitudes de cancelación de suscripción

que se rechazaron porque se produjo un error interno. La
enviar el mensaje UNSUBSCRIBE.
Unsubscribe.Success El número de solicitudes de cancelación de suscripción

que el agente de mensajes procesó correctamente. La
234
Unsubscribe.Throttle El número de solicitudes de cancelación de suscripción

que se rechazaron porque el cliente superó el límite de
solicitudes de cancelación de suscripción permitidas. La
Note
Las métricas del agente de mensajes se muestran en la consola de AWS IoT bajo Protocol
Metrics (Métricas del protocolo).
Métricas de sombras de dispositivos
DeleteThingShadow.Accepted El número de solicitudes DeleteThingShadow

procesadas correctamente. La dimensión Protocol
contiene el protocolo usado para realizar la solicitud.
GetThingShadow.Accepted El número de solicitudes GetThingShadow procesadas

correctamente. La dimensión Protocol contiene el
protocolo usado para realizar la solicitud.
UpdateThingShadow.Accepted El número de solicitudes UpdateThingShadow

procesadas correctamente. La dimensión Protocol
contiene el protocolo usado para realizar la solicitud.
Note
Las métricas de sombras de dispositivos se muestran en la consola de AWS IoT bajo Protocol
Metrics (Métricas del protocolo).
Métricas de trabajos
CanceledJobExecutionCount Número de ejecuciones de trabajo cuyo estado ha

cambiado a CANCELED durante un periodo determinado
por CloudWatch. Para obtener más información acerca
de las métricas de CloudWatch, consulte Métricas de
Amazon CloudWatch. La dimensión JobId contiene el
ID del trabajo.
CanceledJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es CANCELED para el trabajo especificado. La dimensión
JobId contiene el ID del trabajo.
ClientError El número de errores de cliente generados mientras se

ejecuta el trabajo. La dimensión JobId contiene el ID del
trabajo.
FailedJobExecutionCount Número de ejecuciones de trabajo cuyo estado ha

cambiado a FAILED durante un periodo determinado
235
ID del trabajo.
FailedJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es FAILED para el trabajo especificado. La dimensión
InProgressJobExecutionCount Número de ejecuciones de trabajo cuyo estado

ha cambiado a IN_PROGRESS durante un periodo
determinado por CloudWatch. Para obtener más
información acerca de las métricas de CloudWatch,
consulte Métricas de Amazon CloudWatch. La dimensión
InProgressJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es IN_PROGRESS para el trabajo especificado. La
dimensión JobId contiene el ID del trabajo.
RejectedJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es REJECTED para el trabajo especificado. La dimensión
RemovedJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es REMOVED para el trabajo especificado. La dimensión
QueuedJobExecutionCount Número de ejecuciones de trabajo cuyo estado ha

cambiado a QUEUED durante un periodo determinado
ID del trabajo.
QueuedJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es QUEUED para el trabajo especificado. La dimensión
RejectedJobExecutionCount Número de ejecuciones de trabajo cuyo estado ha

cambiado a REJECTED durante un periodo determinado
ID del trabajo.
RemovedJobExecutionCount Número de ejecuciones de trabajo cuyo estado ha

cambiado a REMOVED durante un periodo determinado
ID del trabajo.
ServerError El número de errores de servidor generados mientras se

ejecuta el trabajo. La dimensión JobId contiene el ID del
trabajo.
236
SuccededJobExecutionCount Número de ejecuciones de trabajo cuyo estado ha

cambiado a SUCCESS durante un periodo determinado
ID del trabajo.
SuccededJobExecutionTotalCount El número total de ejecuciones de trabajo cuyo estado

es SUCCESS para el trabajo especificado. La dimensión
Métricas de auditoría de Device Defender
NonCompliantResources Número de recursos que se ha comprobado que no

cumplen los requisitos de una comprobación. El sistema
notifica el número de recursos no conformes en cada
comprobación de cada auditoría realizada.
ResourcesEvaluated Número de recursos cuya conformidad se evaluó. El

sistema notifica el número de recursos que se evaluaron
en cada comprobación de cada auditoría realizada.
Métricas de detección de Device Defender
Violations El número de nuevas infracciones de los

comportamientos del perfil de seguridad que se
han encontrado desde la última vez que se realizó
una evaluación. El sistema comunica el número de
infracciones nuevas de la cuenta, de un perfil de
seguridad específico y de un comportamiento concreto
de un perfil de seguridad determinado.
ViolationsCleared El número de infracciones de los comportamientos del

perfil de seguridad que se han resuelto desde la última
vez que se realizó una evaluación. El sistema comunica
el número de infracciones resueltas de la cuenta, para un
perfil de seguridad específico y para un comportamiento
concreto de un perfil de seguridad determinado.
ViolationsInvalidated El número de infracciones de los comportamientos del

perfil de seguridad de las que ya no está disponible
la información desde la última vez que se realizó una
evaluación (debido a que el dispositivo de informe
dejó de realizar informes o a que ya no se monitoriza
por algún motivo). El sistema comunica el número de
infracciones invalidadas de toda la cuenta, de un perfil de
237
seguridad específico y de un comportamiento concreto
de un perfil de seguridad determinado.
Métricas de aprovisionamiento de dispositivos
CreateKeysAndCertificateFailed Número de errores que se han producido al llamar a la

API CreateKeysAndCertificate de MQTT.
GetDeviceCredentialsSucceeded Número de llamadas correctas a la API

GetDeviceCredentials.
GetDeviceCredentialsFailed Número de llamadas a GetDeviceCredentials que

produjeron un error.
DeviceProvisioningFailed Número de dispositivos que no se pudieron aprovisionar.
DeviceProvisioningSucceeded Número de dispositivos aprovisionados correctamente.
RegisterThingFailed Número de errores que se produjeron al llamar a la API

RegisterThing de MQTT.
Dimensiones de las métricas

Las métricas utilizan el espacio de nombres y proporcionan métricas para las siguientes
dimensiones.
Dimensión Descripción
ActionType El tipo de acción (p. 292) especificado por la regla que

activó la solicitud.
Protocol El protocolo utilizado para realizar la solicitud. Los

valores válidos son: MQTT o HTTP
RuleName El nombre de la regla activada por la solicitud.
JobId El ID del trabajo cuyo progreso o tasa de éxito/error para

la conexión de mensajes se está monitorizando.
CheckName El nombre de la comprobación de auditoría Device

Defender cuyos resultados se están monitoreando.
ScheduledAuditName El nombre de la auditoría programada de Device

Defender cuyos resultados de comprobación se están
monitoreando. Tiene el valor OnDemandsi los resultados
registrados corresponden a una auditoría que se realizó
bajo demanda.
SecurityProfileName El nombre del perfil de seguridad de detección de

Device Defender cuyos comportamientos se están
monitoreando.
238
Monitoreo de AWS IoT mediante CloudWatch Logs
Dimensión Descripción
BehaviorName El nombre del comportamiento del perfil de seguridad de

Device Defender Detect que se está monitorizando.
TemplateName El nombre de la plantilla de aprovisionamiento.
Monitoreo de AWS IoT mediante CloudWatch Logs

Cuando el registro de AWS IoT está habilitado (p. 221), AWS IoT envía eventos de progreso acerca de
cada mensaje a medida que este pasa desde los dispositivos al agente de mensajes y al motor de reglas.
En la consola de CloudWatch, los registros de CloudWatch aparecen en un grupo de registros denominado
AWSIotLogs.
Para obtener más información acerca de CloudWatch Logs, consulte CloudWatch Logs. Para obtener
más información sobre los CloudWatch Logs admitidos para AWS IoT, consulte Entradas de registro de
CloudWatch en AWS IoT (p. 240).
Visualización de registros de AWS IoT en la consola

de CloudWatch
Puede ver sus registros de AWS IoT en la consola de CloudWatch.
1. Desplácese hasta https://console.aws.amazon.com/cloudwatch/. En el panel de navegación, elija

Logs.
2. En el cuadro Filter (Filtro), escriba AWSIotLogsV2 y, a continuación, pulse Intro.
3. Haga doble clic en el grupo de registros AWSIotLogsV2.
4. Elija Search Log Group (Buscar grupo de registros). Se genera una lista completa de registros de
AWS IoT para la cuenta.
5. Elija el icono de ampliar para analizar un flujo individual.
También puede escribir una consulta en el cuadro de texto Filter events (Filtrar eventos). Aquí tiene
algunas consultas interesantes que probar:
• { $.logLevel = "INFO" }
Busque todos los registros que tengan un nivel de registro de INFO.

• { $.status = "Success" }
Busque todos los registros que tengan un estado de Success.

• { $.status = "Success" && $.eventType = "GetThingShadow" }
Busque todos los registros que tengan un estado de Success y un tipo de evento de
GetThingShadow.
Para obtener más información acerca de la creación de expresiones de filtro, vea Consultas de
CloudWatch Logs.
239
Entradas de registro de CloudWatch en AWS IoT

Cada componente de AWS IoT genera sus propias entradas de registro. Cada entrada de registro tiene un
eventType que especifica la operación que provocó que se genere la entrada de registro. En esta sección
se describen las entradas de registro generadas por los siguientes componentes de AWS IoT:
Temas
• Entradas de registro del agente de mensajes (p. 240)
• Entradas de registro de sombre de dispositivo (p. 244)
• Entradas del registro del motor de reglas (p. 246)
• Entradas del registro de Job (p. 250)
• Entradas de registro de aprovisionamiento de dispositivos (p. 254)
• Entradas de registro de grupo de objetos dinámicos (p. 255)
• Atributos de CloudWatch Logs comunes (p. 256)
Entradas de registro del agente de mensajes

El agente de mensajes de AWS IoT genera entradas de registro para los siguientes eventos:
Temas
• Entrada de registro Connect (p. 240)
• Entrada de registro Disconnect (p. 241)
• Entrada de registro Publish-In (p. 241)
• Entrada de registro Publish-Out (p. 242)
• Entrada de registro Subscribe (p. 243)
Entrada de registro Connect

El agente de mensajes de AWS IoT genera una entrada de registro con un eventType de Connect
cuando se conecta un cliente MQTT.
Ejemplo de entrada de registro Connect
{
"timestamp": "2017-08-10 15:37:23.476",
"logLevel": "INFO",
"traceId": "20b23f3f-d7f1-feae-169f-82263394fbdb",
"accountId": "123456789012",
"status": "Success",
"eventType": "Connect",
"protocol": "MQTT",
"clientId": "abf27092886e49a8a5c1922749736453",
"principalId": "145179c40e2219e18a909d896a5340b74cf97a39641beec2fc3eeafc5a932167",
"sourceIp": "205.251.233.181",
"sourcePort": 13490
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro Connect
contienen los siguientes atributos:
clientId
El ID del cliente que realiza la solicitud.
240
principalId
El ID de la entidad principal que realiza la solicitud.

protocolo
El protocolo utilizado cuando se realiza la solicitud. Los valores válidos son MQTT o HTTP.
sourceIp
La dirección IP en la que se originó la solicitud.

sourcePort
El puerto en el que se originó la solicitud.
Entrada de registro Disconnect

El agente de mensajes de AWS IoT genera una entrada de registro con un eventType de Disconnect
cuando se desconecta un cliente MQTT.
Ejemplo de entrada de registro Disconnect
{
"timestamp": "2017-08-10 15:37:23.476",
"logLevel": "INFO",
"traceId": "20b23f3f-d7f1-feae-169f-82263394fbdb",
"accountId": "123456789012",
"eventType": "Disconnect",
"protocol": "MQTT",
"sourceIp": "205.251.233.181",
"sourcePort": 13490
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro Disconnect
clientId

principalId

protocolo
sourceIp

sourcePort
Entrada de registro Publish-In

Cuando el agente de mensajes de AWS IoT recibe un mensaje MQTT, genera una entrada de registro con
un eventType de Publish-In.
241
Ejemplo de entrada de registro Publish-In
{
"timestamp": "2017-08-10 15:39:30.961",
"logLevel": "INFO",
"traceId": "672ec480-31ce-fd8b-b5fb-22e3ac420699",
"accountId": "123456789012",
"eventType": "Publish-In",
"protocol": "MQTT",
"topicName": "$aws/things/MyThing/shadow/get",
"sourceIp": "205.251.233.181",
"sourcePort": 13490
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro Publish-In
clientId

principalId

protocolo
sourceIp

sourcePort

topicName
El nombre del tema suscrito.
Entrada de registro Publish-Out

Cuando el agente de mensajes publica un mensaje MQTT, genera una entrada de registro con un
eventType de Publish-Out.
Ejemplo de entrada de registro Publish-Out
{
"timestamp": "2017-08-10 15:39:30.961",
"logLevel": "INFO",
"traceId": "672ec480-31ce-fd8b-b5fb-22e3ac420699",
"accountId": "123456789012",
"eventType": "Publish-Out",
"protocol": "MQTT",
"topicName": "$aws/things/MyThing/shadow/get",
"sourceIp": "205.251.233.181",
"sourcePort": 13490
242
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro Publish-Out
clientId

principalId

protocolo
sourceIp

sourcePort

topicName
Entrada de registro Subscribe

El agente de mensajes de AWS IoT genera una entrada de registro con un eventType de Subscribe
cuando un cliente MQTT se suscribe a un tema.
Ejemplo de entrada de registro Subscribe
{
"timestamp": "2017-08-10 15:39:04.413",
"logLevel": "INFO",
"traceId": "7aa5c38d-1b49-3753-15dc-513ce4ab9fa6",
"accountId": "123456789012",
"eventType": "Subscribe",
"protocol": "MQTT",
"topicName": "$aws/things/MyThing/shadow/#",
"sourceIp": "205.251.233.181",
"sourcePort": 13490
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro Subscribe
clientId

principalId

protocolo
243
sourceIp

sourcePort

topicName
Entradas de registro de sombre de dispositivo

El servicio de sombra de dispositivo de AWS IoT genera entradas de registro para los siguientes eventos:
Temas
• Entrada de registro DeleteThingShadow (p. 244)
• Entrada de registro GetThingShadow (p. 244)
• Entrada de registro UpdateThingShadow (p. 245)
Entrada de registro DeleteThingShadow

El servicio de sombra de dispositivo genera una entrada de registro con un eventType de
DeleteThingShadow cuando se recibe una solicitud de eliminación de la sombra de un dispositivo.
Ejemplo de entrada de registro DeleteThingShadow
{
"timestamp": "2017-08-07 18:47:56.664",
"logLevel": "INFO",
"traceId": "1a60d02e-15b9-605b-7096-a9f584a6ad3f",
"accountId": "123456789012",
"eventType": "DeleteThingShadow",
"protocol": "MQTT",
"deviceShadowName": "Jack",
"topicName": "$aws/things/Jack/shadow/delete"
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro
DeleteThingShadow contienen los siguientes atributos:
deviceShadowName
Nombre de la sombra que se va a actualizar.

protocolo
topicName
El nombre del tema en el que se publicó la solicitud.
Entrada de registro GetThingShadow

GetThingShadow cuando se recibe una solicitud de obtención para una sombra.
244
Ejemplo de entrada de registro GetThingShadow
{
"timestamp": "2017-08-09 17:56:30.941",
"logLevel": "INFO",
"traceId": "b575f19a-97a2-cf72-0ed0-c64a783a2504",
"accountId": "123456789012",
"eventType": "GetThingShadow",
"protocol": "MQTT",
"deviceShadowName": "MyThing",
"topicName": "$aws/things/MyThing/shadow/get"
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro GetThingShadow
deviceShadowName
El nombre de la sombra solicitada.

protocolo
topicName
Entrada de registro UpdateThingShadow

UpdateThingShadow cuando se recibe una solicitud de actualización de la sombra de un dispositivo.
Ejemplo de entrada de registro UpdateThingShadow
{
"timestamp": "2017-08-07 18:43:59.436",
"logLevel": "INFO",
"traceId": "d0074ba8-0c4b-a400-69df-76326d414c28",
"accountId": "123456789012",
"eventType": "UpdateThingShadow",
"protocol": "MQTT",
"deviceShadowName": "Jack",
"topicName": "$aws/things/Jack/shadow/update"
}
UpdateThingShadow contienen los siguientes atributos:
deviceShadowName
Nombre de la sombra que se va a actualizar.

protocolo
topicName
245
Entradas del registro del motor de reglas

El motor de reglas de AWS IoT genera registros para los siguientes eventos:
Temas
• Entrada de registro FunctionExecution (p. 246)
• Entrada de registro de RuleExecution (p. 247)
• Entrada de registro RuleMatch (p. 247)
• Entrada de registro RuleMessageThrottled (p. 248)
• Entrada de registro RuleNotFound (p. 249)
• Entrada de registro StartingRuleExecution (p. 250)
Entrada de registro FunctionExecution

El motor de reglas genera una entrada de registro con un eventType de FunctionExecution cuando
la consulta SQL de una regla llama a una función externa. Se llama a una función externa cuando una
acción de la regla realiza una solicitud HTTP a AWS IoT u otro servicio web (por ejemplo, llamar a
get_thing_shadow o machinelearning_predict).
Ejemplo de entrada de registro de FunctionExecution
{
"timestamp": "2017-07-13 18:33:51.903",
"logLevel": "DEBUG",
"traceId": "180532b7-0cc7-057b-687a-5ca1824838f5",
"eventType": "FunctionExecution",
"clientId": "N/A",
"topicName":"rules/test",
"ruleName": "ruleTestPredict",
"ruleAction": "MachinelearningPredict",
"resources": {
"ModelId": "predict-model"
},
"principalId": "145179c40e2219e18a909d896a5340b74cf97a39641beec2fc3eeafc5a932167"
}
FunctionExecution contienen los siguientes atributos:
clientId
N/A para registros FunctionExecution.

principalId

resources
Un conjunto de recursos utilizados por las acciones de la regla.

ruleName
El nombre de la regla que coincide.

topicName
246
Entrada de registro de RuleExecution

Cuando el motor de reglas de AWS IoT activa la acción de una regla, genera un registro de
RuleExecution.
Ejemplo de entrada de registro de RuleExecution
{
"timestamp": "2017-08-10 16:32:46.070",
"logLevel": "INFO",
"traceId": "30aa7ccc-1d23-0b97-aa7b-76196d83537e",
"accountId": "123456789012",
"eventType": "RuleExecution",
"topicName": "rules/test",
"ruleName": "JSONLogsRule",
"ruleAction": "RepublishAction",
"resources": {
"RepublishTopic": "rules/republish"
},
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro RuleExecution
clientId

principalId

resources
Un conjunto de recursos utilizados por las acciones de la regla.

ruleAction
El nombre de la acción activada.

ruleName

topicName
Entrada de registro RuleMatch

El motor de reglas de AWS IoT genera una entrada de registro con un eventType de RuleMatch cuando
el agente de mensajes recibe un mensaje que coincide con una regla.
Ejemplo de entrada de registro RuleMatch
{
"timestamp": "2017-08-10 16:32:46.002",
"logLevel": "INFO",
247
"accountId": "123456789012",
"eventType": "RuleMatch",
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro RuleMatch
clientId

principalId

ruleName

topicName
Entrada de registro RuleMessageThrottled

Cuando se limita un mensaje, el motor de reglas de AWS IoT genera una entrada de registro con un
eventType de RuleMessageThrottled.
Ejemplo de entrada de registro RuleMessageThrottled
{
"timestamp": "2017-10-04 19:25:46.070",
"accountId": "123456789012",
"eventType": "RuleMessageThrottled",
"topicName": "$aws/rules/example_rule",
"ruleName": "example_rule",
"reason": "RuleExecutionThrottled",
"details": "Message for Rule example_rule throttled"
}
RuleMessageThrottled contienen los siguientes atributos:
clientId

details
Una breve explicación del error.
248
principalId

reason
La cadena "RuleMessageThrottled".
ruleName
El nombre de la regla que se debe activar.

topicName
El nombre del tema publicado.
Entrada de registro RuleNotFound

Cuando el motor de reglas de AWS IoT no puede encontrar una regla con un nombre concreto, genera una
entrada de registro con un eventType de RuleNotFound.
Ejemplo de entrada de registro RuleNotFound
{
"timestamp": "2017-10-04 19:25:46.070",
"accountId": "123456789012",
"eventType": "RuleNotFound",
"topicName": "$aws/rules/example_rule",
"ruleName": "example_rule",
"reason": "RuleNotFound",
"details": "Rule example_rule not found"
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro RuleNotFound
clientId

details

principalId

reason
La cadena "RuleNotFound".
ruleName
El nombre de la regla que no se pudo encontrar.

topicName
El nombre del tema publicado.
249
Entrada de registro StartingRuleExecution

Cuando el motor de reglas de AWS IoT empieza a activar la acción de una regla, genera una entrada de
registro con un eventType de StartingRuleExecution.
Ejemplo de entrada de registro StartingRuleExecution
{
"timestamp": "2017-08-10 16:32:46.002",
"accountId": "123456789012",
"eventType": "StartingRuleExecution",
"ruleAction": "RepublishAction",
}
Además de Atributos de CloudWatch Logs comunes (p. 256), las entradas de registro rule- contienen
los siguientes atributos:
clientId

principalId

ruleAction
El nombre de la acción activada.

ruleName

topicName
Entradas del registro de Job

El servicio Job de AWS IoT genera entradas de registro para los siguientes eventos. Las entradas de
registro se generan cuando se recibe una solicitud de MQTT o HTTP procedente del dispositivo.
Temas
• Entrada de registro DescribeJobExecution (p. 250)
• Entrada de registro GetPendingJobExecution (p. 251)
• Entrada de registro ReportFinalJobExecutionCount (p. 252)
• Entrada de registro StartNextPendingJobExecution (p. 252)
• Entrada de registro UpdateJobExecution (p. 253)
Entrada de registro DescribeJobExecution

El servicio Jobs de AWS IoT genera una entrada de registro con un eventType de
DescribeJobExecution cuando el servicio recibe una solicitud para describir la ejecución de un trabajo.
250
Ejemplo de entrada de registro DescribeJobExecution
{
"timestamp": "2017-08-10 19:13:22.841",
"accountId": "123456789012",
"eventType": "DescribeJobExecution",
"protocol": "MQTT",
"clientId": "thingOne",
"jobId": "002",
"topicName": "$aws/things/thingOne/jobs/002/get",
"clientToken": "myToken",
"details": "The request status is SUCCESS."
}
GetJobExecution contienen los siguientes atributos:
clientId

clientToken
Identificador único con distinción entre mayúsculas y minúsculas que permite garantizar la
idempotencia de la solicitud. Para obtener más información, consulte How to Ensure Idempotency.
details
Información adicional del servicio Jobs.

jobId
El ID de trabajo para la ejecución de trabajos.

protocolo
topicName
El tema utilizado para realizar la solicitud.
Entrada de registro GetPendingJobExecution

El servicio de Jobs de AWS IoT genera una entrada de registro con un eventType de
GetPendingJobExecution cuando el servicio recibe una solicitud de ejecución de un trabajo.
Ejemplo de entrada de registro GetPendingJobExecution
{
"timestamp": "2018-06-13 17:45:17.197",
"accountId": "123456789012",
"eventType": "GetPendingJobExecution",
"protocol": "MQTT",
"clientId": "299966ad-54de-40b4-99d3-4fc8b52da0c5",
"topicName": "$aws/things/299966ad-54de-40b4-99d3-4fc8b52da0c5/jobs/get",
"clientToken": "24b9a741-15a7-44fc-bd3c-1ff2e34e5e82",
251
GetPendingJobExecution contienen los siguientes atributos:
clientId

clientToken
details

protocolo
topicName
Entrada de registro ReportFinalJobExecutionCount

El servicio Jobs de AWS IoT genera una entrada de registro con un entryType de
ReportFinalJobExecutionCount cuando se completa un trabajo.
Ejemplo de entrada de registro ReportFinalJobExecutionCount
{
"timestamp": "2017-08-10 19:44:16.776",
"logLevel": "INFO",
"accountId": "123456789012",
"eventType": "ReportFinalJobExecutionCount",
"jobId": "002",
"details": "Job 002 completed. QUEUED job execution count: 0 IN_PROGRESS job execution
count: 0 FAILED job execution count: 0 SUCCEEDED job execution count: 1 CANCELED job
execution count: 0 REJECTED job execution count: 0 REMOVED job execution count: 0"
}
ReportFinalJobExecutionCount contienen los siguientes atributos:
details

jobId
Entrada de registro StartNextPendingJobExecution

Cuando recibe una solicitud para iniciar la siguiente ejecución de trabajo pendiente, el servicio Jobs de
AWS IoT genera una entrada de registro con un eventType de StartNextPendingJobExecution.
252
Ejemplo de entrada de registro StartNextPendingJobExecution
{
"timestamp": "2018-06-13 17:49:51.036",
"accountId": "123456789012",
"eventType": "StartNextPendingJobExecution",
"protocol": "MQTT",
"clientId": "95c47808-b1ca-4794-bc68-a588d6d9216c",
"topicName": "$aws/things/95c47808-b1ca-4794-bc68-a588d6d9216c/jobs/start-next",
"clientToken": "bd7447c4-3a05-49f4-8517-dd89b2c68d94",
}
StartNextPendingJobExecution contienen los siguientes atributos:
clientId

clientToken
details

protocolo
topicName
Entrada de registro UpdateJobExecution

El servicio Jobs de AWS IoT genera una entrada de registro con un eventType de
UpdateJobExecution cuando el servicio recibe una solicitud para actualizar una ejecución de un trabajo.
Ejemplo de entrada de registro UpdateJobExecution
{
"timestamp": "2017-08-10 19:25:14.758",
"accountId": "123456789012",
"eventType": "UpdateJobExecution",
"protocol": "MQTT",
"clientId": "thingOne",
"jobId": "002",
"topicName": "$aws/things/thingOne/jobs/002/update",
"clientToken": "myClientToken",
"versionNumber": "1",
"details": "The destination status is IN_PROGRESS. The request status is SUCCESS."
}
UpdateJobExecution contienen los siguientes atributos:
253
clientId

clientToken
details

jobId

protocolo
topicName

versionNumber
La versión de la ejecución de trabajos.
Entradas de registro de aprovisionamiento de dispositivos

El servicio Aprovisionamiento de dispositivos de AWS IoT genera registros para los siguientes eventos:
Temas
• Entrada de registro GetDeviceCredentials (p. 254)
• Entrada de registro de ProvisionDevice (p. 255)
Entrada de registro GetDeviceCredentials

El servicio de aprovisionamiento de dispositivos de AWS IoT genera una entrada de registro con un
eventType de GetDeviceCredential cuando un cliente llama a GetDeviceCredential.
Ejemplo de entrada de registro GetDeviceCredentials
{
"timestamp" : "2019-02-20 20:31:22.932",
"logLevel" : "INFO",
"traceId" : "8d9c016f-6cc7-441e-8909-7ee3d5563405",
"accountId" : "123456789101",
"status" : "Success",
"eventType" : "GetDeviceCredentials",
"deviceCertificateId" :
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"details" : "Additional details about this log."
}
GetDeviceCredentials contienen los siguientes atributos:
details
254
deviceCertificateId
El ID del certificado del dispositivo.
Entrada de registro de ProvisionDevice

El servicio de aprovisionamiento de dispositivos de AWS IoT genera una entrada de registro con un
eventType de ProvisionDevice cuando un cliente llama a ProvisionDevice.
Ejemplo de entrada de registro de ProvisionDevice
{
"timestamp" : "2019-02-20 20:31:22.932",
"logLevel" : "INFO",
"traceId" : "8d9c016f-6cc7-441e-8909-7ee3d5563405",
"accountId" : "123456789101",
"status" : "Success",
"eventType" : "ProvisionDevice",
"provisioningTemplateName" : "myTemplate",
"deviceCertificateId" :
"e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"details" : "Additional details about this log."
}
ProvisionDevice contienen los siguientes atributos:
details

deviceCertificateId
El ID del certificado del dispositivo.

provisioningTemplateName
El nombre de la plantilla de aprovisionamiento.
Entradas de registro de grupo de objetos dinámicos

Los grupos de objetos dinámicos de AWS IoT generan registros para el siguiente evento.
Temas
• Entrada de registro AddThingToDynamicThingGroupsFailed (p. 255)
Entrada de registro AddThingToDynamicThingGroupsFailed

Cuando AWS IoT no es capaz de agregar un objeto a los grupos dinámicos especificados, genera una
entrada de registro con un eventType de AddThingToDynamicThingGroupsFailed. Esto ocurre
cuando un objeto cumplía los criterios para estar en el grupo de objetos dinámico, pero no se pudo agregar
a este grupo o se eliminó de él. Esto puede suceder por los motivos siguientes:
• El objeto ya es miembro del número máximo de grupos.

• Se utilizó la opción --override-dynamic-groups para agregar el objeto a un grupo de objetos estático. Se
eliminó de un grupo de objetos dinámico para hacerlo posible.
255
Para obtener más información, consulte este artículo sobre las limitaciones y conflictos de los grupos de
objetos dinámicos (p. 114).
Ejemplo de entrada de registro AddThingToDynamicThingGroupsFailed
En este ejemplo, se muestra la entrada de registro de un error

AddThingToDynamicThingGroupsFailed. En este ejemplo, TestThing cumplía los criterios para
estar en los grupos de objetos dinámicos que se indican en dynamicThingGroupNames, pero no pudo
agregarse a esos grupos dinámicos, tal y como se describe en reason.
{
"timestamp": "2020-03-16 22:24:43.804",
"traceId": "70b1f2f5-d95e-f897-9dcc-31e68c3e1a30",
"accountId": "571032923833",
"eventType": "AddThingToDynamicThingGroupsFailed",
"thingName": "TestThing",
"dynamicThingGroupNames": [
"DynamicThingGroup11",
"DynamicThingGroup14"
],
"reason": "The thing failed to be added to the given dynamic thing group(s) because the
thing already belongs to the maximum allowed number of groups."
}
AddThingToDynamicThingGroupsFailed contienen los siguientes atributos:
dynamicThingGroupNames
Matriz de los grupos de objetos dinámicos a los que no pudo agregarse el objeto.
reason
Razón por la cual el objeto no pudo agregarse a los grupos dinámicos.

thingName
Nombre del objeto que no pudo agregarse a un grupo de objetos dinámico.
Atributos de CloudWatch Logs comunes

Todas las entradas de registro de CloudWatch Logs incluyen estos atributos:
accountId
Su ID de cuenta de AWS.
eventType
El tipo de evento para el que se generó el registro. El valor del tipo de evento depende del evento que
generó la entrada de registro. Cada descripción de entrada de registro incluye el valor de eventType
para esa entrada de registro.
logLevel
El nivel de registro que se está utilizando. Para obtener más información, consulte the section called
“Niveles de registro” (p. 226).
256
Registre las llamadas a la API de
AWS IoT con AWS CloudTrail.
status
El estado de la solicitud.
timestamp
La marca de tiempo de UNIX de cuando el cliente se conectó al agente de mensajes de AWS IoT.
traceId
Un identificador generado aleatoriamente que puede utilizarse para correlacionar todos los registros
para una solicitud específica.
Registre las llamadas a la API de AWS IoT con

AWS CloudTrail.
AWS IoT está integrado con AWS CloudTrail, un servicio que proporciona un registro de las acciones
realizadas por un usuario, una función o un servicio de AWS en AWS IoT. CloudTrail captura todas las
llamadas a la API de AWS IoT como eventos, incluidas las llamadas procedentes de la consola de AWS
IoT y de las llamadas del código a las API de AWS IoT. Si crea un registro de seguimiento, puede habilitar
la entrega continua de eventos de CloudTrail a un bucket de Amazon S3, incluidos los eventos de AWS
IoT. Si no configura un registro de seguimiento, puede ver los eventos más recientes en la consola de
CloudTrail en el Event history (Historial de eventos). Mediante la información que recopila CloudTrail, se
puede determinar la solicitud que se envió a AWS IoT, la dirección IP desde la que se realizó la solicitud,
quién la realizó, cuándo la realizó y otros detalles.
Para obtener más información sobre CloudTrail, consulte la AWS CloudTrail User Guide.
Información de AWS IoT en CloudTrail

CloudTrail se habilita en una cuenta de AWS al crearla. Cuando se produce una actividad en AWS IoT,
dicha actividad se registra en un evento de CloudTrail junto con los eventos de los demás servicios de
AWS en el Event history (Historial de eventos). Puede ver, buscar y descargar los últimos eventos de
la cuenta de AWS. Para obtener más información, consulte Visualización de eventos con el historial de
eventos de CloudTrail.
Para mantener un registro continuo de los eventos de la cuenta de AWS, incluidos los eventos de AWS
IoT, cree un registro de seguimiento. Un registro de seguimiento permite a CloudTrail enviar archivos de
registro a un bucket de Amazon S3. De forma predeterminada, cuando se crea un registro de seguimiento
en la consola, este se aplica a todas las regiones de AWS. El registro de seguimiento registra los eventos
de todas las regiones de AWS de la partición de AWS y envía los archivos de registro al bucket de Amazon
S3 especificado. También puede configurar otros servicios de AWS para analizar y actuar según los datos
de eventos recopilados en los registros de CloudTrail. Para obtener más información, consulte:
• Introducción a la creación de registros de seguimiento

• Servicios e integraciones compatibles con CloudTrail
• Configuración de notificaciones de Amazon SNS para CloudTrail
• Recibir archivos de registro de CloudTrail de varias regiones y Recepción de archivos de registro de
CloudTrail de varias cuentas
Note
Las acciones del plano de datos (lado del dispositivo) de AWS IoT no se registran en CloudTrail.
Utilice CloudWatch para supervisar estas acciones.
257
Descripción de las entradas de
archivos de registro de AWS IoT
Las acciones del plano de control de AWS IoT las registra CloudTrail. Por ejemplo, las llamadas a las
secciones CreateThing, ListThings y ListTopicRules generan entradas en los archivos de registro de
CloudTrail.
Cada entrada de registro o evento contiene información acerca de quién generó la solicitud. La información
de identidad del usuario le ayuda a determinar lo siguiente:
• Si la solicitud se realizó con las credenciales raíz o del usuario de IAM.

• Si la solicitud se realizó con credenciales de seguridad temporales de un rol o fue un usuario federado.
• Si la solicitud la realizó otro servicio de AWS.
Para obtener más información, consulte el elemento userIdentity de CloudTrail. Las acciones de AWS IoT
se documentan en la Referencia de la API de AWS IoT.
Descripción de las entradas de archivos de registro de

AWS IoT
Un registro de seguimiento es una configuración que permite la entrega de eventos como archivos de
registro al bucket de Amazon S3 que se especifique. Los archivos de registro de CloudTrail contienen
una o varias entradas de registro. Un evento representa una única solicitud de cualquier origen e incluye
información sobre la acción solicitada, la fecha y la hora de la acción, los parámetros de la solicitud,
etcétera. Los archivos de registro de CloudTrail no son un rastro de la pila ordenada de las llamadas a la
API públicas, por lo que no aparecen en ningún orden específico.
En el ejemplo siguiente, se muestra una entrada de registro de CloudTrail que ilustra la acción
AttachPolicy.
{
"timestamp":"1460159496",
"AdditionalEventData":"",
"Annotation":"",
"ApiVersion":"",
"ErrorCode":"",
"ErrorMessage":"",
"EventID":"8bff4fed-c229-4d2d-8264-4ab28a487505",
"EventName":"AttachPolicy",
"EventTime":"2016-04-08T23:51:36Z",
"EventType":"AwsApiCall",
"ReadOnly":"",
"RecipientAccountList":"",
"RequestID":"d4875df2-fde4-11e5-b829-23bf9b56cbcd",
"RequestParamters":{
"principal":"arn:aws:iot:us-
east-1:123456789012:cert/528ce36e8047f6a75ee51ab7beddb4eb268ad41d2ea881a10b67e8e76924d894",
"policyName":"ExamplePolicyForIoT"
},
"Resources":"",
"ResponseElements":"",
"SourceIpAddress":"52.90.213.26",
"UserAgent":"aws-internal/3",
"UserIdentity":{
"type":"AssumedRole",
"principalId":"AKIAI44QH8DHBEXAMPLE",
"arn":"arn:aws:sts::12345678912:assumed-role/iotmonitor-us-east-1-beta-
InstanceRole-1C5T1YCYMHPYT/i-35d0a4b6",
"accountId":"222222222222",
"accessKeyId":"access-key-id",
"sessionContext":{
258
Descripción de las entradas de
archivos de registro de AWS IoT
"attributes":{
"mfaAuthenticated":"false",
"creationDate":"Fri Apr 08 23:51:10 UTC 2016"
},
"sessionIssuer":{
"type":"Role",
"principalId":"AKIAI44QH8DHBEXAMPLE",
"arn":"arn:aws:iam::123456789012:role/executionServiceEC2Role/iotmonitor-
us-east-1-beta-InstanceRole-1C5T1YCYMHPYT",
"accountId":"222222222222",
"userName":"iotmonitor-us-east-1-InstanceRole-1C5T1YCYMHPYT"
}
},
"invokedBy":{
"serviceAccountId":"111111111111"
}
},
"VpcEndpointId":""
}
259
Conexión de dispositivos
Los dispositivos se conectan a AWS IoT mediante un nombre de dominio completo (FQDN) que es
específico de su cuenta. Todas las conexiones a AWS IoT deben estar protegidas con TLS versión 1.2.
Además, AWS IoT necesita que los dispositivos envíen la extensión de Indicación de nombre del servidor
(SNI). Para obtener más información, consulte Seguridad de transporte en AWS IoT.
AWS IoT proporciona tres tipos de puntos de enlace, que se distinguen por los siguientes tres tipos de
servicio que exponen:
• Data: se utiliza para enviar y recibir datos desde y hacia los componentes Agente de mensajes, Sombra
de dispositivo y Motor de reglas de AWS IoT.
• Credential_Provider: se utiliza para intercambiar el certificado X.509 integrado en un dispositivo por
credenciales temporales para establecer una conexión directa con otros servicios de AWS. Para obtener
más información acerca de cómo conectarse a otros servicios de AWS, consulte Autorizar llamadas
directas a servicios de AWS.
• Jobs: se utiliza para permitir que los dispositivos interactúen con el servicio AWS IoT Jobs utilizando las
API HTTPS de dispositivo de Jobs.
Cada cliente de AWS IoT tiene puntos de enlace predeterminados para cada tipo de servicio. La API
DescribeEndpoint se utiliza para obtener los puntos de enlace predeterminados. En la lista siguiente se
indican los tipos de puntos de enlace válidos:
• iot:Data-ATS: punto de enlace para el tipo de servicio Data.

• iot:CredentialProvider: punto de enlace para el tipo de servicio Credential_Provider.
• iot:Jobs: punto de enlace para el tipo de servicio Jobs.
Important
Cada cliente tiene otro tipo de punto de enlace: iot:Data. Utilice este punto de enlace
para recuperar puntos de enlace de datos antiguos que utilicen certificados VeriSign para la
compatibilidad con versiones anteriores. 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. Para obtener más
información, consulte Autenticación del servidor.
Especifique el tipo de punto de enlace que se va a obtener de la API DescribeEndpoint mediante

el parámetro endpointType. En el siguiente ejemplo de la AWS CLI se obtiene el punto de enlace
iot:Data-ATS predeterminado.
Este comando devuelve un punto de enlace con el siguiente formato: account-specific-prefix-

ats.iot.region.amazonaws.com
También puede usar su propio FQDN (por ejemplo, ejemplo.com) y el certificado de servidor asociado
para conectar dispositivos a AWS IoT mediante la función de puntos de enlace configurables, que
actualmente está en versión beta pública. En la siguiente sección se explica cómo utilizar puntos de enlace
configurables para los dominios personalizados y dominios administrados por AWS.
260
Puntos de enlace configurables (beta)
Temas
• Puntos de enlace configurables (beta) (p. 261)
Puntos de enlace configurables (beta)

Puede crear varios puntos de enlace para conectar dispositivos a AWS IoT. También puede configurar
algunos detalles (como el nombre de dominio) utilizando configuraciones de dominio. Puede utilizar
configuraciones de dominio para simplificar tareas como las siguientes.
• Migrar dispositivos a AWS IoT

• 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
En la versión beta, puede configurar un nombre de dominio completo (FQDN), así como el certificado de
servidor asociado. También puede asociar un autorizador personalizado o un autorizador personalizado
mejorado. Para obtener más información, consulte Autorizadores personalizados (p. 143) y Autenticación
personalizada mejorada (beta) (p. 147).
Note
AWS IoT 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 al conectarse y pasar un
nombre de servidor idéntico al nombre de dominio especificado en la configuración del dominio.
Para probar este servicio, use la versión v2 de cada SDK de dispositivo de AWS IoT en GitHub.
Temas
• Creación y configuración de dominios administrados por AWS (p. 261)
• Creación y configuración de dominios personalizados (p. 262)
• Administración de configuraciones de dominio (p. 265)
Creación y configuración de dominios administrados

por AWS
Un punto de enlace configurable en un dominio administrado por AWS se crea con la API
CreateDomainConfiguration. Una configuración de dominio para un dominio administrado por AWS consta
de lo siguiente:
• domainConfigurationName: un nombre definido por el usuario que identifica la configuración del

dominio.
261
Creación y configuración de dominios personalizados
Note
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 su región.
• defaultAuthorizerName: el nombre del autorizador personalizado que se va a utilizar en el punto de
enlace.
• allowAuthorizerOverride: un valor booleano que especifica si los dispositivos pueden invalidar
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: los valores posibles son DATA, CREDENTIAL_PROVIDER y JOB. Si especifica DATA,
AWS IoT devuelve un punto de enlace del tipo iot:Data-Beta. Este es un tipo de punto de enlace
especial para la versión beta de puntos de enlace configurables. El punto de enlace sirve certificados de
servidor firmados por ATS. No se puede crear un punto de enlace configurable iot:Data (VeriSign).
Note
AWS IoT Core actualmente solo admite el tipo de servicio DATA.
El siguiente comando de la AWS CLI crea la configuración de dominio para un punto de enlace Data.
aws iot create-domain-configuration --domain-configuration-name "myDomainConfigurationName"

--service-type "DATA"
Las configuraciones de dominio permiten especificar un nombre de dominio completo (FQDN)

personalizado para conectarse a AWS IoT. En los dominios personalizados, puede administrar sus propios
certificados de servidor y los detalles, como la entidad de certificación raíz (CA) que se utiliza 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. 262)

2. Creación de una configuración de dominio (p. 263)
3. Creación de registros DNS (p. 264)
Registro de certificados de servidor en AWS Certificate Manager

Antes de crear una configuración de dominio con un dominio personalizado, debe registrar la cadena de
certificados de servidor en AWS Certificate Manager (ACM). Puede utilizar tres tipos de certificados de
servidor.
• Certificados públicos generados por ACM (p. 263)

• Certificados externos firmados por una entidad emisora de certificación pública (p. 263)
262
• Certificados externos firmados por una entidad emisora de certificación privada (p. 263)
Note
AWS IoT 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.
Uso de un único 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. Esta cobertura puede ser una coincidencia exacta o una coincidencia de caracteres
comodín.
En las siguientes secciones se describe cómo obtener cada tipo de certificado. Cada recurso de certificado
requiere el ARN registrado con ACM que utiliza al crear la configuración de dominio.
Certificados públicos generados por ACM

Puede generar un certificado público para el dominio personalizado mediante la API RequestCertificate.
Cuando genera un certificado de esta manera, ACM valida que usted es el propietario del dominio
personalizado. Para obtener más información, consulte Solicitar 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 tiene un certificado de servidor firmado con una CA pública (una CA incluida en el paquete de CA
de confianza de Mozilla), puede importar la cadena de certificados directamente a ACM mediante la API
ImportCertificate. 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 entidad emisora de certificación privada o
autofirmado, puede utilizar el certificado para crear la configuración de dominio, pero también debe crear
un certificado público adicional en ACM para validar que usted es el propietario del dominio. Para ello,
registre la cadena de certificados de servidor en ACM mediante la API ImportCertificate. Para obtener
más información sobre esta tarea, los requisitos previos y los requisitos de formato de certificado, consulte
Importación de certificados.
Después de importar el certificado a ACM, genere un certificado público para el dominio personalizado
mediante la API RequestCertificate. Cuando genera un certificado de esta manera, ACM valida que usted
es el propietario 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.
Creación de una configuración de dominio

Cree un punto de enlace configurable en un dominio personalizado mediante la API
CreateDomainConfiguration. Una configuración de dominio para un dominio personalizado consta de lo
siguiente:
• domainConfigurationName: un nombre definido por el usuario que identifica la configuración del

dominio.
263
Note
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 su región.
• domainName: el FQDN que utilizan los dispositivos para conectarse a AWS IoT.
Note
AWS IoT 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 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 de servidor que registró en ACM. La
versión beta solo admite un certificado de servidor.
• validationCertificateArn: el ARN del certificado público que generó en ACM para validar
que usted es el propietario del dominio personalizado. Este argumento no es necesario si utiliza un
certificado de servidor firmado públicamente o uno generado por ACM.
• defaultAuthorizerName: el nombre del autorizador personalizado que se va a utilizar en el punto de
enlace.
• allowAuthorizerOverride: un valor booleano que especifica si los dispositivos pueden invalidar
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: los valores posibles son DATA, CREDENTIAL_PROVIDER y JOB. Si especifica DATA,
AWS IoT devuelve un punto de enlace del tipo iot:Data-Beta. Este es un tipo de punto de enlace
especial para la versión beta de puntos de enlace configurables. No se puede crear un punto de enlace
configurable iot:Data (VeriSign).
Note
AWS IoT Core actualmente solo admite el tipo de servicio DATA.
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, puede pasar un máximo de 15 minutos hasta que
AWS IoT obtenga los certificados de servidor personalizados.
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-Beta. Este es un tipo de punto de enlace
especial para la versión beta de puntos de enlace configurables. Puede obtener su punto de enlace beta
mediante la API DescribeEndpoint.
El siguiente comando de la AWS CLI muestra cómo obtener su punto de enlace beta.
aws iot describe-endpoint --endpoint-type iot:Data-Beta
264
Administración de configuraciones de dominio
Cuando tenga el punto de enlace iot:Data-Beta, cree un registro CNAME en el dominio personalizado
para este punto de enlace de AWS IoT. Si crea varios dominios personalizados en la misma cuenta, asigne
un alias a este mismo punto de enlace iot:Data-Beta.
Administración de configuraciones de dominio

Puede administrar los ciclos de vida de las configuraciones existentes mediante las siguientes API.
• ListDomainConfigurations
• DescribeDomainConfiguration
• UpdateDomainConfiguration
• DeleteDomainConfiguration
Consulta de las configuraciones de dominio

Utilice la API ListDomainConfigurations para devolver una lista paginada de todas las configuraciones de
dominio de su cuenta. Puede ver los detalles de una configuración de dominio en particular mediante la
API DescribeDomainConfiguration. Esta API toma un único parámetro domainConfigurationName y
devuelve los detalles de la configuración especificada.
Actualización de configuraciones de dominio

Para actualizar el estado o el autorizador personalizado de su configuración de dominio, utilice la API
UpdateDomainConfiguration. 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.
Note
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.
Eliminación de configuraciones de dominio

Antes de eliminar una configuración de dominio, utilice la API UpdateDomainConfiguration para establecer
el estado en DISABLED. 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 la API DeleteDomainConfiguration.
Después de eliminar una configuración de dominio, AWS IoT ya no sirve el certificado de servidor asociado
a ese dominio personalizado.
265
Temas
Agente de mensajes de AWS IoT

El agente de mensajes de AWS IoT conecta AWS IoT a los clientes mediante el envío de mensajes de los
clientes de publicación a los clientes de suscripción. Los clientes envían datos mediante la publicación de
un mensaje sobre un tema y reciben mensajes mediante la suscripción a un tema. Cuando el agente de
mensajes recibe un mensaje de un cliente de publicación, reenvía el mensaje a todos los clientes que se
han suscrito a ese tema.
El procesamiento de mensajes a través del agente de mensajes de AWS IoT le permite definir
reglas (p. 285) que pueden iniciar más acciones en función del contenido de los mensajes. Si no necesita
características de AWS IoT como reglas (p. 285) o trabajos (p. 413), consulte Mensajería de AWS
para obtener información sobre otros servicios de mensajería de AWS que podrían ajustarse mejor a sus
requisitos.
Temas
• Temas (p. 266)
• Protocolos (p. 276)
Temas
Los temas identifican mensajes de AWS IoT. Los clientes de AWS IoT identifican los mensajes que
publican dando los 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
AWS IoT utiliza nombres y filtros de temas para dirigir los mensajes de los clientes de publicación a los
clientes de suscripción.
Aunque AWS IoT admite algunos temas reservados del sistema (p. 267), 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:
266
Filtros de temas
• 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. 267) que debe utilizar
únicamente AWS IoT Core.
• AWS IoT Core no puede enviar ni recibir mensajes entre cuentas o regiones de AWS.
El espacio de nombres del tema está limitado a una cuenta y región de AWS. Por ejemplo, el tema de
sensor/temp/room1 utilizado por una cuenta de AWS en una región es distinto del tema sensor/
temp/room1 utilizado por la misma cuenta de AWS en otra región o utilizado por cualquier otra cuenta de
AWS en cualquier región.
Filtros de temas
Los clientes suscriptores registran filtros de temas con el agente de mensajes de AWS IoT para especificar
los temas de mensajes que el agente de mensajes debe enviarles. Un filtro de tema puede ser un único
nombre de tema para suscribirse a un único nombre de tema o puede incluir caracteres comodín para
suscribirse a varios nombres de tema a la vez.
Los clientes de publicación no pueden utilizar caracteres comodín en los nombres de tema 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.
Temas reservados
Los temas que comienzan por un signo de dólar ($) están reservados para su uso por parte de AWS IoT.
Puede suscribirse y publicar en estos temas reservados según lo permitan; sin embargo, no puede crear
267
Temas reservados
nuevos temas que comiencen por un signo de 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 de eventos
Tema Operaciones permitidas Descripción
$aws/events/presence/ Suscribirse AWS IoT publica en este tema

connected/idCliente cuando 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. 750).

disconnected/idCliente cuando un cliente MQTT con
se desconecta de AWS IoT.
Para obtener más información,
$aws/events/subscriptions/ Suscribirse AWS IoT publica en este tema

subscribed/idCliente cuando un cliente MQTT con
se suscribe a un tema
MQTT. Para obtener más
información, consulte Eventos
de suscripción/cancelación de
$aws/events/subscriptions/ Suscribirse AWS IoT publica en este

unsubscribed/idCliente tema cuando un cliente
MQTT con el ID de cliente
especificado anula la
suscripción de un tema
MQTT. Para obtener más
de suscripción/cancelación de
Temas de reglas
$aws/rules/nombreRegla Publicar Los dispositivos o las

aplicaciones publican en
este tema para activar reglas
directamente. Para obtener
más información, consulte
Reducción de los costos
de mensajería con Basic
Ingest (p. 319).
268
Temas reservados
Temas de sombras de objetos
$aws/things/thingName/ Publicar/suscribirse Un dispositivo o una aplicación

shadow/delete publica en este tema para
eliminar una sombra. Para
consulte /delete (p. 406).
$aws/things/thingName/ Suscribirse El servicio Device Shadow

shadow/delete/accepted envía mensajes a este tema
cuando se elimina una
sombra. Para obtener más
información, consulte /delete/
accepted (p. 406).

shadow/delete/rejected envía mensajes a este tema
cuando se rechaza una
solicitud para eliminar una
información, consulte /delete/
rejected (p. 407).
$aws/things/thingName/ Publicar/suscribirse Una aplicación o un objeto

shadow/get publica un mensaje vacío en
este tema para obtener una
información, consulte Temas
MQTT de sombra (p. 400).

shadow/get/accepted envía mensajes a este
tema cuando se realiza
correctamente una solicitud
de una sombra. Para obtener
más información, consulte /
get/accepted (p. 405).

shadow/get/rejected envía mensajes a este
tema cuando se rechaza
una solicitud de una
información, consulte /get/
rejected (p. 405).
$aws/things/thingName/ Publicar/suscribirse Un objeto o una aplicación

shadow/update publica en este tema para
actualizar una sombra. Para
consulte /update (p. 401).

shadow/update/accepted envía mensajes a este
tema cuando se realiza
correctamente una
269
Temas reservados

actualización en una
información, consulte /update/
accepted (p. 402).

shadow/update/rejected envía mensajes a este
tema cuando se rechaza
una actualización en una
rejected (p. 403).

shadow/update/delta envía mensajes a este
tema cuando se detecta
una diferencia entre las
secciones para los estados
reported y desired de una
delta (p. 403).
$aws/things/thingName/ Suscribirse AWS IoT publica un

shadow/update/documents documento de estado en este
tema siempre que se realiza
una actualización correcta de
la sombra. Para obtener más
documents (p. 402).
Temas de trabajos
$aws/things/thingName/jobs/ Publicar Los dispositivos publican

get un mensaje en este tema
para realizar una solicitud
GetPendingJobExecutions.
consulte Uso de las API
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/jobs/ Suscribirse Los dispositivos se

get/accepted suscriben a este tema
para recibir respuestas
correctas de una solicitud
de trabajos de AWS
IoT (p. 438).
270
Temas reservados
$aws/things/thingName/jobs/ Suscribirse Los dispositivos se suscriben

get/rejected a este tema cuando se
rechaza una solicitud
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/jobs/ Publicar Los dispositivos publican

start-next un mensaje en este tema
StartNextPendingJobExecution.
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/jobs/ Suscribirse Los dispositivos se

start-next/accepted suscriben a este tema
correctas a una solicitud
de trabajos de AWS
IoT (p. 438).

start-next/rejected a este tema cuando se
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/ Publicar Los dispositivos publican

jobs/jobId/get un mensaje en este tema
DescribeJobExecution.
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/ Suscribirse Los dispositivos se

jobs/jobId/get/accepted suscriben a este tema
de trabajos de AWS
IoT (p. 438).
271
Temas reservados
$aws/things/thingName/ Suscribirse Los dispositivos se suscriben

jobs/jobId/get/rejected a este tema cuando se
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/ Publicar Los dispositivos publican

jobs/jobId/update un mensaje en este tema
UpdateJobExecution. Para
de trabajos de AWS
IoT (p. 438).
$aws/things/thingName/ Suscribirse Los dispositivos se

jobs/jobId/update/accepted suscriben a este tema
de trabajos de AWS
IoT (p. 438).
Nota
Solo el dispositivo
que publica en $aws/
things/thingName/
jobs/jobId/update
recibirá mensajes en
este tema.
$aws/things/thingName/ Suscribirse Los dispositivos se suscriben

jobs/jobId/update/rejected a este tema cuando se
de trabajos de AWS
IoT (p. 438).
Nota
Solo el dispositivo
que publica en $aws/
things/thingName/
jobs/jobId/update
recibirá mensajes en
este tema.
272
Temas reservados

notify a este tema 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 Uso de
las API de trabajos de AWS
IoT (p. 438).

notify-next a este tema para recibir
notificaciones cuando cambia
la siguiente ejecución de un
trabajo pendiente para el
objeto. Para obtener más
información, consulte Uso de
las API de trabajos de AWS
IoT (p. 438).
$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica

completed un evento sobre este tema
cuando se completa un
trabajo. Para obtener más
de trabajos (p. 746).
$aws/events/job/jobId/ Suscribirse El servicio de trabajos

canceled publica un evento sobre este
tema cuando se cancela un

deleted publica un evento sobre este
tema cuando se elimina un

cancellation_in_progress publica un evento sobre
este tema cuando se
inicia la cancelación de un
$aws/events/job/jobId/ Suscribirse El servicio de trabajos publica

deletion_in_progress un evento sobre este tema
cuando se inicia la eliminación
de un trabajo. Para obtener
Eventos de trabajos (p. 746).
273
Temas reservados
$aws/events/ Suscribirse El servicio de trabajos

jobExecution/jobId/ publica un evento sobre este
succeeded tema cuando la ejecución
del trabajo se ejecuta
satisfactoriamente. Para
consulte Eventos de
trabajos (p. 746).

jobExecution/jobId/failed publica un evento sobre este
tema cuando la ejecución
de un trabajo produce un
error. Para obtener más

jobExecution/jobId/rejected publica un evento sobre
este tema cuando se
rechaza una ejecución de un

jobExecution/jobId/canceled publica un evento sobre
este tema cuando se
cancela la ejecución de un
$aws/events/ Suscribirse El servicio de trabajos publica

jobExecution/jobId/timed_out un evento sobre este tema
cuando se agota el tiempo
de espera de ejecución de
un trabajo. Para obtener más

jobExecution/jobId/removed un evento sobre este tema
cuando se elimina la ejecución

jobExecution/jobId/deleted un evento sobre este tema
cuando se elimina la ejecución
274
Temas reservados
Temas de aprovisionamiento de flotas

connected/idCliente cuando un cliente MQTT con
se conecta a AWS IoT. Para
$aws/certificates/create/cbor Publicación Publique en este tema para

llamar a la API de MQTT
CreateKeysAndCertificate.
$aws/certificates/create/json Publicación Publique en este tema para

llamar a la API de MQTT
$aws/provisioning- Publicación Publique en este tema para

templates/templateName/ llamar a la API de MQTT
provision/cbor RegisterThing.
$aws/provisioning- Publicación Publique en este tema para

templates/templateName/ llamar a la API de MQTT
provision/json RegisterThing.
$aws/certificates/create/cbor/ Subscribe AWS IoT publica en

accepted este tema cuando se
realiza correctamente una
llamada a la API de MQTT
$aws/certificates/create/cbor/ Subscribe AWS IoT publica en

rejected este tema cuando la
produce un error.
$aws/certificates/create/json/ Subscribe AWS IoT publica en

accepted este tema cuando se
realiza correctamente una
$aws/certificates/create/json/ Subscribe AWS IoT publica en

rejected este tema cuando la
produce un error.
$aws/provisioning- Subscribe AWS IoT publica en

templates/templateName/ este tema cuando se
provision/cbor/accepted realiza correctamente una
RegisterThing.
275
Protocolos
$aws/provisioning- Subscribe AWS IoT publica en este tema

templates/templateName/ cuando la llamada a la API
provision/cbor/rejected de MQTT RegisterThing
produce un error.
$aws/provisioning- Subscribe AWS IoT publica en

templates/templateName/ este tema cuando se
provision/json/accepted realiza correctamente una
RegisterThing.
$aws/provisioning- Subscribe AWS IoT publica en este tema

templates/templateName/ cuando la llamada a la API
provision/json/rejected de MQTT RegisterThing
produce un error.
Temas de Device Defender
$aws/things/thingName/ Publicación Los agentes de Device

defender/metrics/ Defender publican métricas
en este tema. Para obtener
Envío de métricas desde
dispositivos (p. 711).
Otros temas
$aws/sitewise/asset- Subscribe AWS IoT SiteWise publica

models/assetModelId/ notificaciones de propiedades
assets/assetId/ de activos en este tema. Para
properties/propertyId obtener más información,
consulte Interacción con
otros servicios de AWS en la
Guía del usuario de AWS IoT
SiteWise.
Protocolos
El agente de mensajes admite clientes que utilizan el protocolo MQTT para publicar y suscribirse
a mensajes y el protocolo HTTPS para publicar mensajes. Ambos protocolos se admiten mediante
IP (versiones 4 y 6). El agente de mensajes también admite el protocolo MQTT sobre el protocolo
WebSocket. La forma en que un cliente puede conectarse al agente de mensajes depende del protocolo
utilizado.
276
Protocolos, mapeos de puertos y autenticación
Protocolos, mapeos de puertos y autenticación

En la tabla siguiente se enumeran los protocolos admitidos por AWS IoT y los puertos y métodos de
autenticación utilizados por cada uno de ellos.
Protocolos, autenticación y mapeos de puerto
Protocolo Autenticación Puerto Nombre del protocolo

ALPN
MQTT a través de Signature Version 4 443 N/A

WebSocket
†
MQTT Certificado de cliente 443 x-amzn-mqtt-ca
X.509
MQTT Certificado de cliente 8883 N/A

X.509
HTTPS Signature Version 4 443 N/A

†
HTTPS Certificado de cliente 443 x-amzn-http-ca
X.509
HTTPS Certificado de cliente 8443 N/A

X.509
†
Los clientes que se conectan al puerto 443 con la autenticación de certificado cliente X.509 deben
implementar la extensión de TLS negociación de protocolo de capa de aplicación (ALPN) y utilizar el
nombre de protocolo ALPN indicado en la ProtocolNameList de ALPN enviado por el cliente como parte
del mensaje ClientHello. Los clientes también deben enviar la extensión TLS de Indicación de nombre
de servidor (SNI) para evitar que se rechacen las conexiones. Para obtener más información, consulte
Seguridad de transporte en AWS IoT.
MQTT
MQTT es un protocolo de mensajería ligero muy utilizado, diseñado para dispositivos limitados. Para
obtener más información, consulte la especificación MQTT v3.1.1.
La implementación del agente de mensajes de AWS IoT se basa en MQTT versión 3.1.1, pero difiere de la
especificación como se indica a continuación:
• AWS IoT Core admite los niveles 0 y 1 de calidad de servicio (QoS) de MQTT. AWS IoT Core no admite
la publicación o suscripción con QoS nivel 2. El agente de mensajes de AWS IoT no envía PUBACK o
SUBACK cuando se solicita QoS nivel 2.
• En AWS IoT Core, 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.
• 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.
• La especificación MQTT ofrece una cláusula que permite a un editor solicitar al agente que conserve
el último mensaje enviado a un tema y que lo envíe a todos los futuros suscriptores de dicho tema.
277
MQTT
AWS IoT Core no admite mensajes conservados. Si se envía una solicitud para conservar mensajes, se
interrumpe la conexión.
• 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 que tengan el
mismo ID de cliente no pueden estar conectados 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.
• El agente de mensajes no garantiza el orden de recepción de los mensajes y ACK.
Puede conectarse a AWS IoT Core a través de MQTT mediante una de las SDK de AWS IoT para
dispositivos y móviles (p. 762). Para ver un ejemplo de cómo conectarse a AWS IoT Core con MQTT,
consulte el ejemplo de basicPubSub en el SDK de Python. Los otros SDK de AWS IoT (p. 762) tienen
aplicaciones de ejemplo similares.
Para obtener más información acerca de la autenticación y las asignaciones de puertos para mensajes
MQTT, consulte Protocolos, mapeos de puertos y autenticación (p. 277).
Sesiones persistentes de MQTT

Una sesión persistente representa una conexión en curso a un agente de mensajes de MQTT. Cuando un
cliente se conecta al intermediario de mensajes de AWS IoT 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. Cuando el cliente vuelve a conectarse la
sesión persistente, todas las suscripciones se restablecen y todos los mensajes almacenados se envían al
cliente a una velocidad máxima de 10 mensajes por segundo.
Puede crear una sesión persistente de MQTT enviando un mensaje CONNECT que establezca la marca
cleanSession en 0. Si no existe ninguna sesión para el cliente que envía el mensaje CONNECT, se crea
una sesión persistente nueva. Si ya existe una sesión para el cliente, se reanuda.
Una vez que el cliente se une a la sesión, puede continuar publicando mensajes y suscribirse a filtros
de temas sin ningún indicador adicional en cada operación. Las condiciones siguientes describen cómo
comienzan y terminan las sesiones persistentes.
• Una sesión persistente termina y no se puede reanudar cuando el cliente envía un mensaje CONNECT
que establece el indicador cleanSession en 1.
• De forma predeterminada, una sesión persistente caduca una hora después de que el agente de
mensajes detecta que un cliente se ha desconectado. Puede configurar este intervalo de tiempo.
• Cuando un cliente se vuelve a conectar después de que la sesión haya caducado y establece el
indicador cleanSession en 0, el servicio crea una nueva sesión persistente. Las suscripciones y los
mensajes de la sesión anterior se descartan.
Los dispositivos utilizan el atributo sessionPresent del mensaje de confirmación de conexión

(CONNACK) para determinar si existe una sesión persistente. Si sessionPresent está establecido
en 1, significa que existe una sesión persistente y los mensajes almacenados se entregan al cliente. Esto
comienza inmediatamente después de que el dispositivo reciba el CONNACK. No es necesario volver a
suscribirse. Si sessionPresent está establecido en 0, significa que no existe ninguna sesión persistente
y que el cliente debe volver a suscribirse a sus filtros de temas.
Las sesiones persistentes tienen un periodo de caducidad predeterminado de una hora. El periodo
de caducidad comienza cuando el agente de mensajes detecta que un cliente se desconecta (por
desconexión o por tiempo de espera de MQTT). El periodo de caducidad de la sesión persistente puede
278
MQTT
aumentarse a través del proceso de aumento del límite estándar. Si un cliente no ha reanudado su sesión
dentro del periodo de caducidad, la sesión se termina y los mensajes relacionados almacenados se
descartan. El período de caducidad es aproximado. Las sesiones podrían persistir hasta 30 minutos
más (pero no menos) que la duración configurada. Para obtener más información, consulte Cuotas de
servicio de AWS. Todos los mensajes almacenados para las sesiones persistentes se facturarán a la tarifa
estándar de mensajería. Para obtener más información, consulte Precios de AWS IoT Core.
MQTT mediante el protocolo WebSocket

AWS IoT Core admite MQTT sobre el protocolo WebSocket para permitir a las aplicaciones basadas en
el navegador y aplicaciones remotas enviar y recibir datos a partir de dispositivos conectados a AWS
IoT Core con credenciales de AWS. Las credenciales de AWS se especifican utilizando AWS Signature
Version 4. El puerto TCP 443 admite WebSocket y permite a los mensajes atravesar la mayoría de
firewalls y servidores proxy web.
Una conexión WebSocket se inicia en un cliente enviando una solicitud HTTP GET. La dirección URL que
utilice tiene la forma siguiente:
wss://<endpoint>.iot.<region>.amazonaws.com/mqtt
wss
Especifica el protocolo WebSocket.

endpoint
Su punto de enlace de AWS IoT Core específico de la cuenta de AWS. Puede utilizar el comando de la
CLI de AWS IoT Core describe-endpoint para encontrar este punto de enlace.
region
La región de AWS de su cuenta de AWS.

mqtt
Especifica que va a enviar mensajes MQTT mediante el protocolo WebSocket.
Cuando el servidor responde, el cliente envía una solicitud de actualización para indicar al servidor que
se comunica mediante el protocolo WebSocket. Después de que el servidor reconozca la solicitud de
actualización, toda la comunicación se realizará mediante el protocolo WebSocket. La implementación
de WebSocket que utilice actúa como protocolo de transporte. Los datos que envíe mediante el protocolo
WebSocket son mensajes MQTT.
Uso del protocolo WebSocket en una aplicación web

La implementación WebSocket proporcionada por la mayoría de los navegadores web no permite la
modificación de encabezados HTTP, por lo que debe agregar la información de Signature Version 4 a
la cadena de consulta. Para obtener más información, consulte Adición de la información de firma a la
cadena de consulta.
El código JavaScript siguiente define algunas funciones de utilidades para generar una solicitud Signature
Version 4.
Para obtener más información sobre el uso del protocolo WebSocket en JavaScript, vea WebSocket en
The Modern JavaScript Tutorial.
/**
* utilities to do sigv4
* @class SigV4Utils
279
MQTT
*/
function SigV4Utils() {}
SigV4Utils.getSignatureKey = function (key, date, region, service) {

var kDate = AWS.util.crypto.hmac('AWS4' + key, date, 'buffer');
var kRegion = AWS.util.crypto.hmac(kDate, region, 'buffer');
var kService = AWS.util.crypto.hmac(kRegion, service, 'buffer');
var kCredentials = AWS.util.crypto.hmac(kService, 'aws4_request', 'buffer');
return kCredentials;
};
SigV4Utils.getSignedUrl = function(host, region, credentials) {

var datetime = AWS.util.date.iso8601(new Date()).replace(/[:\-]|\.\d{3}/g, '');
var date = datetime.substr(0, 8);
var method = 'GET';

var protocol = 'wss';
var uri = '/mqtt';
var service = 'iotdevicegateway';
var algorithm = 'AWS4-HMAC-SHA256';
var credentialScope = date + '/' + region + '/' + service + '/' + 'aws4_request';

var canonicalQuerystring = 'X-Amz-Algorithm=' + algorithm;
canonicalQuerystring += '&X-Amz-Credential=' +
encodeURIComponent(credentials.accessKeyId + '/' + credentialScope);
canonicalQuerystring += '&X-Amz-Date=' + datetime;
canonicalQuerystring += '&X-Amz-SignedHeaders=host';
var canonicalHeaders = 'host:' + host + '\n';

var payloadHash = AWS.util.crypto.sha256('', 'hex');
var canonicalRequest = method + '\n' + uri + '\n' + canonicalQuerystring + '\n' +
canonicalHeaders + '\nhost\n' + payloadHash;
var stringToSign = algorithm + '\n' + datetime + '\n' + credentialScope + '\n' +

AWS.util.crypto.sha256(canonicalRequest, 'hex');
var signingKey = SigV4Utils.getSignatureKey(credentials.secretAccessKey, date,
region, service);
var signature = AWS.util.crypto.hmac(signingKey, stringToSign, 'hex');
canonicalQuerystring += '&X-Amz-Signature=' + signature;

if (credentials.sessionToken) {
canonicalQuerystring += '&X-Amz-Security-Token=' +
encodeURIComponent(credentials.sessionToken);
}
var requestUrl = protocol + '://' + host + uri + '?' + canonicalQuerystring;

return requestUrl;
};
Para crear una solicitud Signature Version 4
1. Cree una solicitud canónica para Signature Version 4.
El siguiente código JavaScript crea una solicitud canónica:
var datetime = AWS.util.date.iso8601(new Date()).replace(/[:\-]|\.\d{3}/g, '');

var date = datetime.substr(0, 8);
var method = 'GET';

var protocol = 'wss';
var uri = '/mqtt';
var service = 'iotdevicegateway';
280
MQTT
var algorithm = 'AWS4-HMAC-SHA256';
var credentialScope = date + '/' + region + '/' + service + '/' + 'aws4_request';

var canonicalQuerystring = 'X-Amz-Algorithm=' + algorithm;
canonicalQuerystring += '&X-Amz-Credential=' +
encodeURIComponent(credentials.accessKeyId + '/' + credentialScope);
canonicalQuerystring += '&X-Amz-Date=' + datetime;
canonicalQuerystring += '&X-Amz-SignedHeaders=host';
var canonicalHeaders = 'host:' + host + '\n';

var payloadHash = AWS.util.crypto.sha256('', 'hex')
var canonicalRequest = method + '\n' + uri + '\n' + canonicalQuerystring + '\n' +
canonicalHeaders + '\nhost\n' + payloadHash;
2. Cree una cadena para firmar, genere una clave de firma y firme la cadena.
Tome la URL canónica que ha creado en el paso anterior e insértela en una cadena para firmar. Para
ello, cree una cadena formada por el algoritmo de hash, la fecha, el ámbito de las credenciales y el
SHA de la solicitud canónica.
A continuación, genere la clave de firma y firme la cadena, tal y como se muestra en el siguiente
código JavaScript.
var stringToSign = algorithm + '\n' + datetime + '\n' + credentialScope + '\n' +

AWS.util.crypto.sha256(canonicalRequest, 'hex');
var signingKey = SigV4Utils.getSignatureKey(credentials.secretAccessKey, date,
region, service);
var signature = AWS.util.crypto.hmac(signingKey, stringToSign, 'hex');
3. Agregue la información de firma a la solicitud.
El siguiente código JavaScript muestra cómo agregar la información de firma a la cadena de consulta.
canonicalQuerystring += '&X-Amz-Signature=' + signature;
4. Si tiene credenciales de sesión (de un servidor STS, AssumeRole o Amazon Cognito), anexe el token
de sesión al final de la cadena URL después de la firma:
canonicalQuerystring += '&X-Amz-Security-Token=' +
encodeURIComponent(credentials.sessionToken);
5. Anteponga el protocolo, el host y el URI a canonicalQuerystring:
var requestUrl = protocol + '://' + host + uri + '?' + canonicalQuerystring;
6. Abra WebSocket.
El siguiente código JavaScript muestra cómo crear un cliente Paho MQTT y hacer una llamada
CONNECT a AWS IoT. El argumento endpoint corresponde al punto de enlace específico de su
cuenta de AWS. El clientId es un identificador de texto único entre todos los clientes conectados
simultáneamente en su cuenta de AWS.
var client = new Paho.MQTT.Client(requestUrl, clientId);
281
HTTP
var connectOptions = {
onSuccess: function(){
// connect succeeded
},
useSSL: true,
timeout: 3,
mqttVersion: 4,
onFailure: function() {
// connect failed
}
};
client.connect(connectOptions);
Uso del protocolo WebSocket en una aplicación móvil

Le recomendamos que utilice uno de los SDK de dispositivos de AWS IoT Core para conectar su
dispositivo a AWS IoT Core cuando establezca una conexión WebSocket. Los siguientes SDK de
dispositivos de AWS IoT Core son compatibles con las conexiones MQTT a AWS IoT Core basadas en
WebSocket:
• Node.js
• iOS
• Android
Para ver una implementación de referencia para conectar una aplicación web a AWS IoT Core mediante
MQTT sobre el protocolo WebSocket consulte AWS Labs WebSocket sample en el sitio web de GitHub.
Si utiliza un lenguaje de programación o de script que no esté admitido actualmente, puede utilizar
cualquier biblioteca de WebSocket existente siempre y cuando la solicitud de actualización de WebSocket
inicial (HTTP POST) se conecte mediante Signature Version 4. Algunos clientes MQTT, como Eclipse
Paho para JavaScript, admiten el protocolo WebSocket de manera nativa.
HTTP
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. 277).
HTTP URL
Los clientes de publicación realizan solicitudes POST a un punto de enlace específico del
cliente y a una dirección URL específica del tema: https://<AWS IoT endpoint>/
topics/<url_encoded_topic_name>?qos=1".
• <AWS IoT endpoint> es el punto de enlace de la API REST. Puede encontrar el punto de enlace en
la consola de AWS IoT en la página de detalles del objeto o en el cliente mediante el comando la CLI de
AWS IoT:
aws iot describe-endpoint
El punto de enlace debería tener un aspecto similar al siguiente: a3qj468xinsffp-ats.iot.us-

west-2.amazonaws.com
• <url_encoded_topic_name> es el nombre del tema (p. 266) completo del mensaje enviado.
282
HTTP
Ejemplo de curl
Puede usar curl para emular a un cliente que envía un mensaje a AWS IoT Core.
Para usar curl para enviar un mensaje desde un dispositivo cliente de AWS IoT Core
1. Compruebe la versión de curl.
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 la opción --tlsv1.2 o aparece un error command not found, actualice o instale curl
en su cliente antes 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 clave privada del cliente (private.key en este ejemplo).

• El archivo de certificado del cliente (certificate.pem.crt en este ejemplo).
• El archivo de certificado de entidad de certificación (AmazonRootCA1.pem en este ejemplo).
3. Cree la línea de comando curl.
curl --tlsv1.2 --cacert AmazonRootCA1.pem --cert certificate.pem.crt --key private.key -X

POST -d "{ \"message\": \"Hello, world\" }" "https://<AWS IoT Endpoint>:8443/topics/topic?qos=1"
--tlsv1.2
Use TLS 1.2 (SSL).

--cacert <nombre de archivo>
El nombre de archivo y la ruta de acceso, si es necesario, del certificado de entidad de

certificación para verificar el par.
--cert <nombre de archivo>
El nombre y la ruta de acceso del archivo de certificado del cliente, si es necesario.

--key <nombre de archivo>
El nombre y la ruta del archivo de la clave privada del cliente, si es necesario.

-X POST
El tipo de solicitud HTTP (en este caso, POST).

-d <datos>
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://<AWS IoT endpoint>:8443/topics/topic?qos=1"
La URL del punto de enlace de la API REST de su cliente, seguido del puerto HTTPS, :8443,
seguido de la palabra clave /topics/ y el nombre del tema topic, en este caso. Especifique la
calidad del servicio como parámetro de consulta, ?qos=1.
4. Abra el cliente de prueba MQTT en la consola.
283
HTTP
Siga las instrucciones de Visualización de los mensajes de MQTT de dispositivo con el cliente MQTT
de AWS IoT (p. 12) y configure la consola para que se suscriba a los mensajes con el nombre del
tema de topic o utilice el filtro de tema 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.
284
Concesión a AWS IoT del acceso requerido
Reglas para AWS IoT

Las reglas permiten a sus dispositivos interactuar con los servicios de AWS. Las reglas se analizan y las
acciones se ejecutan en función del flujo de temas MQTT. Puede utilizar reglas para admitir tareas como
las siguientes:
• Incrementar o filtrar los datos recibidos desde un dispositivo.

• Escribir datos recibidos desde un dispositivo en una base de datos de Amazon DynamoDB.
• Guardar un archivo en Amazon S3.
• Enviar una notificación de inserción a todos los usuarios mediante Amazon SNS.
• Publicar datos en una cola de Amazon SQS.
• Invocar una función de Lambda para extraer datos.
• Procesar mensajes de un gran número de dispositivos mediante Amazon Kinesis.
• Enviar datos a Amazon Elasticsearch Service.
• Capturar una métrica de CloudWatch.
• Cambiar una alarma de CloudWatch.
• Enviar los datos de un mensaje MQTT a Amazon Machine Learning para realizar predicciones basadas
en un modelo de Amazon ML.
• Enviar un mensaje a un flujo de entrada de Salesforce IoT
• Enviar datos de mensaje a un canal de AWS IoT Analytics.
• Iniciar la ejecución de una máquina de estado de Step Functions.
• Enviar datos de mensaje a una entrada de AWS IoT Events.
• Envíe datos de mensaje de una propiedad de recurso de AWS IoT SiteWise.
• Envíe datos de mensaje a una aplicación o servicio web.
Su reglas pueden utilizar mensajes de MQTT que pasen por publicación o suscripción de Agente de
mensajes de AWS IoT (p. 266) o, mediante la característica Basic Ingest (p. 319), puede enviar de forma
segura los datos de los dispositivos a los servicios de AWS indicados anteriormente sin incurrir en costos
de mensajería. (La característica Basic Ingest (p. 319) optimiza el flujo de datos eliminando el agente de
mensajes de publicación/suscripción desde la ruta de adquisición, por lo que resulta más rentable al tiempo
que mantiene las características de procesamiento de los datos y de seguridad de AWS IoT).
Para que AWS IoT pueda realizar estas acciones, debe concederle permiso de acceso a los recursos de
AWS en su nombre. Cuando dichas acciones se ejecuten, se le cobrará la tarifa estándar de los servicios
de AWS que utilice.

Utilice los roles de IAM para controlar los recursos de AWS a los que cada regla tiene acceso. Antes de
crear una regla, debe crear un rol de IAM con una política que le permita acceder a los recursos de AWS
necesarios. AWS IoT adoptará este rol cuando ejecute una regla.
Para crear un rol de IAM (AWS CLI)
1. Guarde el siguiente documento de política de confianza, que concede a AWS IoT permiso para asumir
el rol, en un archivo llamado iot-role-trust.json:
285
"Version":"2012-10-17",
"Statement":[{
"Effect": "Allow",
"Principal": {
},
}]
}
Utilice el comando create-role para crear un rol de IAM especificando el archivo iot-role-
trust.json:
aws iam create-role --role-name my-iot-role --assume-role-policy-document file://iot-

role-trust.json
El resultado de este comando tendrá un aspecto similar al siguiente.
{
"Role": {
"AssumeRolePolicyDocument": "url-encoded-json",
"RoleId": "AKIAIOSFODNN7EXAMPLE",
"CreateDate": "2015-09-30T18:43:32.821Z",
"RoleName": "my-iot-role",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:role/my-iot-role"
}
}
2. Copie el siguiente JSON en un archivo denominado iot-policy.json.
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "dynamodb:*",
"Resource": "*"
}]
}
Este JSON es un ejemplo de documento de política que concede a AWS IoT acceso de administrador
a DynamoDB.
Ejecute el comando create-policy para conceder a AWS IoT acceso a sus recursos de AWS en el
momento en que asuma el rol pasando el archivo iot-policy.json:
aws iam create-policy --policy-name my-iot-policy --policy-document file://my-iot-

policy.json
Para obtener más información acerca de cómo conceder acceso a los servicios de AWS en las
políticas de AWS IoT, consulte Creación de una regla de AWS IoT (p. 288).
La salida del comando create-policy contendrá el ARN de la política. Tendrá que adjuntar la política a
un rol.
{
"Policy": {
"PolicyName": "my-iot-policy",
"CreateDate": "2015-09-30T19:31:18.620Z",
286
Transmisión de los permisos de rol
"AttachmentCount": 0,
"IsAttachable": true,
"PolicyId": "ZXR6A36LTYANPAI7NJ5UV",
"DefaultVersionId": "v1",
"Path": "/",
"Arn": "arn:aws:iam::123456789012:policy/my-iot-policy",
"UpdateDate": "2015-09-30T19:31:18.620Z"
}
}
3. Ejecute el comando attach-role-policy para asociar la política al rol:
aws iam attach-role-policy --role-name my-iot-role --policy-arn

"arn:aws:iam::123456789012:policy/my-iot-policy"
Transmisión de los permisos de rol

La definición de una regla implica que un rol de IAM conceda permiso para tener acceso a los recursos
especificados en la acción de la regla. El motor de reglas asume dicho rol cuando se activa la acción de la
regla. El rol tiene que estar definido en la misma cuenta de AWS que la regla.
De hecho, cuando crea o sustituye una regla, está transfiriendo un rol al motor de reglas. El usuario que
realiza esta operación necesita el permiso iam:PassRole. Para asegurarse de que dispone de dicho
permiso, cree una política que conceda el permiso iam:PassRole y asóciela a su usuario de IAM. La
política siguiente muestra cómo conceder un permiso iam:PassRole para un rol.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "Stmt1",
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::123456789012:role/myRole"
]
}
]
}
En este ejemplo de política, se concede el permiso iam:PassRole para el rol myRole. El rol se especifica
mediante el ARN del rol. Debe asociar esta política al usuario o al rol de IAM al que pertenezca el usuario.
Para obtener más información, consulte Working with Managed Policies.
Note
Las funciones de Lambda utilizan una política basada en recursos. Dicha política está
directamente asociada a la función de Lambda en sí. Cuando crea una regla que invoca una
función Lambda, no pasa un rol, por lo que el usuario que crea la regla no necesita el permiso
iam:PassRole. Para obtener más información acerca de la autorización de funciones de
Lambda, consulte Granting Permissions Using a Resource Policy.
287
Creación de una regla de AWS IoT

Puede configurar las reglas para direccionar datos desde los objetos conectados. Las reglas constan de
los elementos siguientes:
Nombre de la regla
El nombre de la regla.
Note
No es recomendable utilizar información de identificación personal en los nombres de regla.

Descripción opcional
Descripción textual de la regla.

Note
No es recomendable utilizar información de identificación personal en las descripciones de

regla.
Instrucción SQL
Sintaxis de SQL simplificada para filtrar los mensajes recibidos sobre un tema MQTT e insertar
los datos en otro punto. Para obtener más información, consulte Referencia de la SQL de AWS
IoT (p. 320).
Versión de SQL
Versión del motor de reglas SQL que debe utilizarse al evaluar la regla. Aunque esta propiedad es
opcional, recomendamos encarecidamente que especifique la versión de SQL. Si no se define esta
propiedad, se usará el valor predeterminado 2015-10-08. Para obtener más información, consulte
Versiones de SQL (p. 375).
Una o varias acciones
Las acciones que realiza AWS IoT al ejecutar la regla. Por ejemplo, puede insertar datos en una tabla
de DynamoDB, escribir datos en un bucket de Amazon S3, publicar en un tema de Amazon SNS o
invocar una función de Lambda.
Una acción de error
La acción AWS IoT se realiza cuando no es posible realizar una acción de la regla.
Cuando cree una regla, debe tener en cuenta la cantidad de datos que publica en los temas. Si crea
reglas que contienen un patrón de tema con comodín, es posible que coincidan con una gran cantidad de
mensajes y que necesite aumentar la capacidad de los recursos de AWS se que utilizan en las acciones de
destino. Asimismo, si crea una regla para volver a publicar que contenga un patrón de tema con comodín,
puede acabar teniendo una regla circular que genere un bucle infinito.
Note
La creación y la actualización de reglas son acciones de nivel de administrador. Todo usuario que
tenga permiso para crear o actualizar reglas podrá tener acceso a los datos procesados por las
reglas.
Para crear una regla (AWS CLI)
Ejecute el comando create-topic-rule para crear una regla:
288
aws iot create-topic-rule --rule-name my-rule --topic-rule-payload file://my-rule.json
Ejemplo de archivo de carga con una regla que inserta todos los mensajes enviados al tema iot/test
en la tabla de DynamoDB especificada. La instrucción SQL filtra los mensajes, y el ARN del rol concede a
AWS IoT permiso para escribir en la tabla de DynamoDB.
{
"sql": "SELECT * FROM 'iot/test'",
"ruleDisabled": false,
"awsIotSqlVersion": "2016-03-23",
"actions": [{
"dynamoDB": {
"tableName": "my-dynamodb-table",
"roleArn": "arn:aws:iam::123456789012:role/my-iot-role",
"hashKeyField": "topic",
"hashKeyValue": "${topic(2)}",
"rangeKeyField": "timestamp",
"rangeKeyValue": "${timestamp()}"
}
}]
}
A continuación, se muestra un ejemplo de archivo de carga con una regla que inserta todos los mensajes
enviados al tema iot/test en el bucket de S3 especificado. La instrucción SQL filtra los mensajes, y el
ARN del rol concede a AWS IoT permiso para escribir en el bucket de Amazon S3.
{
"sql": "SELECT * FROM 'iot/test'",
"actions": [
{
"s3": {
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_s3",
"bucketName": "my-bucket",
"key": "myS3Key"
}
}
]
}
A continuación, se muestra un ejemplo de archivo de carga con una regla que inserta datos en Amazon
Elasticsearch Service:
{
"sql":"SELECT *, timestamp() as timestamp FROM 'iot/test'",
"ruleDisabled":false,
"actions":[
{
"elasticsearch":{
"roleArn":"arn:aws:iam::123456789012:role/aws_iot_es",
"endpoint":"https://my-endpoint",
"index":"my-index",
"type":"my-type",
"id":"${newuuid()}"
}
}
]
}
289
Ejemplo de archivo de carga con una regla que invoca una función de Lambda:
{
"sql": "expression",
"actions": [{
"lambda": {
"functionArn": "arn:aws:lambda:us-west-2:123456789012:function:my-lambda-
function"
}
}]
}
Ejemplo de archivo de carga con una regla que publica en un tema de Amazon SNS:
{
"actions": [{
"sns": {
"targetArn": "arn:aws:sns:us-west-2:123456789012:my-sns-topic",
"roleArn": "arn:aws:iam::123456789012:role/my-iot-role"
}
}]
}
Ejemplo de archivo de carga con una regla que vuelve a publicar en otro tema MQTT:
{
"actions": [{
"republish": {
"topic": "my-mqtt-topic",
}
}]
}
Ejemplo de archivo de carga con una regla que inserta datos en un flujo de Amazon Kinesis Data Firehose:
{
"sql": "SELECT * FROM 'my-topic'",
"actions": [{
"firehose": {
"roleArn": ""arn:aws:iam::123456789012:role/my-iot-role",
"deliveryStreamName": "my-stream-name"
}
}]
}
Ejemplo de archivo de carga con una regla que utiliza la función Amazon Machine Learning de
machinelearning_predict para volver a publicar en un tema, siempre y cuando los datos de la carga
de MQTT se clasifiquen como 1.
290
Visualización de las reglas
{
"sql": "SELECT * FROM 'iot/test' where machinelearning_predict('my-model',
'arn:aws:iam::123456789012:role/my-iot-aml-role', *).predictedLabel=1",
"actions": [{
"republish": {
"roleArn": "arn:aws:iam::123456789012:role/my-iot-role",
"topic": "my-mqtt-topic"
}
}]
}
A continuación se incluye un archivo de carga de ejemplo con una regla que publica mensajes en un flujo
de entrada de Salesforce IoT Cloud.
{
"actions": [{
"salesforce": {
"token": "ABCDEFGHI123456789abcdefghi123456789",
"url": "https://ingestion-cluster-id.my-env.sfdcnow.com/streams/stream-id/
connection-id/my-event"
}
}]
}
Ejemplo de archivo de carga con una regla que inicia la ejecución de una máquina de estado de Step
Functions.
{
"actions": [{
"stepFunctions": {
"stateMachineName": "myCoolStateMachine",
"executionNamePrefix": "coolRunning",
}
}]
}
Visualización de las reglas

Ejecute el comando list-topic-rules para visualizar una lista de sus reglas:
aws iot list-topic-rules
Ejecute el comando get-topic-rule para obtener información acerca de una regla:
aws iot get-topic-rule --rule-name my-rule
291
Eliminar una regla
Eliminar una regla

Cuando ya no necesite una regla, puede eliminarla.
Para eliminar una regla (AWS CLI)
Ejecute el comando delete-topic-rule para eliminar una regla:
aws iot delete-topic-rule --rule-name my-rule
Acciones de reglas de AWS IoT

Las acciones de las reglas de AWS IoT se utilizan para especificar qué hacer cuando se activa una regla.
Puede definir acciones para escribir datos en una base de datos de DynamoDB o una secuencia de
Kinesis o para invocar una función de Lambda, etc. AWS admite acciones en regiones donde el servicio
está disponible. Se admiten las siguientes acciones:
• cloudwatchAlarm para cambiar una alarma de CloudWatch.

• cloudwatchLogs para enviar datos a CloudWatch Logs.
• cloudwatchMetric para capturar una métrica de CloudWatch.
• dynamoDB para escribir datos en una base de datos de DynamoDB.
• dynamoDBv2 para escribir datos en una base de datos de DynamoDB.
• elasticsearch para escribir datos en un dominio de Amazon Elasticsearch Service.
• firehose para escribir datos en un flujo de Amazon Kinesis Data Firehose.
• http para publicar datos en un punto de enlace HTTPS.
• iotAnalytics para enviar datos a un canal de AWS IoT Analytics.
• iotEvents para enviar datos a una entrada de AWS IoT Events.
• iotSiteWise para enviar datos a propiedades de recursos en AWS IoT SiteWise.
• kinesis para escribir datos en un flujo de Kinesis.
• lambda para invocar una función de Lambda.
• republish para volver a publicar el mensaje en otro tema MQTT.
• s3 para escribir datos en un bucket de Amazon S3.
• salesforce para escribir un mensaje en un flujo de entrada de Salesforce IoT.
• sns para escribir datos como notificación de inserción.
• sqs para escribir datos en una cola de SQS.
• stepFunctions para iniciar la ejecución de una máquina de estado de Step Functions.
Note
Es posible que el motor de reglas de AWS IoT realice varios intentos para ejecutar una acción en
caso de errores intermitentes. Si todos los intentos fallan, el mensaje se descarta y el error está
disponible en los registros de CloudWatch. Es posible especificar una acción de error para cada
regla que se invoca cuando se produce un error. Para obtener más información, consulte Control
de errores (acción de error) (p. 315).
Algunas acciones de regla desencadenan acciones en servicios que se integran con AWS Key
Management Service (AWS KMS) para admitir el cifrado de datos en reposo. Si utiliza una clave maestra
del cliente de AWS KMS (CMK) administrada por el cliente para cifrar los datos en reposo, el servicio
292
Acción de alarma de CloudWatch
debe tener permiso para poder usar la CMK en nombre del autor de la llamada. Consulte los temas de
cifrado de datos en la guía del servicio apropiado para obtener información acerca de cómo administrar los
permisos de una CMK administrada por el cliente. Para obtener más información acerca de las CMK y las
CMK administradas por el cliente, consulte Conceptos de AWS Key Management Service en la AWS Key
Management Service Developer Guide.
Cada acción se describe de manera detallada.
Acción de alarma de CloudWatch

CloudWatch alarm action
La acción de alarma de CloudWatch permite cambiar el estado de la alarma de CloudWatch. Puede

especificar el motivo del cambio de estado y el valor de esta llamada.
More information (1)
Cuando cree una regla de AWS IoT con una acción de alarma de CloudWatch, debe especificar la
información siguiente:
roleArn
El rol de IAM que permite el acceso a la alarma de CloudWatch.

alarmName
El nombre de la alarma de CloudWatch.

stateReason
El motivo del cambio de alarma.

stateValue
El valor del estado de alarma. Los valores aceptables son OK, ALARM e INSUFFICIENT_DATA.
Note
Asegúrese de que el rol asociado a la regla tenga una política que conceda el permiso
cloudwatch:SetAlarmState.
El siguiente ejemplo de JSON muestra cómo definir una acción de alarma de CloudWatch en una
regla de AWS IoT:
{
"topicRulePayload": {
"sql": "SELECT * FROM 'some/topic'",
"actions": [{
"cloudwatchAlarm": {
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_cw",
"alarmName": "IotAlarm",
"stateReason": "Temperature stabilized.",
"stateValue": "OK"
}
}]
}
}
Para obtener más información, consulte CloudWatch Alarms.
293
Acción de CloudWatch Logs
Acción de CloudWatch Logs

CloudWatch Logs action
La acción de registros de CloudWatch permite enviar datos a CloudWatch Logs. Puede especificar el
grupo de registros de CloudWatch al que la acción va a enviar los datos.
Cuando cree una regla de AWS IoT con una acción de registros de CloudWatch, debe especificar la
roleArn
El rol de IAM que permite el acceso al registro de CloudWatch.

logGroupName
El grupo de registros de CloudWatch al que la acción envía los datos.
El siguiente ejemplo de JSON muestra cómo definir una acción de registros de CloudWatch en una
regla de AWS IoT:
{
"actions": [{
"cloudwatchLogs": {
"logGroupName": "IotLogs"
}
}]
}
}
Para obtener más información, consulte Introducción a CloudWatch Logs. Si utiliza una CMK de AWS
KMS administrada por el cliente para cifrar los datos de registro en CloudWatch Logs, el servicio
debe tener permiso para poder usar la CMK en nombre del autor de la llamada. Para obtener más
información, consulte Cifrar datos de registro en CloudWatch Logs mediante AWS KMS en la Guía del
usuario de Amazon CloudWatch Logs.
Acción de métrica de CloudWatch

CloudWatch metric action
La acción de métrica de CloudWatch le permite capturar una métrica de CloudWatch. Puede

especificar el espacio de nombres, el nombre, el valor, la unidad y la marca de tiempo de la métrica.
Cuando cree una regla de AWS IoT con una acción de métrica de CloudWatch, debe especificar la
información siguiente:
roleArn
El rol de IAM que permite el acceso a la métrica de CloudWatch.
294
Acción de DynamoDB
metricNamespace
El nombre del espacio de nombres de la métrica de CloudWatch.

metricName
El nombre de la métrica de CloudWatch.

metricValue
El valor de la métrica de CloudWatch.

metricUnit
La unidad métrica que admite CloudWatch.

metricTimestamp
Una marca de tiempo Unix opcional.
Note
cloudwatch:PutMetricData.
El siguiente ejemplo de JSON muestra cómo definir una acción de métrica de CloudWatch en una
regla de AWS IoT:
{
"actions": [{
"cloudwatchMetric": {
"metricNamespace": "IotNamespace",
"metricName": "IotMetric",
"metricValue": "1",
"metricUnit": "Count",
"metricTimestamp": "1456821314"
}
}]
}
}
Para obtener más información, consulte Métricas de CloudWatch de .
Acción de DynamoDB
DynamoDB action
La acción dynamoDB le permite escribir todo un mensaje MQTT o parte de él en una tabla de
DynamoDB.
Cuando cree una regla de DynamoDB, debe especificar la información siguiente:
hashKeyType
Opcional. El tipo de datos de la clave hash (también denominado clave de partición). Los valores
válidos son: "STRING" o "NUMBER".
295
Acción de DynamoDB
hashKeyField
El nombre de la clave hash (también denominada clave de partición).

hashKeyValue
El valor de la clave hash.

rangeKeyType
Opcional. El tipo de datos de la clave de rango (también denominada clave de ordenación). Los
valores válidos son: "STRING" o "NUMBER".
rangeKeyField
Opcional. El nombre de la clave de rango (también denominada clave de ordenación).

rangeKeyValue
Opcional. El valor de la clave de rango.

operación
Opcional. El tipo de operación que se va a realizar. Sigue la plantilla de sustitución, por lo que
puede ser ${operation}, pero la sustitución debe tener como resultado uno de los elementos
siguientes: INSERT, UPDATE o DELETE.
payloadField
Opcional. El nombre del campo donde se escribirá la carga. Si este valor no se especifica, la
carga se escribe en el campo payload.
tabla
Nombre de la tabla de DynamoDB.

roleARN
El rol de IAM que permite tener acceso a la tabla de DynamoDB. Como mínimo, el rol debe
permitir la acción de IAM dynamoDB:PutItem.
Los datos que se escriben en la tabla de DynamoDB son el resultado de la instrucción SQL de la
regla. Los campos hashKeyValue y rangeKeyValue se componen normalmente de expresiones
(por ejemplo, "${topic()}" o "${timestamp()}").
Note
Los datos que no son JSON se escriben en DynamoDB como datos binarios. La consola de
DynamoDB mostrará los datos como texto codificado en Base64.
dynamodb:PutItem.
El siguiente ejemplo de JSON muestra cómo definir una acción dynamoDB en una regla de AWS IoT:
{
"sql": "SELECT * AS message FROM 'some/topic'",
"description": "A test Dynamo DB rule",
"actions": [{
"dynamoDB": {
"hashKeyField": "key",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_dynamoDB",
"tableName": "my_ddb_table",
296
Acción DynamoDBv2
"hashKeyValue": "${topic()}",
"rangeKeyValue": "${timestamp()}",
"rangeKeyField": "timestamp"
}
}]
}
}
Para obtener más información, consulte Guía de introducción a Amazon DynamoDB. Si utiliza una
CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo de DynamoDB, el
servicio debe tener permiso para poder usar la CMK en nombre del autor de la llamada. Para obtener
más información, consulte este artículo sobre la CMK administrado por el cliente en la Guía de
introducción de Amazon DynamoDB.
Acción DynamoDBv2
DynamoDBv2 action
La acción dynamoDBv2 le permite escribir todo un mensaje MQTT o parte de él en una tabla de
DynamoDB. Cada atributo de la carga se escribe en una columna independiente de la base de datos
de DynamoDB.
Cuando cree una regla de DynamoDB, debe especificar la información siguiente:
roleARN
El rol de IAM que permite tener acceso a la tabla de DynamoDB. Como mínimo, el rol debe
permitir la acción de IAM dynamoDB:PutItem.
tableName
Nombre de la tabla de DynamoDB.
Note
La carga del mensaje MQTT debe contener una clave de nivel de raíz que coincida con la
clave de partición principal de la tabla y una clave de nivel de raíz que coincida con la clave
de ordenación principal de la tabla, si hay una definida.
Los datos que se escriben en la tabla de DynamoDB son el resultado de la instrucción SQL de la
regla.
Note
dynamodb:PutItem.
El siguiente ejemplo de JSON muestra cómo definir una acción dynamoDB en una regla de AWS IoT:
{
"sql": "SELECT * AS message FROM 'some/topic'",
"description": "A test DynamoDBv2 rule",
"actions": [{
"dynamoDBv2": {
297
Acción de Elasticsearch
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_dynamoDBv2",
"putItem": {
"tableName": "my_ddb_table"
}
}
}]
}
}
Para obtener más información, consulte Guía de introducción a Amazon DynamoDB. Si utiliza una
CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo de DynamoDB, el
servicio debe tener permiso para poder usar la CMK en nombre del autor de la llamada. Para obtener
más información, consulte este artículo sobre la CMK administrado por el cliente en la Guía de
introducción de Amazon DynamoDB.
Acción de Elasticsearch
Elasticsearch action
La acción elasticsearch le permite escribir datos de mensajes de MQTT en un dominio de Amazon

Elasticsearch Service. Los datos contenidos en Elasticsearch se pueden consultar y visualizar con
herramientas como Kibana.
Cuando cree una regla de AWS IoT con una acción elasticsearch, debe especificar la información
siguiente:
endpoint
Punto de enlace del dominio de Amazon Elasticsearch Service.

índice
Índice de Elasticsearch donde se van a almacenar los datos.

type
Tipo de documento que está almacenando.

id
Identificador único de cada documento.
Note
es:ESHttpPut.
El siguiente ejemplo de JSON muestra cómo definir una acción elasticsearch en una regla de
AWS IoT:
{
"topicRulePayload":{
"sql":"SELECT *, timestamp() as timestamp FROM 'iot/test'",
"ruleDisabled":false,
"actions":[{
"elasticsearch":{
"roleArn":"arn:aws:iam::123456789012:role/aws_iot_es",
298
Acción Firehose
"endpoint":"https://my-endpoint",
"index":"my-index",
"type":"my-type",
"id":"${newuuid()}"
}
}]
}
}
Para obtener más información, consulte Guía para desarrolladores de Amazon Elasticsearch Service.
Si utiliza una CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo de
Elasticsearch, el servicio debe tener permiso para poder usar la CMK en nombre del autor de la
llamada. Para obtener más información, consulte este artículo sobre el cifrado de datos en reposo
para Amazon Elasticsearch Service en la Guía del desarrollador de Amazon Elasticsearch Service.
Acción Firehose
Firehose action
Una acción firehose envía datos de un mensaje MQTT que activó la regla a un flujo de Kinesis Data
Firehose.
Cuando cree una regla con una acción firehose, debe especificar la información siguiente:
deliveryStreamName
El flujo de Kinesis Data Firehose en el que deben escribirse los datos del mensaje.
roleArn
El rol de IAM que permite obtener acceso a Kinesis Data Firehose.

separator
Un separador de caracteres que se utiliza para separar los registros escritos en el flujo de Kinesis
Data Firehose. Los valores válidos son: '\n' (línea nueva), '\t' (tabulador), '\r\n' (línea nueva de
Windows), ',' (coma).
Note
firehose:PutRecord.
El ejemplo de JSON siguiente muestra cómo crear una regla de AWS IoT con una acción firehose:
{
"actions": [{
"firehose": {
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_firehose",
"deliveryStreamName": "my_firehose_stream"
}
}]
}
}
299
Acción HTTP
Para obtener más información, consulte Guía para desarrolladores de Amazon Kinesis Data Firehose.
Si utiliza Kinesis Data Firehose para enviar datos a un bucket de Amazon S3 y utiliza una CMK de
AWS KMS administrada por el cliente para los cifrar datos en reposo de Amazon S3, Kinesis Data
Firehose debe tener acceso al bucket y permiso para poder usar la CMK en nombre de la persona que
llama. Para obtener más información, consulte este artículo acerca de cómo conceder a Kinesis Data
Firehose acceso a un destino de Amazon S3 en la Guía del desarrollador de Amazon Kinesis Data
Firehose.
Acción HTTP
HTTP action
La acción http envía datos desde el mensaje MQTT que activó la regla a sus aplicaciones o servicios
web para su posterior procesamiento, sin escribir ningún código. El punto de enlace al que envía datos
debe verificarse para que el motor de reglas pueda usarlo.
Cuando cree una regla con una acción http, debe especificar la información siguiente:
url
La URL HTTPS donde HTTP POST envía el mensaje. Puede utilizar plantillas de sustitución en la
URL.
confirmationUrl
Opcional. Si se especifica, AWS IoT utiliza la dirección URL de confirmación para crear un destino
de regla del tema coincidente. Debe habilitar el destino de la regla del tema para poder usarlo en
una acción http. Para obtener más información, consulte Trabajar con destinos de reglas de
temas (p. 317). Si utiliza plantillas de sustitución, debe crear manualmente destinos de reglas de
tema para poder utilizar la acción http. confirmationUrl debe ser un prefijo de url.
La relación entre url y confirmationUrl se describe de la siguiente manera:

• Si url está codificado y no se proporciona confirmationUrl, tratamos implícitamente el
campo url como confirmationUrl. AWS IoT crea un destino de regla del tema para url.
• Si url y confirmationUrl están codificados, url debe comenzar por confirmationUrl.
AWS IoT crea un destino de regla del tema para confirmationUrl.
• Si url contiene una plantilla de sustitución, debe especificar confirmationUrl y url debe
comenzar por confirmationUrl. Si confirmationUrl contiene plantillas de sustitución,
debe crear manualmente destinos de reglas del tema para poder utilizar la acción http. Si
confirmationUrl no contiene plantillas de sustitución, AWS IoT crea un destino de regla del
tema para confirmationUrl.
headers
Opcional. Cualquier encabezado que desee incluir en las solicitudes HTTP.

clave
La clave del encabezado. No se admiten plantillas de sustitución.

value
El valor del encabezado. Se admiten plantillas de sustitución.

auth
Opcional. Autenticación utilizada por el motor de reglas para conectarse a la dirección URL del
punto de enlace especificada en el argumento url. Actualmente, Signature Version 4 es el único
tipo de autenticación admitido. Para obtener más información, consulte Autorización HTTP.
300
Acción de IoT Analytics
El ejemplo de JSON siguiente muestra cómo crear una regla de AWS IoT con una acción http:
{
"sql": "select * from 'a/b'",
"actions": [{
"http": {
"url": "https://www.example.com/subpath",
"confirmationUrl": "https://www.example.com",
"headers": [{
"key": "static_header_key",
"value": "static_header_value"
},
{
"key": "substitutable_header_key",
"value": "${value_from_payload}"
}]
}
}]
}
}
El tipo de contenido predeterminado es application/json cuando la carga útil está en formato JSON.
De lo contrario, es application/octet-stream. Puede sobrescribirlo especificando el tipo de contenido
exacto en el encabezado con el tipo de contenido de la clave (sin distinción entre mayúsculas y
minúsculas).
HTTP action retry logic
El motor de reglas de AWS IoT reintenta las acciones http de acuerdo con estas reglas:
• El motor de reglas intenta enviar un mensaje al menos una vez.

• El motor de reglas realiza como máximo dos reintentos. El número máximo de intentos es tres.
• El motor de reglas no realiza un reintento si:
• El intento anterior proporcionó una respuesta mayor de 16384 bytes.
• El servicio o la aplicación web de salida cierra la conexión TCP después del intento.
• El tiempo total para completar una solicitud con reintentos superó el límite de tiempo de espera de
la solicitud.
• La solicitud devuelve un código de estado HTTP distinto de 429, 500-599.
Note
Se aplican costos estándar de transferencia de datos a los reintentos.

IoT Analytics action
Una acción iotAnalytics envía datos desde el mensaje MQTT que activó la regla a un canal de
AWS IoT Analytics.
Cuando cree una regla con una acción iotAnalytics, debe especificar la información siguiente:
301
channelName
El nombre del canal de AWS IoT Analytics en el que se escriben los datos.
roleArn
El rol de IAM que permite tener acceso al canal de AWS IoT Analytics.
La política asociada al rol que especifique debe tener el siguiente aspecto:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotanalytics:BatchPutMessage",
"Resource": [
"arn:aws:iotanalytics:us-west-2:account-id:channel/mychannel"
]
}
]
}
y debe tener una relación de confianza con este aspecto:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
},
"Action": "sts:AssumeRole",
}
]
}
El ejemplo de JSON siguiente muestra cómo crear una regla de AWS IoT con una acción
iotAnalytics:
{
"actions": [{
"iotAnalytics": {
"channelName": "mychannel",
"roleArn": "arn:aws:iam::123456789012:role/analyticsRole",
}
}]
}
}
Para obtener más información, consulte la Guía del usuario de AWS IoT Analytics.
La consola de AWS IoT Analytics también tiene una característica Inicio rápido que le permite crear un
canal, almacén de datos y canalización con un solo clic. Busque esta página cuando abra la consola
de AWS IoT Analytics:
302
Acción de eventos de IoT
Acción de eventos de IoT

IoT Events action
Una acción iotEvents envía datos desde el mensaje MQTT que activó la regla a una entrada de
AWS IoT Events.
Cuando cree una regla con una acción iotEvents, debe especificar la información siguiente:
inputName
El nombre de la entrada de AWS IoT Events.

messageId
Opcional. Utilice esta opción para asegurarse de que un detector de AWS IoT Events solo
procesará una entrada (un mensaje) con un determinado messageId.
roleArn
El ARN del rol que concede permiso a AWS IoT para enviar una entrada a un detector de AWS
IoT Events. ("Action":"iotevents:BatchPutMessage").
Aquí hay un ejemplo de política de confianza que debería ir asociada al rol:
{
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "iotevents:BatchPutMessage",
"Resource": [ * ]
}
}
El ejemplo JSON siguiente muestra cómo crear una regla de AWS IoT con una acción iotEvents:
{
303
Acción SiteWise de IoT
"description": "An AWS IoT Events test rule",
"actions": [{
"iotEvents": {
"inputName": "MyIoTEventsInput",
"messageId": "1234567890",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_events"
},
}]
}
}
Para obtener más información, consulte la Guía para desarrolladores de AWS IoT Events.

IoT SiteWise action
Una acción iotSiteWise envía datos desde el mensaje MQTT que activó la regla a las propiedades
de recurso de AWS IoT SiteWise.
Note
Cuando envía datos a AWS IoT SiteWise con esta acción, los datos deben cumplir todos los
requisitos de la acción BatchPutAssetPropertyValue. Para obtener más información,
consulte BatchPutAssetPropertyValue en la Referencia de la API AWS IoT SiteWise.
Puede seguir un tutorial que le muestra cómo incorporar datos de objetos de AWS IoT. Para obtener
más información, consulte Incorporación de datos a AWS IoT SiteWise desde objetos de AWS IoT en
la Guía del usuario de AWS IoT SiteWise.
Para obtener más información acerca de la solución de problemas de esta regla, consulte Solución de
problemas de una acción de regla de AWS IoT SiteWise en la Guía del usuario de AWS IoT SiteWise.
Cuando cree una regla con una acción iotSiteWise, debe especificar la información siguiente:
putAssetPropertyValueEntries
Una lista de entradas de valor de propiedad de recurso, en la que cada entrada contiene la
entryId
Opcional. Un identificador único para esta entrada. Puede definir el entryId para facilitar el
seguimiento del mensaje que causó un error en caso de que se produzca un error. Acepta
plantillas de sustitución. El valor predeterminado es un nuevo UUID.
propertyAlias
El alias de propiedad asociado a la propiedad del recurso. Debe especificar un

propertyAlias o tanto un assetId como un propertyId. Acepta plantillas de
sustitución. Para obtener más información acerca de los alias de propiedades, consulte
Mapeo de flujos de datos industriales a propiedades de recursos en la Guía del usuario de
AWS IoT SiteWise.
assetId
El ID del recurso de AWS IoT SiteWise. Debe especificar un propertyAlias o tanto un

assetId como un propertyId. Acepta plantillas de sustitución.
304
propertyId
El ID de la propiedad del recurso. Debe especificar un propertyAlias o tanto un assetId

como un propertyId. Acepta plantillas de sustitución.
propertyValues
Una lista de valores de propiedad que se van a insertar, en la que cada valor contiene una
marca temporal, la calidad y el valor (TQV) en el formato siguiente:
timestamp
Una estructura de marca temporal que contiene la siguiente información:

timeInSeconds
Una cadena que contiene el tiempo en segundos en formato de tiempo Unix. Acepta
plantillas de sustitución. Si su carga de mensajes no tiene una marca temporal,
puede usar Timestamp() (p. 369), que devuelve la hora actual en milisegundos.
Para convertir ese tiempo en segundos, puede utilizar la siguiente plantilla de
sustitución: ${floor(timestamp() / 1E3)}.
offsetInNanos
Opcional. Una cadena que contiene el desfase de tiempo en nanosegundos a partir

del tiempo en segundos. Acepta plantillas de sustitución. Si su carga de mensajes
no tiene una marca temporal, puede usar Timestamp() (p. 369), que devuelve la
hora actual en milisegundos. Para calcular el desfase en nanosegundos a partir de
ese tiempo, puede utilizar la siguiente plantilla de sustitución: ${(timestamp() %
1E3) * 1E6}.
Con respecto a la hora en formato de tiempo Unix, AWS IoT SiteWise acepta solo
entradas que tengan una marca temporal de hasta 15 minutos en el pasado y hasta 5
minutos en el futuro.
quality
Opcional. Una cadena que describe la calidad del valor. Acepta plantillas de sustitución.
Debe ser GOOD, BAD o UNCERTAIN.
value
Una estructura de valores que contiene uno de los siguientes campos de valor, en
función del tipo de datos de la propiedad del recurso:
booleanValue
Opcional. Una cadena que contiene el valor booleano de la entrada del valor. Acepta
plantillas de sustitución.
doubleValue
Opcional. Una cadena que contiene el valor "double" de la entrada del valor. Acepta
integerValue
Opcional. Una cadena que contiene el valor entero de la entrada del valor. Acepta
stringValue
Opcional. El valor de cadena de la entrada del valor. Acepta plantillas de sustitución.

roleArn
El ARN del rol que concede a AWS IoT permiso para enviar un valor de propiedad de recurso
AWS IoT SiteWise. ("Action": "iotsitewise:BatchPutAssetPropertyValue").
305
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*"
}
]
}
Para mejorar la seguridad, puede especificar una ruta jerárquica de recursos de AWS IoT
SiteWise en la propiedad Condition. El siguiente ejemplo es una política de confianza que
especifica una ruta jerárquica de recursos.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
iotSiteWise básica:
{
"actions": [{
"iotSiteWise": {
"putAssetPropertyValueEntries": [
{
"propertyAlias": "/some/property/alias",
"propertyValues": [
{
"timestamp": {
"timeInSeconds": "${my.payload.timeInSeconds}"
},
"value": {
"integerValue": "${my.payload.value}"
}
}
]
}
],
306
Acción Kinesis
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_sitewise"
},
}]
}
}
iotSiteWise: En este ejemplo se utiliza el tema como alias de propiedad y función timestamp().
Por ejemplo, si publica datos en /company/windfarm/3/turbine/7/rpm, esta acción envía los
datos a la propiedad del recurso con un alias de propiedad que es el mismo que el tema especificado.
{
"sql": "SELECT * FROM '/company/windfarm/+/turbine/+/+'",
"actions": [{
"iotSiteWise": {
"putAssetPropertyValueEntries": [
{
"propertyAlias": "${topic()}",
"propertyValues": [
{
"timestamp": {
"timeInSeconds": "${floor(timestamp() / 1E3)}",
"offsetInNanos": "${(timestamp() % 1E3) * 1E6}"
},
"value": {
"doubleValue": "${my.payload.value}"
}
}
]
}
],
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_sitewise"
},
}]
}
}
Para obtener más información, consulte la Guía del usuario de AWS IoT SiteWise.
Acción Kinesis
Kinesis action
La acción kinesis le permite escribir los datos de mensajes de MQTT en un flujo de Kinesis.
Cuando cree una regla de AWS IoT con una acción kinesis, debe especificar la información
siguiente:
stream
El flujo de Kinesis en el que se escriben los datos.

partitionKey
La clave de partición utilizada para determinar en qué fragmento se escriben los datos. La
clave de partición se compone normalmente de una expresión (por ejemplo, "${topic()}" o
"${timestamp()}").
307
Acción Lambda
Note
Asegúrese de que la política asociada a la regla tenga el permiso kinesis:PutRecord.
El siguiente ejemplo de JSON muestra cómo definir una acción kinesis en una regla de AWS IoT:
{
"actions": [{
"kinesis": {
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_kinesis",
"streamName": "my_kinesis_stream",
"partitionKey": "${topic()}"
}
}],
}
}
Para obtener más información, consulte Guía para desarrolladores de Amazon Kinesis Data Streams.
Si utiliza una CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo de Kinesis
Data Streams, el servicio debe tener permiso para poder usar la CMK en nombre del autor de la
llamada. Para obtener más información, consulte Permisos para utilizar claves maestras de KMS
generadas por el usuario en la Guía del desarrollador de Amazon Kinesis Data Streams.
Acción Lambda
Lambda action
Una acción lambda llama a una función de Lambda, transfiriendo el mensaje MQTT que activó la
regla. Las funciones de Lambda se ejecutan de forma asíncrona.
Las funciones de Lambda se ejecutan de forma asíncrona.
Para que AWS IoT llame a la función de Lambda, debe configurar una política que conceda el
permiso lambda:InvokeFunction a AWS IoT. Solo puede invocar una función de Lambda
definida en la misma región en la que existe la política de Lambda. Las funciones de Lambda
utilizan políticas basadas en recursos, de modo que debe asociar la política a la propia función de
Lambda. Ejecute el siguiente comando de la CLI para asociar una política que conceda el permiso
lambda:InvokeFunction:
aws lambda add-permission --function-name "function_name" --region "region" --principal

iot.amazonaws.com --source-arn arn:aws:iot:us-east-2:account-id:rule/rule_name --
source-account "account-id" --statement-id "unique_id" --action "lambda:InvokeFunction"
A continuación, se indican los argumentos del comando add-permission:
--function-name
Nombre de la función de Lambda cuya política de recursos está actualizando mediante la adición
de un nuevo permiso.
--region
Región de AWS de la cuenta.
308
Acción Lambda
--principal
La entidad principal que obtiene el permiso. Debe ser iot.amazonaws.com para que AWS IoT
pueda llamar a una función de Lambda.
--source-arn
El ARN de la regla. Puede utilizar el comando de la CLI get-topic-rule para obtener el ARN
de una regla.
--source-account
Cuenta de AWS donde está definida la regla.

--statement-id
Un identificador de instrucción único.

--action
La acción Lambda que desea permitir en esta instrucción. Para permitir que AWS IoT invoque una
función de Lambda, especifique lambda:InvokeFunction.
Note
Si agrega un permiso para una entidad de seguridad de AWS IoT sin proporcionar el ARN
de origen, cualquier cuenta de AWS que cree una regla con la acción de Lambda podrá
desencadenar reglas para invocar la función Lambda desde AWS IoT.
Para obtener más información, consulte este artículo sobre el modelo de permisos de Lambda.
Cuando cree una regla con una acción lambda, debe especificar la función Lambda que se invocará
cuando se active la regla.
El ejemplo de JSON siguiente muestra una regla que llama a una función de Lambda:
{
"actions": [{
"lambda": {
"functionArn": "arn:aws:lambda:us-
east-2:123456789012:function:myLambdaFunction"
}
}]
}
}
Si no especifica una versión o un alias para la función de Lambda, se ejecutará la versión más
reciente de la función. Puede especificar una versión o alias si desea ejecutar una versión específica
de su función de Lambda. Para especificar una versión o alias, añada la versión o el alias en el ARN
de la función de Lambda. Por ejemplo:
"arn:aws:lambda:us-east-2:123456789012:function:myLambdaFunction:someAlias"
Para obtener más información acerca del control de versiones y los alias, consulte Control de
versiones y alias de las funciones de AWS Lambda. Para obtener más información sobre AWS
Lambda, consulte la AWS Lambda Developer Guide.
309
Acción Republish
Si utiliza una CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo de AWS
Lambda, el servicio debe tener permiso para poder usar la CMK en nombre del autor de la llamada.
Para obtener más información, consulte Cifrado en reposo en la Guía del desarrollador de AWS
Lambda.
Acción Republish
Republish action
La acción republish le permite volver a publicar el mensaje que activó el rol, en otro tema MQTT.
Cuando cree una regla con una acción republish, debe especificar la información siguiente:
tema
El tema MQTT en el que se va a volver a publicar el mensaje. Si está volviendo a publicar en un

tema reservado que comience por $ utilice $$ en su lugar. Por ejemplo, si va a volver a publicar
en un tema de sombra de dispositivo como $$aws/things/MyThing/shadow/update,
especifique el tema como $$aws/things/MyThing/shadow/update.
roleArn
El rol de IAM que permite publicar en el tema de MQTT.

qos
Opcional. El nivel de calidad de servicio (QoS) que se utiliza para volver a publicar mensajes. Los
valores válidos son 0 o 1. El valor predeterminado es 0.
Note
iot:Publish.
{
"actions": [{
"republish": {
"topic": "another/topic",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_republish",
"qos": 1
}
}]
}
}
Acción S3
S3 action
Una acción s3 escribe los datos desde el mensaje MQTT que activó la regla en un bucket de Amazon
S3.
310
Acción S3
Cuando cree una regla de AWS IoT con una acción s3, debe especificar la información siguiente
(excepto cannedacl, que es opcional):
bucket
El bucket de Amazon S3 en el que se escribirán los datos.

cannedacl
Opcional. La lista de control de acceso (ACL) predefinida de Amazon S3 que controla el acceso
al objeto identificado mediante la clave de objeto. Para obtener más información, incluidos los
valores permitidos, consulte ACL predefinidas de S3.
key
La ruta al archivo en el que se escriben los datos. Por ejemplo, si el valor de este argumento es
"${topic()}/${timestamp()}", el tema al que se envió el mensaje es "this/is/my/topic". Si la marca de
tiempo actual es 1460685389, los datos se escriben en un archivo denominado "1460685389" en
la carpeta "this/is/my/topic" de Amazon S3.
Note
El uso de una clave estática hará que se sobrescriba únicamente un archivo en Amazon
S3 por cada invocación de la regla. Lo más habitual es utilizar la marca de tiempo del
mensaje u otro identificador de mensaje único, de modo que por cada mensaje recibido
se guarde un archivo nuevo en Amazon S3.
roleArn
El rol de IAM que permite tener acceso al bucket de Amazon S3.
Note
s3:PutObject.
El siguiente ejemplo de JSON muestra cómo definir una acción s3 en una regla de AWS IoT:
{
"actions": [{
"s3": {
"bucketName": "my-bucket",
"key": "${topic()}/${timestamp()}"
"cannedacl": "public-read"
}
}]
}
}
Para obtener más información, consulte Guía para desarrolladores de Amazon Simple Storage
Service. Si utiliza una CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo
de Amazon S3, el servicio debe tener permiso para poder usar la CMK en nombre del autor de la
llamada. Para obtener más información, consulte CMK administradas por AWS y CMK administradas
por el cliente en la Guía del desarrollador de Amazon Simple Storage Service.
311
Acción Salesforce
Acción Salesforce
Salesforce action
Una acción salesforce envía datos del mensaje MQTT que activó la regla a un flujo de entrada de
Salesforce IoT.
Cuando cree una regla con una acción salesforce, debe especificar la información siguiente:
url
La dirección URL expuesta por el flujo de entrada de Salesforce IoT. La dirección URL está
disponible en la plataforma de Salesforce IoT cuando crea un flujo de entrada. Para obtener más
información, consulte la documentación de Salesforce IoT.
token
El token que se utiliza para autenticar el acceso al flujo de entrada de Salesforce IoT especificado.
El token está disponible en la plataforma de Salesforce IoT cuando se crea un flujo de entrada.
Para obtener más información, consulte la documentación de Salesforce IoT.
Note
Estos parámetros no pueden sustituirse.
salesforce:
{
"actions": [{
"salesforce": {
"token": "ABCDEFGHI123456789abcdefghi123456789",
"url": "https://ingestion-cluster-id.my-env.sfdcnow.com/streams/stream-
id/connection-id/my-event"
}
}]
}
}
Para obtener más información, consulte la documentación de Salesforce IoT.
Acción SNS
SNS action
Una acción sns envía los datos del mensaje MQTT que activó la regla como notificación de inserción
de SNS.
Cuando cree una regla con una acción sns, debe especificar la información siguiente:
312
Acción SQS
messageFormat
El formato del mensaje. Los valores aceptados son "JSON" y "RAW." El valor predeterminado del
atributo es "RAW." SNS utiliza esta configuración para determinar si la carga debe analizarse y las
partes pertinentes de la carga específicas de la plataforma deben extraerse.
roleArn
El rol de IAM que permite obtener acceso a SNS.

targetArn
El tema de SNS o el dispositivo individual al que se enviará la notificación de inserción.
Note
Asegúrese de que la política asociada a la regla tenga el permiso sns:Publish.
El siguiente ejemplo de JSON muestra cómo definir una acción sns en una regla de AWS IoT:
{
"actions": [{
"sns": {
"targetArn": "arn:aws:sns:us-east-2:123456789012:my_sns_topic",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_sns"
}
}]
}
}
Para obtener más información, consulte Guía para desarrolladores de Amazon Simple Notification
Service. Si utiliza una CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo
de Amazon SNS, el servicio debe tener permiso para poder usar la CMK en nombre del autor de la
llamada. Para obtener más información, consulte este artículo sobre la administración de claves en la
Guía del desarrollador de Amazon Simple Notification Service.
Acción SQS
SQS action
Una acción sqs envía datos del mensaje MQTT que activó la regla a una cola de SQS.
Cuando cree una regla con una acción sqs, debe especificar la información siguiente:
queueUrl
La dirección URL de la cola SQS en la que se escriben los datos.

useBase64
Establezca esta opción en true si quiere que los datos de mensajes MQTT se codifiquen en
Base64 antes de escribir en la cola SQS. De lo contrario, establézcala en false.
roleArn
El rol de IAM que permite tener acceso a la cola SQS.
313
Acción de Step Functions
Note
sqs:SendMessage.
El ejemplo de JSON siguiente muestra cómo crear una regla de AWS IoT con una acción sqs:
{
"actions": [{
"sqs": {
"queueUrl": "https://sqs.us-east-2.amazonaws.com/123456789012/
my_sqs_queue",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_sqs",
"useBase64": false
}
}]
}
}
La acción de SQS no es compatible con las colas FIFO de SQS. Dado que el motor de reglas es un
servicio totalmente distribuido, no se garantiza el orden de los mensajes cuando se activa la acción de
SQS.
Para obtener más información, consulte Guía para desarrolladores de Amazon Simple Queue Service.
Si utiliza una CMK de AWS KMS administrada por el cliente para cifrar los datos en reposo de Amazon
SQS, el servicio debe tener permiso para poder usar la CMK en nombre del autor de la llamada.
Para obtener más información, consulte este artículo sobre la administración de claves en la Guía del
desarrollador de Amazon Simple Queue Service.
Acción de Step Functions

Step Functions action
Una acción stepFunctions inicia la ejecución de una máquina de estado de Step Functions.
Cuando cree una regla con una acción stepFunctions, debe especificar la información siguiente:
executionNamePrefix
Opcional. El nombre asignado a la ejecución de la máquina de estado consta de este prefijo

seguido de un UUID. Step Functions crea un nombre único para cada ejecución de la máquina de
estado si no se proporciona ninguno.
stateMachineName
El nombre de la máquina de estado de Step Functions cuya ejecución se va a iniciar.

roleArn
El ARN del rol que concede a AWS IoT permisos para iniciar la ejecución de una máquina de
estado ("Action":"states:StartExecution").
314
Solución de problemas de las reglas
"Version": "2012-10-17",
"Statement": {
"Effect": "Allow",
"Action": "states:StartExecution",
"Resource": [ * ]
}
}
stepFunctions:
{
"description": "A step functions test rule",
"actions": [{
"stepFunctions": {
"executionNamePrefix": "myExecution",
"stateMachineName": "myStateMachine",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_step_functions"
}
}]
}
}
Para obtener más información, consulte Guía para desarrolladores de AWS Step Functions.
Solución de problemas de las reglas

Si tiene algún problema con las reglas, debe habilitar CloudWatch Logs. Si analiza los logs, puede saber
si el problema es la autorización o si, por ejemplo, la condición de cláusula WHERE no ha coincidido. Para
obtener más información, consulte el tema sobre la configuración de CloudWatchLogs.
Control de errores (acción de error)

Cuando AWS IoT recibe un mensaje de un dispositivo, el motor de reglas realiza comprobaciones para
ver si el mensaje coincide con una regla. En caso afirmativo, se evalúa la instrucción SQL de la regla, se
activan las acciones de la regla y se pasa el resultado de la instrucción SQL.
Si se produce un problema al activar una acción, el motor de reglas activa una acción de error si se
especificó una para la regla. Esto podría ocurrir cuando:
• Una regla no dispone de permiso para acceder al bucket de Amazon S3.

• Un error de usuario provoca que se supere el rendimiento aprovisionado de DynamoDB.
Formato de mensaje de acción de error

Se genera un único mensaje por regla y mensaje. Por ejemplo, si se produce un error en dos acciones de
regla en la misma regla, la acción de error recibe un mensaje con los dos errores.
El mensaje de acción de error tiene el siguiente aspecto:
315
Ejemplo de acción de error
{
"ruleName": "TestAction",
"topic": "testme/action",
"cloudwatchTraceId": "7e146a2c-95b5-6caf-98b9-50e3969734c7",
"clientId": "iotconsole-1511213971966-0",
"base64OriginalPayload": "ewogICJtZXNzYWdlIjogIkhlbGxvIHZyb20gQVdTIElvVCBjb25zb2xlIgp9",
"failures": [
{
"failedAction": "S3Action",
"failedResource": "us-east-1-s3-verify-user",
"errorMessage": "Failed to put S3 object. The error received was The
specified bucket does not exist (Service: Amazon S3; Status Code: 404; Error
Code: NoSuchBucket; Request ID: 9DF5416B9B47B9AF; S3 Extended Request ID:
yMah1cwPhqTH267QLPhTKeVPKJB8BO5ndBHzOmWtxLTM6uAvwYYuqieAKyb6qRPTxP1tHXCoR4Y=).
Message arrived on: error/action, Action: s3, Bucket: us-
east-1-s3-verify-user, Key: \"aaa\". Value of x-amz-id-2:
yMah1cwPhqTH267QLPhTKeVPKJB8BO5ndBHzOmWtxLTM6uAvwYYuqieAKyb6qRPTxP1tHXCoR4Y="
}
]
}
ruleName
El nombre de la regla que activó la acción de error.

tema
El tema en el que se recibió el mensaje original.

cloudwatchTraceId
Una identidad única relacionada con los registros de errores en CloudWatch.

clientId
El ID de cliente del publicador de mensajes.

base64OriginalPayload
La carga del mensaje original codificada en Base64.

failures
failedAction
El nombre de la acción que no se pudo completar (por ejemplo "S3Action").

failedResource
El nombre del recurso (por ejemplo el nombre de un bucket de S3).

errorMessage
La descripción y explicación del error.
Ejemplo de acción de error

A continuación se muestra un ejemplo de una regla con una acción de error añadida. La siguiente regla
tiene una acción que escribe datos de mensajes en una tabla de DynamoDB y una acción de error que
escribe datos en un bucket de Amazon S3:
{
"sql" : "SELECT * FROM ..."
"actions" : [{
"dynamoDB" : {
"table" : "PoorlyConfiguredTable",
316
Trabajar con destinos de reglas de temas
"hashKeyField" : "AConstantString",
"hashKeyValue" : "AHashKey"}}
],
"errorAction" : {
"s3" : {
"bucket" : "message-processing-errors",
"key" : "${replace(topic(), '/', '-') + '-' + timestamp() + '-' + newuuid()}"
}
}
}
Puede utilizar cualquier función o sustitución en una instrucción SQL de la acción de error, excepto en
funciones externas (por ejemplo, get_thing_shadow, aws_lambda y machinelearning_predict).
Para obtener más información acerca de reglas y cómo especificar una acción de error, consulte Creación
de una regla de AWS IoT (p. 288).
Para obtener más información sobre el uso de CloudWatch para monitorizar el éxito o el fracaso de las
reglas, consulte Métricas y dimensiones de AWS IoT (p. 230).
Trabajar con destinos de reglas de temas

Un destino es un recurso que define dónde el motor de reglas puede enviar los datos. Un destino se puede
reutilizar de una regla a otra y puede requerir confirmación o configuración antes de poder utilizarlo. Los
destinos permiten que el motor de reglas envíe datos a otros servicios que no están integrados de forma
nativa con AWS IoT.
Los destinos de reglas de temas se utilizan para comprobar que usted es el propietario del punto de enlace
al que desea enviar los datos o tiene acceso a él. Cuando crea una acción de regla con un punto de enlace
(por ejemplo, una acción http) o actualiza el punto de enlace de una acción de regla existente, AWS
IoT envía un mensaje de confirmación al punto de enlace que contiene un token único. Para verificar su
punto de enlace, debe llamar a ConfirmTopicRuleDestination con el token para verificar que usted
es el propietario del punto de enlace o tiene acceso a él. El token es válido durante tres días, después
de los cuales debe crear una nueva acción http o llamar a la API UpdateTopicRuleDestination
para reiniciar el proceso de confirmación. También puede confirmar el destino de la regla del tema
desplazándose hasta enableUrl o proporcionando el token en la página Destination (Destino) de la
consola de AWS IoT.
Cuando AWS IoT recibe el token enviado a su punto de enlace, se confirma el destino. Debe habilitar el
destino para que lo pueda utilizar el motor de reglas. Un destino puede tener cualquiera de los siguientes
estados:
ENABLED
El destino está habilitado. Un destino debe tener el estado ENABLED para que se utilice en una regla.
Solo puede habilitar destinos con el estado DISABLED.
DISABLED
El destino se ha confirmado pero está deshabilitado. Esto es útil si desea impedir temporalmente el
tráfico a su punto de enlace sin tener que pasar de nuevo por el proceso de confirmación. Solo puede
deshabilitar un destino con el estado ENABLED.
IN_PROGRESS
La confirmación del destino se está realizando.

ERROR
Se ha agotado el tiempo de espera de confirmación del destino.
317
Creación de un destino de regla del tema
Una vez confirmados y habilitados, los destinos se pueden utilizar con cualquier regla de su cuenta.
Creación de un destino de regla del tema

Un destino se crea cuando se utiliza AWS IoT para crear una regla con una acción http. También puede
crear un destino mediante la API CreateTopicRuleDestination o la consola de AWS IoT.
Al crear un destino, AWS IoT comprueba que la dirección URL del punto de enlace sea válida. Si la URL
es válida, se envía un mensaje de confirmación a esa URL. La solicitud de confirmación tiene el siguiente
formato:
HTTP POST {confirmationUrl}/?confirmationToken={confirmationToken}

Headers:
x-amz-rules-engine-message-type: DestinationConfirmation
x-amz-rules-engine-destination-arn:"arn:aws:iot:us-east-1:123456789012:ruledestination/
http/7a280e37-b9c6-47a2-a751-0703693f46e4"
Content-Type: application/json
Body:
{
"arn":"arn:aws:iot:us-east-1:123456789012:ruledestination/http/7a280e37-b9c6-47a2-
a751-0703693f46e4",
"confirmationToken": "AYADeMXLrPrNY2wqJAKsFNn-…NBJndA",
"enableUrl": "https://iot.us-east-1.amazonaws.com/confirmdestination/
AYADeMXLrPrNY2wqJAKsFNn-…NBJndA",
"messageType": "DestinationConfirmation"
}
Los campos de este mensaje se definen de la siguiente manera:
arn
El ARN del destino de la regla del tema que se va a confirmar.

confirmationToken
El token de confirmación. El token del ejemplo está truncado. Su token será mayor.
enableUrl
La dirección URL a la que se desplaza para confirmar el destino de una regla del tema.
messageType
Tipo de mensaje.
Confirmación de un destino de regla del tema

Puede confirmar un destino realizando una solicitud HTTP GET a la enableUrl que se incluye en el
mensaje de confirmación. Puede llamar a ConfirmTopicRuleDestination con el token desde el
mensaje de confirmación o puede usar la consola de AWS IoT.
El token debe ser válido para que el destino adopte el estado ENABLED. Si el token ha caducado, debe
llamar a UpdateTopicRuleDestination para reiniciar el proceso de confirmación.
Note
Si confirma el destino de la regla del tema llamando a ConfirmTopicRuleDestination, el

estado del destino será DISABLED y tendrá que habilitar explícitamente su destino llamando a
UpdateTopicRuleDestination antes de usarlo.
318
Deshabilitación de un destino de regla del tema
Deshabilitación de un destino de regla del tema

Para deshabilitar un destino, llame a UpdateTopicRuleDestination y establezca el estado del destino
de la regla del tema en DISABLED.
Habilitación de un destino de regla del tema

Para habilitar un destino, llame a UpdateTopicRuleDistination y establezca el estado de la regla del
tema en ENABLED. No es necesario volver a validar la URL.
Envío de un nuevo mensaje de confirmación

Para activar un nuevo mensaje de confirmación para un destino, llame a
UpdateTopicRuleDistination y establezca el estado del destino de la regla del tema en
IN_PROGRESS.
Eliminación de un destino de regla del tema

Para eliminar un destino de regla del tema, llame a DeleteTopicRuleDestination.
Reducción de los costos de mensajería con Basic

Ingest
Basic Ingest le permite enviar de forma segura datos de los dispositivos a los servicios de AWS
compatibles con Acciones de reglas de AWS IoT (p. 292) sin incurrir en costos de mensajería. Basic
Ingest optimiza el flujo de datos eliminando el agente de mensajes de publicación/suscripción de la ruta de
adquisición, por lo que resulta más rentable.
Para utilizar Basic Ingest, los mensajes se envían desde los dispositivos o aplicaciones con los nombres de
temas que empiezan con $aws/rules/rule-name como sus tres primeros niveles, donde rule-name
es el nombre de la regla de AWS IoT que desencadenar.
Puede utilizar una regla existente con Basic Ingest simplemente añadiendo el prefijo de Basic Ingest
($aws/rules/rule-name) al tema del mensaje por el que normalmente se desencadena la regla.
Por ejemplo, si tiene una regla llamada BuildingManager que se desencadena mediante mensajes
con temas como Buildings/Building5/Floor2/Room201/Lights ("sql": "SELECT * FROM
'Buildings/#'"), podrá desencadenar la misma regla con Basic Ingest enviando un mensaje con el
tema $aws/rules/BuildingManager/Buildings/Building5/Floor2/Room201/Lights.
Tenga en cuenta lo siguiente:
• Sus dispositivos y sus reglas no pueden suscribirse a temas reservados para Basic Ingest. Para obtener
más información, consulte Temas reservados (p. 267).
• Si necesita un agente de publicación/suscripción para distribuir mensajes a varios suscriptores (por
ejemplo para entregar mensajes a otros dispositivos y al motor de reglas), debe seguir utilizando el
agente de mensajes de AWS IoT para gestionar la distribución de los mensajes. Solo tiene que publicar
sus mensajes en temas que no sean temas de Basic Ingest.
Uso de Basic Ingest

Asegúrese de que su dispositivo o su aplicación utiliza una política (p. 152) que disponga de permisos
de publicación en $aws/rules/*. También puede especificar permiso para reglas individuales en la
319
Referencia de la SQL de AWS IoT
política con $aws/rules/rule-name/*. De lo contrario, los dispositivos y las aplicaciones podrán seguir
utilizando las conexiones existentes con AWS IoT Core.
Cuando el mensaje llega al motor de reglas, no existe diferencia alguna en la ejecución o en la gestión de
los errores entre reglas desencadenadas desde Basic Ingest y las desencadenadas a través suscripciones
al agente de mensajes.
Puede, por supuesto, crear reglas para usarlas con Basic Ingest. Tenga en cuenta lo siguiente:
• El prefijo inicial de un tema de Basic Ingest ($aws/rules/rule-name) no está disponible a la función

topic(Decimal) (p. 370).
• Si define una regla que se desencadena solo con Basic Ingest, la cláusula FROM es opcional en el
campo sql de la definición rule. Seguirá siendo necesaria si la regla también se desencadena a
través de otros mensajes que deben enviarse por medio del agente de mensajes (por ejemplo, porque
esos otros mensajes deban distribuirse a varios suscriptores). Para obtener más información, consulte
Referencia de la SQL de AWS IoT (p. 320).
• Los primeros tres niveles del tema de Basic Ingest ($aws/rules/rule-name) no se cuentan en cuanto
al límite de longitud de ocho segmentos o en cuanto al límite de caracteres total de 256 de un tema. De
lo contrario, se aplican las mismas restricciones que se documentan en Límites de AWS IoT.
• Si se recibe un mensaje con un tema de Basic Ingest que especifica una regla no activa o una regla
que no existe, se crea un registro del error en un registro de Amazon CloudWatch que le ayudará con
la tarea de depuración. Para obtener más información, consulte Entradas del registro del motor de
reglas (p. 246). Se muestra una métrica RuleNotFound, en la cual podrá crear alarmas. Para obtener
más información, consulte Métricas de la regla en Métricas de reglas (p. 231).
• Seguirá pudiendo publicar con QoS 1 en temas de Basic Ingest. Recibirá PUBACK después de
que el mensaje se entregue correctamente al motor de reglas. Recibir PUBACK no significa que las
acciones asociadas a la regla se hayan realizado correctamente. Puede configurar una acción de error
para gestionar los errores durante el proceso de ejecución. Consulte Control de errores (acción de
error) (p. 315).
Referencia de la SQL de AWS IoT

En AWS IoT, las reglas se definen utilizando una sintaxis similar a SQL. Las instrucciones SQL se
componen de tres tipos de cláusulas:
SELECT
Obligatorio. Extrae información de la carga de mensaje de entrada y realiza las transformaciones.
La cláusula SELECT admite Tipos de datos (p. 325), Operadores (p. 328), Funciones (p. 334),
Literales (p. 372), Instrucciones case (p. 372), Extensiones JSON (p. 373), Plantillas de
sustitución (p. 373) y Consultas de objetos anidados (p. 374).
FROM
El filtro de temas de mensajes de MQTT. La regla se activa para cada mensaje enviado a un tema de
MQTT que coincide con el filtro especificado aquí. Obligatorio para reglas que se activan mediante
mensajes que pasan por el agente de mensajes. Opcional para reglas que solo se activan mediante la
característica Basic Ingest (p. 319).
WHERE
Opcional. Agrega lógica condicional que determina si se llevan a cabo las acciones especificadas por
una regla.
La cláusula WHERE admite Tipos de datos (p. 325), Operadores (p. 328), Funciones (p. 334),
320
Cláusula SELECT
Un ejemplo de instrucción SQL tiene este aspecto:
SELECT color AS rgb FROM 'a/b' WHERE temperature > 50
Un mensaje MQTT de ejemplo (también denominado carga de entrada) tiene este aspecto:
{
"color":"red",
"temperature":100
}
Si este mensaje se publica en el tema 'a/b', la regla se activa y se evalúa la instrucción SQL. La
instrucción SQL extrae el valor de la propiedad color si la propiedad "temperature" es superior a 50.
La cláusula WHERE especifica la condición temperature > 50. La palabra clave AS cambia el nombre
de la propiedad "color" a "rgb". El resultado (también denominado carga de salida) tiene este aspecto:
{
"rgb":"red"
}
Estos datos se reenvían después a la acción de la regla, que envía los datos para seguirlos procesando.
Para obtener más información sobre las acciones de las reglas, consulte Acciones de reglas de AWS
IoT (p. 292).
Cláusula SELECT
La cláusula SELECT de AWS IoT es básicamente la misma que la cláusula SELECT ANSI SQL con
algunas diferencias menores.
La cláusula SELECT admite Tipos de datos (p. 325), Operadores (p. 328), Funciones (p. 334),
Puede utilizar la cláusula SELECT para extraer información de los mensajes MQTT de entrada. También
puede utilizar SELECT * para recuperar toda la carga del mensaje de entrada. Por ejemplo:
Incoming payload published on topic 'a/b': {"color":"red", "temperature":50}

SQL statement: SELECT * FROM 'a/b'
Outgoing payload: {"color":"red", "temperature":50}
Si la carga es un objeto JSON, puede hacer referencia a claves en el objeto. La carga de salida contiene el
par clave-valor. Por ejemplo:

SQL statement: SELECT color FROM 'a/b'
Outgoing payload: {"color":"red"}
Puede utilizar la palabra clave AS para cambiar el nombre de las claves. Por ejemplo:
Incoming payload published on topic 'a/b':{"color":"red", "temperature":50}

SQL:SELECT color AS my_color FROM 'a/b'
Outgoing payload: {"my_color":"red"}
Puede seleccionar varios elementos separándolos con una coma. Por ejemplo:
321
Cláusula SELECT
SQL: SELECT color as my_color, temperature as fahrenheit FROM 'a/b'

Outgoing payload: {"my_color":"red","fahrenheit":50}
Puede seleccionar varios elementos incluido '*' para agregar elementos a la carga de entrada. Por ejemplo:

SQL: SELECT *, 15 as speed FROM 'a/b'
Outgoing payload: {"color":"red", "temperature":50, "speed":15}
Puede utilizar la palabra clave "VALUE" para generar cargas de salida que no sean objetos JSON. Con la
versión 2015-10-08 de SQL, solo se puede seleccionar un elemento. Con la versión SQL 2016-03-23 o
posterior, también puede seleccionar una matriz para generar como objeto de nivel superior.
Example

SQL: SELECT VALUE color FROM 'a/b'
Outgoing payload: "red"
Puede utilizar la sintaxis '.' para explorar objetos JSON anidados en la carga de entrada. Por ejemplo:
Incoming payload published on topic 'a/b': {"color":{"red":255,"green":0,"blue":0},

"temperature":50}
SQL: SELECT color.red as red_value FROM 'a/b'
Outgoing payload: {"red_value":255}
Puede utilizar funciones (consulte Funciones (p. 334)) para transformar la carga de entrada. Puede
utilizar paréntesis para realizar agrupaciones. Por ejemplo:

SQL: SELECT (temperature – 32) * 5 / 9 AS celsius, upper(color) as my_color FROM 'a/b'
Outgoing payload: {"celsius":10,"my_color":"RED"}
Uso de las cargas binarias

Cuando la carga del mensaje deba tratarse como datos binarios sin procesar, (en lugar de como un objeto
JSON, puede utilizar el operador * para hacer referencia a ella en una cláusula SELECT. Esto funciona
para cargas de trabajo que no sean de JSON con algunas acciones de regla, como la acción S3.
Si desea utilizar * para hacer referencia a la carga del mensaje como datos binarios sin procesar, debe
seguir estas reglas:
1. La instrucción SQL y las plantillas no deben hacer referencia a nombres JSON, salvo a *.
2. La instrucción SELECT debe incluir * como único elemento, o debe contener solo funciones, por
ejemplo:
SELECT * FROM 'a/b'
SELECT encode(*, 'base64') AS data, timestamp() AS ts FROM 'a/b'
Para las acciones de regla que no admiten la entrada de carga útil binaria, como la acción de Lambda,
debe decodificar las cargas útiles binarias. La acción de la regla de Lambda puede recibir datos binarios si
está codificado en base64 y en una carga JSON. Puede hacer esto cambiando la regla a:
322
Cláusula FROM
SELECT encode(*, 'base64') AS data FROM 'my_topic'
Ejemplos de carga binaria

Puede utilizar la siguiente cláusula SELECT con cargas binarias, ya que no hace referencia a nombres
JSON.
SELECT * FROM 'a/b'
No puede utilizar la siguiente cláusula SELECT con cargas binarias porque hace referencia a
device_type en la cláusula WHERE.
SELECT * FROM 'a/b' WHERE device_type = 'thermostat'
No puede utilizar la cláusula SELECT siguiente con cargas binarias porque infringe la regla n.º 2.
SELECT *, timestamp() AS timestamp FROM 'a/b'
Puede utilizar la siguiente cláusula SELECT con cargas binarias porque cumple con la regla n.º 1 o la regla
n.º 2.
SELECT * FROM 'a/b' WHERE timestamp() % 12 = 0
No puede utilizar la siguiente regla de AWS IoT con cargas binarias porque infringe la regla n.º 1.
{
"sql": "SELECT * FROM 'a/b'"
"actions": [{
"republish": {
"topic":"device/${device_id}"
}
}]
}
Cláusula FROM
La cláusula FROM suscribe a su regla a un tema o un filtro de temas. Debe incluir el tema o el filtro de
temas entre comillas simples ('). La regla se activa para cada mensaje enviado a un tema de MQTT que
coincide con el filtro de temas especificado aquí. Un filtro de temas le permite suscribirse a un grupo de
temas similares.
Ejemplo:
Carga de entrada publicada en el tema 'a/b': {temperature: 50}
Carga de entrada publicada en el tema 'a/c': {temperature: 50}
SQL: "SELECT temperature AS t FROM 'a/b'".
La regla se suscribe a 'a/b', por lo que la carga de entrada se pasa a la regla. La carga de salida, que
se pasa a las acciones de regla, es: {t: 50}. La regla no está suscrita a 'a/c', por lo que la regla no se
activa para el mensaje publicado en 'a/c'.
Ejemplo de comodín #:
323
Cláusula WHERE
Puede utilizar el carácter comodín '#' (multinivel) para buscar coincidencias con uno o varios elementos de
ruta en particular:
Carga de entrada publicada en el tema 'a/b': {temperature: 50}.
Carga de entrada publicada en el tema 'a/c': {temperature: 60}.
Carga de entrada publicada en el tema 'a/e/f': {temperature: 70}.
Carga de entrada publicada en el tema 'b/x': {temperature: 80}.
SQL: "SELECT temperature AS t FROM 'a/#'".
La regla está suscrita a todos los temas que empiecen por 'a', por lo que se ejecutará tres veces y
enviará cargas de salida de {t: 50} (para a/b), {t: 60} (para a/c) y {t: 70} (para a/e/f) a sus
acciones. No está suscrita a 'b/x', por lo que la regla no se activa para el mensaje {temperature:
80}.
Ejemplo de comodín +:
Puede utilizar el carácter comodín '+' (nivel único) para buscar coincidencias con cualquier elemento de
ruta en particular:
Carga de entrada publicada en el tema 'a/b': {temperature: 50}.
Carga de entrada publicada en el tema 'a/c': {temperature: 60}.
Carga de entrada publicada en el tema 'a/e/f': {temperature: 70}.
Carga de entrada publicada en el tema 'b/x': {temperature: 80}.
SQL: "SELECT temperature AS t FROM 'a/+'".
La regla está suscrita a todos los temas que tengan dos elementos de ruta donde el primer elemento
sea 'a'. La regla se ejecuta para los mensajes enviados a 'a/b' y 'a/c', pero no para los mensajes
enviados a 'a/e/f' ni 'b/x'.
Cláusula WHERE
La cláusula WHERE determina si se llevan a cabo las acciones especificadas por una regla. Si la cláusula
WHERE se evalúa en true, se llevan a cabo las acciones de la regla. De lo contrario, las acciones de la
regla no se llevan a cabo.
La cláusula WHERE admite Tipos de datos (p. 325), Operadores (p. 328), Funciones (p. 334),
Ejemplo:
Carga de entrada publicada en a/b: {"color":"red", "temperature":40}.
SQL: SELECT color AS my_color FROM 'a/b' WHERE temperature > 50 AND color <>
'red'.
En este caso, la regla se activa, pero las acciones especificadas por la regla no se llevarán a cabo. No
habrá carga de salida.
Puede utilizar funciones y operadores en la cláusula WHERE. Sin embargo, no puede hacer referencia
a ningún alias creado con la palabra clave AS en la cláusula SELECT. La cláusula WHERE se evalúa en
primer lugar para determinar si SELECT debe evaluarse.
324
Tipos de datos
Tipos de datos
El motor de reglas de AWS IoT admite todos los tipos de datos JSON.
Tipos de datos admitidos

Tipo Significado
Int Un valor Int discreto de 34 dígitos como máximo.
Decimal Un valor Decimal con una precisión de 34 dígitos,

con una magnitud no nula mínima de 1E-999 y una
magnitud máxima de 9.999... E999.
Note
Algunas funciones devuelven valores

Decimal con doble precisión (en lugar de
una precisión de 34 dígitos).
Boolean True o bien False.
String Una cadena UTF-8.
Array Una serie de valores que no han de tener

obligatoriamente el mismo tipo.
Object Un valor JSON compuesto de una clave y un valor.

Las claves deben ser cadenas. Los valores pueden
ser de cualquier tipo.
Null Valor Null, tal como lo define JSON. Es un

valor real que representa la ausencia de valor.
El usuario puede crear explícitamente un valor
Null especificando la palabra clave Null en la
instrucción SQL. Por ejemplo: "SELECT NULL AS
n FROM 'a/b'"
Undefined No es un valor. No se representa explícitamente en

JSON, salvo que se omita el valor. Por ejemplo, en
el objeto {"foo": null}, la clave "foo" devuelve
NULL, pero la clave "bar" devuelve Undefined.
Internamente, el lenguaje SQL trata a Undefined
como un valor, pero este no se puede representar
en JSON, por lo que cuando se serializa en JSON,
los resultados son Undefined.
{"foo":null, "bar":undefined}
se serializa en JSON como:
{"foo":null}
Del mismo modo, Undefined se convierte en una

cadena vacía cuando se serializa por sí mismo.
Las funciones a las que se llama con argumentos
no válidos (por ejemplo, tipos erróneos, número de
argumentos erróneo, etc.) devuelven Undefined.
325
Tipos de datos
Conversiones
En la tabla siguiente se muestra una lista de los resultados que se producen cuando un valor de un tipo se
convierte en otro tipo (cuando se da un valor de tipo incorrecto a una función). Por ejemplo, si a la función
de valor absoluto "abs" (que espera un valor Int o Decimal) se le da un valor String, esta función
intentará convertir el valor String en un valor Decimal, de acuerdo con estas reglas. En este caso, 'abs
("-5.123")' se trata como 'abs(-5.123)'.
Note
No hay ningún intento de conversión en Array, Object, Null o Undefined.
En valor decimal
Tipo de argumento Resultado
Int Valor Decimal sin separador decimal.
Decimal El valor de origen.
Boolean Undefined. (Puede utilizar de forma explícita la

función cast para transformar true = 1.0, false =
0.0).
String El motor SQL intentará analizar la cadena como

Decimal. AWS IoT intenta analizar las cadenas
que coincidan con la expresión regular:^-?\d
+(\.\d+)?((?i)E-?\d+)?$. "0", "-1.2", "5E-12"
son ejemplos de cadenas que se convierten
automáticamente en valores de tipo Decimal.
Matriz Undefined.
Objeto Undefined.
Null Null.
Sin definir Undefined.
En valor entero
Int El valor de origen.
Decimal El valor de origen redondeado al valor Int más

cercano.
Boolean Undefined. (Puede utilizar de forma explícita la

función cast para transformar true = 1.0, false =
0.0).
String El motor SQL intentará analizar la cadena como

Decimal. AWS IoT intenta analizar las cadenas
que coincidan con la expresión regular:^-?\d
+(\.\d+)?((?i)E-?\d+)?$. "0", "-1.2", "5E-12"
son ejemplos de cadenas que se convierten
326
Tipos de datos

AWS IoT intenta convertir String en un valor
Decimal y, a continuación, eliminar los decimales
del valor Decimal para obtener un valor Int.
Matriz Undefined.
Objeto Undefined.
Null Null.
En valor booleano
Int Undefined. (Puede utilizar explícitamente

la función cast para transformar 0 = False,
any_nonzero_value = True).
Decimal Undefined. (Puede utilizar explícitamente la

función de conversión para transformar 0 = False,
any_nonzero_value = True).
Boolean El valor original.
String "true"= True y "false" = False (no distingue entre

mayúsculas y minúsculas). Otros valores de string
son Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
En cadena
Int Una representación de cadena del valor Int en

notación estándar.
Decimal Una cadena que representa el valor Decimal,

posiblemente en notación científica.
Boolean "true" o "false". Todos en minúscula.
String El valor original.
Matriz El valor Array serializado en formato JSON. La

cadena obtenida es una lista separada por comas,
entre corchetes. Los valores de tipo String se
indican entre comillas. No así los valores de tipo
Decimal, Int, Boolean y Null.
327
Operadores
Objeto El objeto serializado al formato JSON. La cadena

obtenida es una lista separada por comas de pares
clave-valor que comienza y termina con llaves. Los
valores de tipo String se indican entre comillas.
No así los valores de tipo Decimal, Int, Boolean
y Null.
Null Undefined.
Sin definir Sin definir.
Operadores
Los operadores siguientes se pueden utilizar en las cláusulas SELECT y WHERE.
Operador AND
Devuelve un resultado Boolean. Realiza una operación AND lógica. Devuelve el valor true si los
operandos izquierdo y derecho son true. De lo contrario, devuelve el valor false. Se necesitan operandos
de tipo Boolean u operandos de cadena "true" o "false" que no distingan entre mayúsculas y minúsculas.
Sintaxis: expression AND expression.
Operador AND
Operando Operando derecho Salida

izquierdo
Boolean Boolean Boolean. True si ambos operandos son true. De lo contrario,

devuelve false.
String/Boolean String/Boolean Si todas las cadenas son "true" o "false" (no se distingue entre
mayúsculas y minúsculas), se convierten en valores de tipo
Boolean y se procesan normalmente como boolean AND
boolean.
Otro valor Otro valor Undefined.
Operador OR
Devuelve un resultado Boolean. Realiza una operación OR lógica. Devuelve el valor true si el operando
izquierdo o el operando derecho es true. De lo contrario, devuelve el valor false. Se necesitan operandos
de tipo Boolean u operandos de cadena "true" o "false" que no distingan entre mayúsculas y minúsculas.
Sintaxis: expression OR expression.
Operador OR

izquierdo
Boolean Boolean Boolean. True si uno de los operandos es true. De lo

contrario, devuelve false.
328
Operadores

izquierdo
String/Boolean String/Boolean Si todas las cadenas son "true" o "false" (no se distingue
entre mayúsculas y minúsculas), se convierten en valores
booleanos y se procesan normalmente como boolean OR
boolean.
Operador NOT
Devuelve un resultado Boolean. Realiza una operación NOT lógica. Devuelve true si el operado es false.
De lo contrario, devuelve true. Se necesita un operando Boolean o un operando de cadena "true" o "false"
que no distinga entre mayúsculas y minúsculas.
Sintaxis: NOT expression.
Operador NOT
Operando Salida
Boolean Boolean. True si el operando es false. De lo

contrario, devuelve true.
String Si la cadena es "true" o "false" (no distingue entre

mayúsculas y minúsculas), se convierte en el valor
booleano correspondiente y se devuelve el valor
opuesto.
Otro valor Undefined.
Operador >
Devuelve un resultado Boolean. Devuelve el valor true si el operando izquierdo es superior al operando
derecho. Los dos operandos se convierten en un valor Decimal y, a continuación, se comparan.
Sintaxis: expression > expression.
> operador

izquierdo
Int/Decimal Int/Decimal Boolean. Devuelve el valor true si el operando izquierdo es

superior al operando derecho. De lo contrario, devuelve false.
String/Int/ String/Int/ Si todas las cadenas se pueden convertir en un valor

Decimal Decimal Decimal y, a continuación, en un valor Boolean. Devuelve
el valor true si el operando izquierdo es superior al operando
derecho. De lo contrario, devuelve false.
Otro valor Undefined. Undefined.
329
Operadores
Operador >=
Devuelve un resultado Boolean. Devuelve el valor true si el operando izquierdo es superior o igual al
operando derecho. Los dos operandos se convierten en un valor Decimal y, a continuación, se comparan.
Sintaxis: expression >= expression.
>= operador

izquierdo
Int/Decimal Int/Decimal Boolean. Devuelve el valor true si el operando izquierdo

es superior o igual al operando derecho. De lo contrario,
devuelve false.

el valor true si el operando izquierdo es superior o igual al
operando derecho. De lo contrario, devuelve false.
Otro valor Undefined. Undefined.
Operador <
Devuelve un resultado Boolean. Devuelve el valor true si el operando izquierdo es inferior al operando
derecho. Los dos operandos se convierten en un valor Decimal y, a continuación, se comparan.
Sintaxis: expression < expression.
Operador <

izquierdo

inferior al operando derecho. De lo contrario, devuelve false.

el valor true si el operando izquierdo es inferior al operando
Otro valor Undefined Undefined
Operador <=
Devuelve un resultado Boolean. Devuelve el valor true si el operando izquierdo es inferior o igual al
operando derecho. Los dos operandos se convierten en un valor Decimal y, a continuación, se comparan.
Sintaxis: expression <= expression.
330
Operadores
Operador <=

izquierdo

inferior o igual al operando derecho. De lo contrario, devuelve
false.

el valor true si el operando izquierdo es inferior o igual al
operando derecho. De lo contrario, devuelve false.
Otro valor Undefined Undefined
Operador <>
Devuelve un resultado Boolean. Devuelve el valor true si los operandos izquierdo y derecho no son
iguales. De lo contrario, devuelve el valor false.
Sintaxis: expression <> expression.
Operador <>

izquierdo
Int Int True si el operando izquierdo no es igual al operando

Decimal Decimal True si el operando izquierdo no es igual al operando

derecho. De lo contrario, devuelve false. Int se convierte en
un valor Decimal antes de la comparación.
String String True si el operando izquierdo no es igual al operando

Matriz Matriz True si los elementos de cada operando no son iguales y no

están en el mismo orden. De lo contrario, devuelve false.
Objeto Objeto True si las claves y los valores de cada operando no son
iguales. De lo contrario, devuelve false. El orden de las claves
y los valores no tiene importancia.
Null Null False.
Cualquier valor Undefined Sin definir.
Undefined Cualquier valor Sin definir.
Tipo no Tipo no True.

coincidente coincidente
Operador =
Devuelve un resultado Boolean. Devuelve el valor true si los operandos izquierdo y derecho son iguales.
De lo contrario, devuelve el valor false.
331
Operadores
Sintaxis: expression = expression.
Operador =

izquierdo
Int Int True si el operando izquierdo es igual al operando derecho.

De lo contrario, devuelve false.
Decimal Decimal True si el operando izquierdo es igual al operando derecho.

De lo contrario, devuelve false. Int se convierte en un valor
Decimal antes de la comparación.
String String True si el operando izquierdo es igual al operando derecho.

De lo contrario, devuelve false.
Matriz Matriz True si los elementos de cada operando son iguales y están
en el mismo orden. De lo contrario, devuelve false.
Objeto Objeto True si las claves y los valores de cada operando son iguales.
De lo contrario, devuelve false. El orden de las claves y los
valores no tiene importancia.
Cualquier valor Undefined Undefined.
Undefined Cualquier valor Undefined.
Tipo no Tipo no False.

coincidente coincidente
Operador +
El símbolo "+" es un operador sobrecargado. Se puede utilizar para la concatenación o la adición de
cadenas.
Sintaxis: expression + expression.
Operador +

izquierdo
String Cualquier valor Convierte el operando derecho en una cadena que concatena
al final del operando izquierdo.
Cualquier valor String Convierte el operando izquierdo en una cadena y concatena

el operando derecho al final del operando izquierdo
convertido.
Int Int Valor Int. Agrega ambos operandos.
Int/Decimal Int/Decimal Valor Decimal. Agrega ambos operandos.
332
Operadores
Operador -
Resta el operando derecho del operando izquierdo.
Sintaxis: expression - expression.
Operador -

izquierdo
Int Int Valor Int. Resta el operando derecho del operando

izquierdo.
Int/Decimal Int/Decimal Valor Decimal. Resta el operando derecho del operando

izquierdo.
String/Int/ String/Int/ Si todas las cadenas se convierten en decimales

Decimal Decimal correctamente, se devuelve un valor Decimal. Resta el
operando derecho del operando izquierdo. De lo contrario,
devuelve Undefined.
Operador *
Multiplica el operando izquierdo por el operando derecho.
Sintaxis: expression * expression.
Operador *

izquierdo
Int Int Valor Int. Multiplica el operando izquierdo por el operando

derecho.
Int/Decimal Int/Decimal Valor Decimal. Multiplica el operando izquierdo por el

operando derecho.

Decimal Decimal correctamente, se devuelve un valor Decimal. Multiplica el
operando izquierdo por el operando derecho. De lo contrario,
devuelve Undefined.
Operador /
Divide el operando izquierdo por el operando derecho.
Sintaxis: expression / expression.
333
Funciones
Operador /

izquierdo
Int Int Valor Int. Divide el operando izquierdo por el operando

derecho.
Int/Decimal Int/Decimal Valor Decimal. Divide el operando izquierdo por el operando

derecho.

Decimal Decimal correctamente, se devuelve un valor Decimal. Divide el
operando izquierdo por el operando derecho. De lo contrario,
devuelve Undefined.
Operador %
Devuelve el resto de la división del operando izquierdo por el operando derecho.
Sintaxis: expression % expression.
Operador %

izquierdo
Int Int Valor Int. Devuelve el resto de la división del operando

izquierdo por el operando derecho.

Decimal Decimal correctamente, se devuelve un valor Decimal. Devuelve el
resto de la división del operando izquierdo por el operando
derecho. De lo contrario, Undefined.
Funciones
Puede utilizar las funciones integradas siguientes en las cláusulas SELECT o WHERE de sus expresiones
SQL.
abs(Decimal)
Devuelve el valor absoluto de un número. Es compatible con la versión 2015-10-08 de SQL y versiones
posteriores.
Ejemplo: abs(-5) devuelve 5.
Int Int, el valor absoluto del argumento.
334
Funciones
Decimal Decimal, el valor absoluto del argumento.
Boolean Undefined.
String Decimal. El resultado es el valor absoluto del argumento.

Si la cadena no se puede convertir, el resultado es
Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
Accountid()
Devuelve el ID de la cuenta que posee esta regla como un valor de tipo String. Es compatible con la
versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo:
accountid() = "123456789012"
acos(Decimal)
Devuelve el coseno inverso de un número en radianes. Los argumentos Decimal se redondean con doble
precisión antes de la aplicación de la función. Es compatible con la versión 2015-10-08 de SQL y versiones
posteriores.
Ejemplo: acos(0) = 1.5707963267948966
Int Decimal (con doble precisión), el coseno inverso del

argumento. Se devuelven resultados imaginarios como
Undefined.
Decimal Decimal (con doble precisión), el coseno inverso del

Undefined.
Boolean Undefined.
String Decimal, el coseno inverso del argumento. Si la cadena

no se puede convertir, el resultado es Undefined. Se
devuelven resultados imaginarios como Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
335
Funciones
asin(Decimal)
Devuelve el seno inverso de un número en radianes. Los argumentos Decimal se redondean con doble
posteriores.
Ejemplo: asin(0) = 0.0
Int Decimal (con doble precisión), el seno inverso del

Undefined.
Decimal Decimal (con doble precisión), el seno inverso del

Undefined.
Boolean Undefined.
String Decimal (con doble precisión), el seno inverso del

argumento. Si la cadena no se puede convertir, el
resultado es Undefined. Se devuelven resultados
imaginarios como Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
atan(Decimal)
Devuelve la tangente inversa de un número en radianes. Los argumentos Decimal se redondean con
doble precisión antes de la aplicación de la función. Es compatible con la versión 2015-10-08 de SQL y
versiones posteriores.
Ejemplo: atan(0) = 0.0
Int Decimal (con doble precisión), la tangente inversa del

Undefined.
Decimal Decimal (con doble precisión), la tangente inversa del

Undefined.
Boolean Undefined.
String Decimal, la tangente inversa del argumento. Si la cadena

no se puede convertir, el resultado es Undefined. Se
devuelven resultados imaginarios como Undefined.
336
Funciones
Matriz Undefined.
Objeto Undefined.
Null Undefined.
atan2(Decimal, decimal)
Devuelve el ángulo, en radianes, entre el eje x positivo y el punto (x, y) definido en los dos argumentos. El
ángulo es positivo para los ángulos en sentido contrario a las agujas del reloj (plano medio superior y > 0)
y es negativo para los ángulos que siguen el sentido de las agujas del reloj (plano medio inferior y < 0). Los
argumentos Decimal se redondean con doble precisión antes de aplicar la función. Es compatible con la
Ejemplo: atan2(1, 0) = 1.5707963267948966
Tipo de argumento Tipo de argumento Resultado
Int/Decimal Int/Decimal Decimal (con doble p

punto (x, y) especifica
Int/Decimal/String Int/Decimal/String Decimal, la tangente

cadena no se puede c
aws_lambda(functionArn, inputJson)
Llama a la función de Lambda especificada que pasa inputJson a la función de Lambda y devuelve el
JSON generado por la función de Lambda.
Argumentos
Argumento Descripción
functionArn El ARN de la función de Lambda a la que se llamará. La función de

Lambda debe devolver datos JSON.
inputJson La entrada de JSON trasladada a la función de Lambda.
Debe conceder a AWS IoT permisos de lambda:InvokeFunction para invocar la función de

Lambda especificada. En el siguiente ejemplo, se muestra cómo se puede conceder el permiso
lambda:InvokeFunction utilizando AWS CLI:
aws lambda add-permission --function-name "function_name"

--region "region"
--principal iot.amazonaws.com
--source-arn arn:aws:iot:us-east-1:account_id:rule/rule_name
--source-account "account_id"
--statement-id "unique_id"
--action "lambda:InvokeFunction"
337
Funciones
A continuación, se indican los argumentos del comando add-permission:
--function-name
Nombre de la función de Lambda cuya política de recursos está actualizando mediante la adición de
un nuevo permiso.
--region
Región de AWS de la cuenta.

--principal
La entidad principal que obtiene el permiso. Debe ser iot.amazonaws.com para que AWS IoT
pueda llamar a una función de Lambda.
--source-arn
El ARN de la regla. Puede utilizar el comando de la CLI get-topic-rule para obtener el ARN de una
regla.
--source-account
Cuenta de AWS donde está definida la regla.

--statement-id
Un identificador de instrucción único.

--action
La acción Lambda que desea permitir en esta instrucción. Para permitir que AWS IoT invoque una
función de Lambda, especifique lambda:InvokeFunction.
Note
Si agrega un permiso para una entidad de seguridad de AWS IoT sin proporcionar el ARN
de origen, cualquier cuenta de AWS que cree una regla con la acción de Lambda podrá
desencadenar reglas para invocar la función Lambda desde AWS IoT. Para obtener más
información, consulte Lambda Permission Model.
Dada una carga de mensaje JSON como:
{
"attribute1": 21,
"attribute2": "value"
}
La función aws_lambda se puede utilizar para llamar a funciones de Lambda de la siguiente manera:
SELECT
aws_lambda("arn:aws:lambda:us-east-1:account_id:function:lambda_function",
{"payload":attribute1}) as output FROM 'a/b'
Si desea pasar la carga del mensaje MQTT completa, puede especificar la carga JSON mediante '*'. Por
ejemplo:
SELECT
aws_lambda("arn:aws:lambda:us-east-1:account_id:function:lambda_function", *) as output
FROM 'a/b'
338
Funciones
payload.inner.element selecciona datos de un mensaje publicado en el tema 'a/b'.
some.value selecciona datos de la salida generada por la función de Lambda.

Note
El motor de reglas limita la duración de la ejecución de las funciones de Lambda. Las llamadas a
funciones de Lambda desde las reglas deben completarse en 2000 milisegundos.
bitand(Int, int)
Ejecuta una operación AND bit a bit en las representaciones de bits de los dos argumentos Int(-
convertidos). Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: bitand(13, 5) = 5
Int Int Int, una operación A
Int/Decimal Int/Decimal Int, una operación A

Todos los números qu
al valor Int inferior m
argumentos no se pue
resultado es Undefin
Int/Decimal/String Int/Decimal/String Int, una operación A

Todas las cadenas se
redondean al valor In
produce un error en la
Undefined.
bitor(Int, int)
Realiza una operación OR bit a bit de las representaciones de bit de los dos argumentos. Es compatible
con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: bitor(8, 5) = 13
Int Int Int, la operación OR
Int/Decimal Int/Decimal Int, la operación OR

Todos los números qu
al valor Int inferior m
en la conversión, el re
Int/Decimal/String Int/Decimal/String Int, la operación OR

Todas las cadenas se
redondean al valor In
produce un error en la
Undefined.
339
Funciones
bitxor(Int, int)
Ejecuta una operación XOR bit a bit en las representaciones de bits de los dos argumentos Int(-
convertidos). Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo:bitor(13, 5) = 8
Int Int Int, una operación X
Int/Decimal Int/Decimal Int, una operación X

Los números que no s
inferior más cercano.
Int/Decimal/String Int/Decimal/String Int, una operación X

Las cadenas se convi
al valor Int más cerc
conversión, el resultad
bitnot(Int)
Ejecuta una operación NOT bit a bit en las representaciones de bits del argumento Int (convertido). Es
compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: bitnot(13) = 2
Int Int, una operación NOT bit a bit del argumento.
Decimal Int, una operación NOT bit a bit del argumento. El valor
Decimal se redondea al valor Int inferior más cercano.
String Int, una operación NOT bit a bit del argumento. Las
cadenas se convierten en decimales y se redondean al
valor Int inferior más cercano. Si se produce un error en
la conversión, el resultado obtenido es Undefined.
Otro valor Otro valor.
Cast()
Convierte un valor de un tipo de datos a otro tipo. Cast se comporta básicamente como las conversiones
estándar, salvo que puede convertir números en valores booleanos o viceversa. Si AWS IoT no puede
determinar cómo convertir un tipo en otro, el resultado es Undefined. Es compatible con la versión
2015-10-08 de SQL y versiones posteriores. Formato: cast(valor as tipo).
Ejemplo:
cast(true as Decimal) = 1.0
340
Funciones
Las siguientes palabras clave pueden aparecer después de "as" cuando se llama a cast:
Para las versiones 2015-10-08 y 2016-03-23 de SQL
Palabra clave Resultado
Decimal Convierte un valor en Decimal.
Bool Convierte un valor en Boolean.
Boolean Convierte un valor en Boolean.
String Convierte un valor en String.
Nvarchar Convierte un valor en String.
Text Convierte un valor en String.
Ntext Convierte un valor en String.
varchar Convierte un valor en String.
Int Convierte un valor en Int.
Entero Convierte un valor en Int.
Además, para SQL versión 2016-03-23
Palabra clave Resultado
Decimal Convierte un valor en Decimal.
Bool Convierte un valor en Boolean.
Boolean Convierte un valor en Boolean.
Reglas de conversión:
Conversión en decimal
Int Valor Decimal sin separador decimal.
Decimal El valor de origen.
Boolean true = 1.0, false = 0.0.
String Intenta analizar la cadena como un valor Decimal. AWS

IoT intenta analizar las cadenas que coincidan con la
expresión regular: ^-?\d+(\.\d+)?((?i)E-?\d+)?$. "0", "-1.2",
"5E-12" son ejemplos de cadenas que se convierten
Matriz Undefined.
Objeto Undefined.
Null Undefined.
341
Funciones
Conversión en entero
Int El valor de origen.
Decimal El valor de origen redondeado al valor Int inferior más

cercano.
Boolean true = 1.0, false = 0.0.
String Intenta analizar la cadena como un valor Decimal. AWS

IoT intenta analizar las cadenas que coincidan con la
expresión regular: ^-?\d+(\.\d+)?((?i)E-?\d+)?$. "0", "-1.2",
"5E-12" son ejemplos de cadenas que se convierten
automáticamente en valores de tipo Decimal. AWS IoT
intenta convertir la cadena en un valor de tipo Decimal y
redondearlo al valor de tipo Int inferior más cercano.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
Conversión a valor Boolean
Int 0 = False, any_nonzero_value = True.
Decimal 0 = False, any_nonzero_value = True.
Boolean El valor de origen.
String "true" = True y "false" = False (no distingue entre

mayúsculas y minúsculas). Otros valores de cadena =
Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
342
Funciones
Conversión en cadenas
Int Una representación de cadena del valor Int, en notación

estándar.
Decimal Una cadena que representa el valor Decimal,

posiblemente en notación científica.
Boolean "true" o "false", todo en minúsculas.
String "true" = True y "false" = False (no distingue entre

mayúsculas y minúsculas). Otros valores de cadena =
Undefined.
Matriz La matriz serializada en formato JSON. La cadena

obtenida es una lista separada por comas, entre
corchetes. Los valores String se indican entre comillas.
Los valores Decimal, Int y Boolean no se indican entre
comillas.
Objeto El objeto serializado al formato JSON. La cadena JSON

es una lista separada por comas de pares clave-valor
que comienza y termina con llaves. Los valores String
se indican entre comillas. Los valores Decimal, Int,
Boolean y Null no se indican entre comillas.
Null Undefined.
ceil(Decimal)
Redondea el valor Decimal indicado al valor Int superior más cercano. Es compatible con la versión
2015-10-08 de SQL y versiones posteriores.
Ejemplos:
ceil(1.2) = 2
ceil(-1.2) = -1
Int Int, el valor del argumento.
Decimal Int, el valor de Decimal redondeado al valor de tipo Int

superior más cercano.
String Int. La cadena se convierte en un valor Decimal y se

redondea al valor de tipo Int superior más cercano. Si
la cadena no se puede convertir en un valor Decimal, el
resultado es Undefined.
343
Funciones
chr(String)
Devuelve el carácter ASCII que corresponde al argumento Int determinado. Es compatible con la versión
Ejemplos:
chr(65) = "A".
chr(49) = "1".
Int El carácter correspondiente al valor ASCII especificado. Si

el argumento no es un valor ASCII válido, el resultado es
Undefined.
Decimal El carácter correspondiente al valor ASCII especificado. El

argumento Decimal se redondea al valor Int inferior más
cercano. Si el argumento no es un valor ASCII válido, el
Boolean Undefined.
String Si el valor String puede convertirse en un valor

Decimal, se redondea al valor Int inferior más cercano.
Si el argumento no es un valor ASCII válido, el resultado
es Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
Clientid()
Devuelve el ID del cliente MQTT que envía el mensaje o n/a si el mensaje no se ha enviado por MQTT.
Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo:
clientid() = "123456789012"
Concat()
Concatena matrices o cadenas. Esta función acepta cualquier cantidad de argumentos y devuelve un valor
String o un valor Array. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplos:
concat() = Undefined.
concat(1) = "1".
concat([1, 2, 3], 4) = [1, 2, 3, 4].
344
Funciones
concat([1, 2, 3], "hello") = [1, 2, 3, "hello"]
concat("con", "cat") = "concat"
concat(1, "hello") = "1hello"
concat("he","is","man") = "heisman"
concat([1, 2, 3], "hello", [4, 5, 6]) = [1, 2, 3, "hello", 4, 5, 6]
Número de argumentos Resultado
0 Undefined.
1 El argumento se devuelve sin modificar.
2+ Si alguno de los argumentos es un valor Array, el

resultado es una matriz única que contiene todos los
argumentos. Si no hay argumentos de tipo Array y al
menos un argumento es un valor String, el resultado es
la concatenación de las representaciones de String de
todos los argumentos. Los argumentos se convierten en
cadenas mediante las conversiones estándar indicadas
arriba.
.
cos(Decimal)
Devuelve el coseno de un número en radianes. Los argumentos Decimal se redondean con doble
posteriores.
Ejemplo:
cos(0) = 1.
Int Decimal (con doble precisión), el coseno del argumento.

Se devuelven resultados imaginarios como Undefined.
Decimal Decimal (con doble precisión), el coseno del argumento.

Se devuelven resultados imaginarios como Undefined.
Boolean Undefined.
String Decimal (con doble precisión), el coseno del argumento.

Si la cadena no se puede convertir en un valor Decimal,
el resultado es Undefined. Se devuelven resultados
imaginarios como Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
345
Funciones
cosh(Decimal)
Devuelve el coseno hiperbólico de un número en radianes. Los argumentos Decimal se redondean con
doble precisión antes de la aplicación de la función. Es compatible con la versión 2015-10-08 de SQL y
Ejemplo: cosh(2.3) = 5.037220649268761.
Int Decimal (con doble precisión), el coseno hiperbólico del

Undefined.
Decimal Decimal (con doble precisión), el coseno hiperbólico del

Undefined.
Boolean Undefined.
String Decimal (con doble precisión), el coseno hiperbólico

del argumento. Si la cadena no se puede convertir en un
valor Decimal, el resultado es Undefined. Se devuelven
resultados imaginarios como Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
encode(value, encodingScheme)
Utilice la función encode para codificar la carga, que puede estar constituida por datos que no son JSON,
en su representación de cadena basada en el esquema de codificación. Es compatible con la versión SQL
2016-03-23 y versiones posteriores.
value
Cualquiera de las expresiones válidas, tal y como se define en Referencia de la SQL de AWS
IoT (p. 320). Puede especificar * para codificar toda la carga, con independencia de si está en
formato JSON o no. Si suministra una expresión, el resultado de la evaluación se convierte en una
cadena antes de codificarla.
encodingScheme
Una cadena literal que representa el esquema de codificación que desea utilizar. En la actualidad, solo
se admite 'base64'.
endswith(String, string)
Devuelve un valor Boolean que indica si el primer argumento String termina con el segundo argumento
String. Si alguno de los argumentos es Null o Undefined, el resultado es Undefined. Es compatible
346
Funciones
Ejemplo: endswith("cat","at") = true.
Tipo de argumento 1 Tipo de argumento 2 Resultado
String String True si el primer argum

argumento. De lo con
Otro valor Otro valor Ambos argumentos se

reglas de conversión e
termina en el segundo
devuelve false. Si algu
Undefined, el resulta
exp(Decimal)
Devuelve e elevado al argumento Decimal. Los argumentos Decimal se redondean con doble precisión
antes de la aplicación de la función. Es compatible con la versión 2015-10-08 de SQL y versiones
posteriores.
Ejemplo: exp(1) = e.
Int Decimal (con doble precisión), argumento potencia e.
Decimal Decimal (con doble precisión), argumento potencia e.
String Decimal (con doble precisión), argumento potencia e.

Si el valor String no se puede convertir en un valor
Decimal, el resultado es Undefined.
floor(Decimal)
Redondea a la baja el valor Decimal indicado al valor Int más cercano. Es compatible con la versión
Ejemplos:
floor(1.2) = 1
floor(-1.2) = -2
Int Int, el valor del argumento.
Decimal Int, valor Decimal redondeado a la baja al valor Int

más próximo.
String Int. La cadena se convierte en un valor Decimal y se

redondea a la baja al valor Int más cercano. Si la cadena
no se puede convertir en un valor Decimal, el resultado
es Undefined.
347
Funciones
Get
Extrae un valor de un tipo de recopilación (array, string, object). No se aplica ninguna conversión al primer
argumento. La conversión se aplica tal y como se documenta en la tabla del segundo argumento. Es
Ejemplos:
get(["a", "b", "c"], 1) = "b"
get({"a":"b"}, "a") = "b"
get("abc", 1) = "b"
Matriz Cualquier tipo (convertido en Int) El elemento en el índi

proporcionado por el s
Int). Si la conversión
es Undefined. Si el í
valor Array (negativo
Undefined.
Cadena Cualquier tipo (convertido en Int) El carácter en el índic

proporcionada por el s
un valor Int). Si la co
obtenido es Undefin
de los límites de la ca
Objeto String (no se aplica conversión) El valor almacenado e

correspondiente a la c
como segundo argum
Otro valor Cualquier valor Undefined.
get_dynamodb(tableName, partitionKeyName, partitionKeyValue,

sortKeyName, sortKeyValue, roleArn)
Recupera datos de una tabla DynamoDB. get_dynamodb() permite consultar una tabla DynamoDB
mientras se evalúa una regla. Puede filtrar o aumentar las cargas útiles de mensajes utilizando los datos
recuperados de DynamoDB. Es compatible con la versión SQL 2016-03-23 y versiones posteriores.
get_dynamodb() utiliza los parámetros siguientes:
tableName
Nombre de la tabla DynamoDB que consultar.

partitionKeyName
Nombre de la tabla de particiones. Para obtener más información, consulte .Claves de DynamoDB
348
Funciones
partitionKeyValue
Valor de la clave de partición utilizada para identificar un registro. Para obtener más información,
consulte .Claves de DynamoDB
sortKeyName
Opcional. Nombre de la clave de ordenación. Este parámetro solo es necesario si la tabla DynamoDB
consultada utiliza una clave compuesta. Para obtener más información, consulte .Claves de
DynamoDB
SortKeyValue
Opcional. Valor de la clave de ordenación. Este parámetro solo es necesario si la tabla DynamoDB
consultada utiliza una clave compuesta. Para obtener más información, consulte .Claves de
DynamoDB
roleArn
El ARN de un rol de IAM que concede acceso a la tabla de DynamoDB. El motor de reglas asume
este rol para acceder a la tabla DynamoDB en su nombre. Evite usar un rol excesivamente permisivo.
Otorgue al rol solo los permisos requeridos por la regla. A continuación se muestra un ejemplo de
política que concede acceso a una tabla DynamoDB.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "dynamodb:GetItem",
"Resource": "arn:aws:dynamodb:aws-region:account-id:table/table-name"
}
]
}}
Como ejemplo de cómo puede usar get_dynamodb(), supongamos que tiene una tabla DynamoDB que
contiene el ID de dispositivo e información de ubicación para todos los dispositivos conectados a AWS IoT.
La siguiente instrucción SELECT utiliza la función get_dynamodb() para recuperar la ubicación del ID de
dispositivo especificado:
SELECT *, get_dynamodb("InServiceDevices", "deviceId", id,

"arn:aws:iam::12345678910:role/getdynamo").location AS location FROM 'some/
topic'
Note
• Puede llamar a get_dynamodb() un máximo de una vez por instrucción SQL. Llamar a
get_dynamodb() varias veces en una sola instrucción SQL hace que la regla termine sin
invocar ninguna acción.
• Si get_dynamodb() devuelve más de 8 KB de datos, no se puede invocar la acción de la
regla.
get_thing_shadow(thingName, roleARN)
Muestra la sombra del elemento especificado. Es compatible con la versión SQL 2016-03-23 y versiones
posteriores.
thingName
String: el nombre del elemento cuya sombra desea recuperar.
349
Funciones
roleArn
String: un ARN de rol con permiso iot:GetThingShadow.
Ejemplo:
SELECT * from 'a/b'
WHERE get_thing_shadow("MyThing","arn:aws:iam::123456789012:role/
AllowsThingShadowAccess") .state.reported.alarm = 'ON'
Funciones de hash
AWS IoT ofrece las siguientes funciones de hash:
• md2
• md5
• sha1
• sha224
• sha256
• sha384
• sha512
Todas las funciones de hash esperan un argumento de cadena. El resultado es el valor con hash de dicha
cadena. Las conversiones de cadena estándar se aplican a los argumentos que no son cadenas. Todas
las funciones de hash son compatibles con la versión 2015-10-08 de SQL y con versiones posteriores.
Ejemplos:
md2("hello") = "a9046c73e00331af68917d3804f70655"
md5("hello") = "5d41402abc4b2a76b9719d911017c592"
indexof(String, string)
Devuelve el primer índice (basado en 0) del segundo argumento como subcadena del primer argumento.
Se espera que ambos argumentos sean cadenas. Los argumentos que no sean cadenas están sujetos
a las reglas de conversión estándar de cadenas. Esta función no se aplica a matrices, únicamente a
cadenas. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplos:
indexof("abcd", "bc") = 1
isNull()
Devuelve verdadero si el argumento es el valor Null. Es compatible con la versión 2015-10-08 de SQL y
Ejemplos:
isNull(5) = false.
isNull(Null) = true.
350
Funciones
Int false
Decimal false
Boolean false
String false
Array false
Object false
Null true
Undefined false
isUndefined()
Devuelve verdadero si el argumento tiene el valor Undefined. Es compatible con la versión SQL
2016-03-23 y versiones posteriores.
Ejemplos:
isUndefined(5) = false.
isUndefined(floor([1,2,3]))) = true.
Int false
Decimal false
Boolean false
String false
Array false
Object false
Null false
Undefined true
length(String)
Devuelve el número de caracteres de la cadena suministrada. Se aplican las reglas de conversión
estándar a los argumentos que no sean String. Es compatible con la versión 2015-10-08 de SQL y
Ejemplos:
length("hi") = 2
length(false) = 5
351
Funciones
ln(Decimal)
Devuelve el logaritmo natural del argumento. Los argumentos Decimal se redondean con doble precisión
posteriores.
Ejemplo: ln(e) = 1.
Int Decimal (con doble precisión), el log natural del

argumento.
Decimal Decimal (con doble precisión), el log natural del

argumento.
Boolean Undefined.
String Decimal (con doble precisión), el log natural del

argumento. Si la cadena no se puede convertir en un valor
Matriz Undefined.
Objeto Undefined.
Null Undefined.
log(Decimal)
Devuelve el logaritmo decimal del argumento. Los argumentos Decimal se redondean con doble precisión
posteriores.
Ejemplo: log(100) = 2.0.
Int Decimal (con doble precisión), el log de base 10 del

argumento.
Decimal Decimal (con doble precisión), el log de base 10 del

argumento.
Boolean Undefined.
String Decimal (con doble precisión), el log de base 10 del

argumento. Si el valor String no se puede convertir en
un valor Decimal, el resultado es Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
352
Funciones
lower(String)
Muestra la versión en minúsculas del valor String indicado. Los argumentos que no son cadenas se
convierten en cadenas con las reglas de conversión estándar. Es compatible con la versión 2015-10-08 de
SQL y versiones posteriores.
Ejemplos:
lower("HELLO") = "hello".
lower(["HELLO"]) = "[\"hello\"]".
lpad(String, int)
Devuelve el argumento String, rellenado en el lado izquierdo con el número de espacios especificado
por el segundo argumento. El argumento Int debe estar comprendido entre 0 y 1000. Si el valor
proporcionado se encuentra fuera de este rango válido, el argumento se establece en el valor válido más
cercano (0 o 1000). Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplos:
lpad("hello", 2) = " hello".
lpad(1, 3) = "1"
String Int String, el valor Stri

lado izquierdo con un
Int proporcionado.
String Decimal El argumento Decima

más cercano y el valo
izquierdo con el núme
String String El segundo argumento

que se redondea al va
el valor String se re
especificado en la izq
no se puede convertir
Undefined.
Otro valor Int/Decimal/String El primer valor se con

mediante las conversi
se aplica la función LP
puede convertir, el res
Cualquier valor Otro valor Undefined.
ltrim(String)
Elimina todos los espacios en blanco del principio (tabuladores y espacios) del valor String
proporcionado. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
353
Funciones
Ejemplo:
Ltrim(" h i ") = "hi ".
Int La representación String de Int con todos los espacios

en blanco del principio suprimidos.
Decimal La representación String de Decimal con todos los

espacios en blanco del principio suprimidos.
Boolean La representación String del valor booleano ("true" o

"false") con todos los espacios en blanco del principio
suprimidos.
String El argumento con todos los espacios en blanco del

principio suprimidos.
Matriz La representación String de Array (mediante las reglas

de conversión estándar) con todos los espacios en blanco
del principio suprimidos.
Objeto La representación String del objeto (mediante las reglas

de conversión estándar) con todos los espacios en blanco
del principio suprimidos.
Null Undefined.
machinelearning_predict(modelId)
Utilice la función machinelearning_predict para realizar predicciones con los datos de un mensaje
MQTT basado en un modelo Amazon Machine Learning (Amazon ML). Es compatible con la versión
2015-10-08 de SQL y versiones posteriores. Los argumentos de la función machinelearning_predict
son:
modelId
El ID del modelo en el que se ejecutará la predicción. El punto de enlace en tiempo real del modelo
debe estar activado.
roleArn
El rol de IAM que tiene una política con permisos machinelearning:Predict y

machinelearning:GetMLModel, y permite tener acceso al modelo en el que se ejecuta la
predicción.
record
Los datos que van a transmitirse a la API de previsión Amazon ML. Debe representarse como un
objeto JSON de capa única. Si el registro es un objeto JSON de varias capas, el registro se aplana
serializando sus valores. Por ejemplo, el JSON siguiente:
{ "key1": {"innerKey1": "value1"}, "key2": 0}
se convertiría en:
354
Funciones
{ "key1": "{\"innerKey1\": \"value1\"}", "key2": 0}
La función devuelve un objeto JSON con los campos siguientes:
predictedLabel
La clasificación de la entrada en función del modelo.

details
Contiene los atributos siguientes:

PredictiveModelType
El tipo de modelo. Los valores válidos son REGRESSION, BINARY, MULTICLASS.

Algoritmo
El algoritmo utilizado por Amazon ML para realizar las predicciones. El valor debe ser SGD.
predictedScores
Contiene la puntuación de clasificación bruta correspondiente a cada etiqueta.

predictedValue
El valor que Amazon ML prevé.
mod(Decimal, decimal)
Devuelve el resto de la división del primer argumento por el segundo argumento. Es igual que
remainder(Decimal, decimal) (p. 361). También puede utilizar "%" como un operador infijo para la misma
funcionalidad modulo. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: mod(8, 3) = 2.
Operando izquierdo Operando derecho Salida
Int Int Int, el primer y el seg

ejecutar la función mo
Int/Decimal Int/Decimal Decimal, el primer ar

para los que quiere ej
String/Int/Decimal String/Int/Decimal Si todas las cadenas s

función modulo se eje
nanvl(AnyValue, AnyValue)
Devuelve el primer argumento si es un Decimal válido. De lo contrario, se devuelve el segundo
argumento. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: Nanvl(8, 3) = 8.
355
Funciones
Tipo de argumento 1 Tipo de argumento 2 Salida
Sin definir Cualquier valor El segundo argumento
Null Cualquier valor El segundo argumento
Decimal (NaN) Cualquier valor El segundo argumento
Decimal (no NaN) Cualquier valor El primer argumento.
Otro valor Cualquier valor El primer argumento.
Newuuid()
Devuelve un UUID aleatorio de 16 bytes. Es compatible con la versión 2015-10-08 de SQL y versiones
posteriores.
Ejemplo: newuuid() = 123a4567-b89c-12d3-e456-789012345000
numbytes(String)
Devuelve el número de bytes de la codificación UTF-8 de la cadena proporcionada. Se aplican las reglas
de conversión estándar a los argumentos que no sean String. Es compatible con la versión 2015-10-08
de SQL y versiones posteriores.
Ejemplos:
numbytes("hi") = 2
numbytes("€") = 3
Principal()
Devuelve la entidad principal que utiliza el dispositivo para la autenticación. La entidad principal que se
devuelve depende de cómo se publicó el mensaje de activación. En la siguiente tabla se describe la
entidad principal devuelta para cada método y protocolo de publicación.
Cómo se publica el mensaje Protocolo Tipo de credenciales
Cliente MQTT MQTT Certificado de disposi
Cliente MQTT de la consola de MQTT Usuario o rol de IAM

AWS IoT
AWS CLI HTTP Usuario o rol de IAM
SDK de dispositivos de AWS IoT MQTT Certificado de disposi
SDK de dispositivos de AWS IoT MQTT a través de WebSocket Usuario o rol de IAM
En los siguientes ejemplos se muestran los distintos tipos de valores devueltos por principal:
• Huella digital del certificado X.509:

ba67293af50bf2506f5f93469686da660c7c844e7b3950bfb16813e0d31e9373
• ID de rol de IAM y nombre de sesión: ABCD1EFG3HIJK2LMNOP5:my-session-name
• devuelve un ID de usuario: ABCD1EFG3HIJK2LMNOP5
356
Funciones
parse_time(String, long, [string])

Utilice la función parse_time para aplicar un formato legible a una marca de fecha y hora. Es compatible
con la versión SQL 2016-03-23 y versiones posteriores. Los argumentos de la función parse_time son:
pattern
(String) Un patrón de fecha y hora que se ajusta al formato estándar ISO 8601. (En concreto, la
función admite formatos Joda-Time).
timestamp
(Long) La hora que se va a formatear en milisegundos a partir del formato de hora Unix. Consulte la
función Timestamp() (p. 369).
timezone
(Cadena) Opcional. La zona horaria de la fecha/hora formateada. El valor predeterminado es "UTC".

La función admite zonas horarias Joda-Time
Ejemplos:
Cuando este mensaje se publica en el tema "A/B", la carga {"ts": "1970.01.01 AD at 21:46:40
CST"} se envía al bucket de S3:
{
"ruleArn": "arn:aws:iot:us-east-2:ACCOUNT_ID:rule/RULE_NAME",
"sql": "SELECT parse_time("yyyy.MM.dd G 'at' HH:mm:ss z", 100000000, "America/
Belize" ) as ts FROM 'A/B'",
"actions": [
{
"s3": {
"roleArn": "arn:aws:iam::ACCOUNT_ID:rule:role/ROLE_NAME",
"bucketName": "BUCKET_NAME",
"key": "KEY_NAME"
}
}
],
"ruleName": "RULE_NAME"
}
}
Cuando este mensaje se publica en el tema "A/B", una carga similar a {"ts": "2017.06.09 AD at
17:19:46 UTC"} (pero con la fecha y hora actuales) se envía al bucket de S3:
{
"sql": "SELECT parse_time("yyyy.MM.dd G 'at' HH:mm:ss z", timestamp() ) as ts FROM
'A/B'",
"actions": [
{
"s3": {
"bucketName": "BUCKET_NAME",
"key": "KEY_NAME"
357
Funciones
}
}
],
}
}
parse_time() se puede usar también como una plantilla de sustitución. Por ejemplo, cuando este
mensaje se publica en el tema "A/B", la carga se envía al bucket de S3 con la clave = "2017":
{
"sql": "SELECT * FROM 'A/B'",
"actions": [
{
"s3": {
"bucketName": BUCKET_NAME,
"key": "${parse_time("yyyy", timestamp(), "UTC")}"
}
}
],
}
}
power(Decimal, decimal)
Devuelve el primer argumento elevado al segundo argumento. Los argumentos Decimal se redondean
con doble precisión antes de la aplicación de la función. Es compatible con la versión 2015-10-08 de SQL y
versiones posteriores. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: power(2, 5) = 32.0.
Tipo de argumento 1 Tipo de argumento 2 Salida
Int/Decimal Int/Decimal Un Decimal (con dob

elevado a la potencia
Int/Decimal/String Int/Decimal/String Un Decimal (con dob

elevado a la potencia
cadenas se convierten
no se convierte en un
Undefined.
Rand()
Devuelve un valor pseudoaleatorio, distribuido de forma uniforme entre 0,0 y 1,0. Es compatible con la
Ejemplo:
rand() = 0.8231909191640703
358
Funciones
regexp_matches(String, string)
Devuelve verdadero si la cadena (primer argumento) contiene una coincidencia para la expresión regular
(segundo argumento).
Ejemplo:
regexp_matches("aaaa", "a{2,}") = true.
regexp_matches("aaaa", "b") = false.
Primer argumento:
Int La representación String del valor Int.
Decimal La representación String del valor Decimal.

"false").
String El valor String.
Matriz La representación String del valor Array (mediante

reglas de conversión estándar).
Objeto La representación String del objeto (mediante reglas de

conversión estándar).
Null Undefined.
Segundo argumento:
Tiene que ser una expresión regex válida. Los tipos que no son cadenas se convierten en valores de tipo
String mediante reglas de conversión estándar. En función del tipo, es posible que la cadena obtenida
no sea una expresión regular válida. Si el argumento (convertido) no es un regex válido, el resultado es
Undefined.
regexp_replace(String, string, string)

Sustituye todos los segundos argumentos (expresiones regulares) que hay en el primer argumento
por el tercer argumento. Hace referencia a los grupos de captura con "$". Es compatible con la versión
Ejemplo:
regexp_replace("abcd", "bc", "x") = "axd".
regexp_replace("abcd", "b(.*)d", "$1") = "ac".
Primer argumento:
359
Funciones

"false").
String El valor de origen.


Null Undefined.
Segundo argumento:
no sea una expresión regular válida. Si el argumento (convertido) no es una expresión regex válida, el
Tercer argumento:
Debe ser una cadena de sustitución de regex válida. (Puede hacer referencia a grupos de capturas).
Los tipos que no son cadenas se convierten en valores de tipo String mediante reglas de conversión
estándar. Si el argumento (convertido) no es una cadena de sustitución de regex válida, el resultado es
Undefined.
regexp_substr(String, string)
Busca la primera coincidencia del segundo parámetro (regex) en el primer parámetro. Hace referencia a
los grupos de captura con "$". Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo:
regexp_substr("hihihello", "hi") = "hi"
regexp_substr("hihihello", "(hi)*") = "hihi"
Primer argumento:

"false").
String El argumento String.


360
Funciones
Null Undefined.
Segundo argumento:
no sea una expresión regular válida. Si el argumento (convertido) no es una expresión regex válida, el
Tercer argumento:
Debe ser una cadena de sustitución de regex válida. (Puede hacer referencia a grupos de capturas).
Los tipos que no son cadenas se convierten en valores de tipo String mediante reglas de conversión
estándar. Si el argumento no es una cadena de sustitución de regex válida, el resultado es Undefined.
remainder(Decimal, decimal)
Devuelve el resto de la división del primer argumento por el segundo argumento. Es igual que
mod(Decimal, decimal) (p. 355). También puede utilizar "%" como un operador infijo para la misma
funcionalidad modulo. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo: remainder(8, 3) = 2.
Operando izquierdo Operando derecho Salida
Int Int Int, el primer y el seg

ejecutar la función mo
Int/Decimal Int/Decimal Decimal, el primer ar

para los que quiere ej
String/Int/Decimal String/Int/Decimal Si todas las cadenas s

función modulo se eje
replace(String, string, string)

Reemplaza todas las instancias del segundo argumento que hay en el primer argumento por el tercer
argumento. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo:
replace("abcd", "bc", "x") = "axd".
replace("abcdabcd", "b", "x") = "afcdafcd".
Todos los argumentos
361
Funciones

"false").
String El valor de origen.


Null Undefined.
rpad(String, int)
Devuelve el argumento de cadena, rellenado en el lado derecho con el número de espacios especificado
en el segundo argumento. El argumento Int debe estar comprendido entre 0 y 1000. Si el valor
proporcionado se encuentra fuera de este rango válido, el argumento se establece en el valor válido más
cercano (0 o 1000). Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplos:
rpad("hello", 2) = "hello ".
rpad(1, 3) = "1".
String Int El
valor
String
se
rellena
en el
lado
derecho
con un
número
de
espacios
igual al
valor
Int
proporcionado.
String Decimal El
argumento
Decimal
se
redondea
al
362
Funciones

valor
Int
inferior
más
cercano
y la
cadena
se
rellena
en el
lado
derecho
con
una
serie
de
espacios
igual al
valor
Int
proporcionado.
String String El
segundo
argumento
se
convierte
en un
valor
Decimal
que se
redondea
al
valor
Int
inferior
más
cercano.
El
valor
String
se
rellena
en el
lado
derecho
con un
número
de
espacios
igual al
valor
Int.
363
Funciones
Otro valor Int/Decimal/String El

primer
valor
se
convierte
en un
valor
de tipo
String
mediante
las
conversiones
estándar
y, a
continuación,
se
aplica
la
función
rpad a
dicho
valor
String.
Si no
se
puede
convertir,
el
resultado
es
Undefined.
Cualquier valor Otro valor Undefined.
round(Decimal)
Redondea el valor Decimal indicado al valor Int más cercano. Si el valor Decimal está a la misma
distancia de dos valores Int, (por ejemplo, 0,5), el valor Decimal se redondea al valor superior. Es
Ejemplo: Round(1.2) = 1.
Round(1.5) = 2.
Round(1.7) = 2.
Round(-1.1) = -1.
Round(-1.5) = -2.
Int El argumento.
364
Funciones
Decimal El valor Decimal se redondea al valor Int inferior más

cercano.
String El valor Decimal se redondea al valor Int inferior más

cercano. Si la cadena no se puede convertir en un valor
rtrim(String)
Elimina todos los espacios en blanco del final (tabuladores y espacios) del valor String proporcionado. Es
Ejemplos:
rtrim(" h i ") = " h i"

"false").


Null Undefined.
Sin definir Undefined
sign(Decimal)
Devuelve el signo del número especificado. Cuando el signo del argumento es positivo, se devuelve 1.
Cuando el signo del argumento es negativo, se devuelve -1. Si el argumento es 0, se devuelve 0. Es
Ejemplos:
sign(-7) = -1.
sign(0) = 0.
sign(13) = 1.
Int Int, el signo del valor Int.
365
Funciones
Decimal Int, el signo del valor Decimal.
String Int, el signo del valor Decimal. La cadena se convierte

en un valor Decimal y se devuelve el signo del valor
Decimal. Si el valor String no se puede convertir en un
valor Decimal, el resultado es Undefined. Es compatible
sin(Decimal)
Devuelve el seno de un número en radianes. Los argumentos Decimal se redondean con doble precisión
posteriores.
Ejemplo: sin(0) = 0.0
Int Decimal (con doble precisión), el seno del argumento.
Decimal Decimal (con doble precisión), el seno del argumento.
Boolean Undefined.
String Decimal (con doble precisión), el seno del argumento. Si

la cadena no se puede convertir en un valor Decimal, el
Matriz Undefined.
Objeto Undefined.
Null Undefined.
Undefined Undefined.
sinh(Decimal)
Devuelve el seno hiperbólico de un número. Los valores Decimal se redondean con doble precisión antes
de la aplicación de la función. El resultado es un valor Decimal de doble precisión. Es compatible con la
Ejemplo: sinh(2.3) = 4.936961805545957
Int Decimal (con doble precisión); el seno hiperbólico del

argumento.
Decimal Decimal (con doble precisión); el seno hiperbólico del

argumento.
366
Funciones
Boolean Undefined.
String Decimal (con doble precisión); el seno hiperbólico del

Matriz Undefined.
Objeto Undefined.
Null Undefined.
substring(String, int [, int])

Espera un valor String seguido de uno o dos valores Int. Para un argumento String y un único
argumento Int, esta función devuelve la subcadena del argumento String proporcionado que proviene
del índice Int (de base 0 incluido) suministrado al final del argumento String. Para un argumento
String y dos argumentos Int, esta función devuelve la subcadena del argumento String proporcionado
que proviene del primer argumento de índice Int (de base 0 incluido) en el segundo argumento de índice
Int (de base 0 no incluido). Los índices inferiores a cero se establecen en cero. Los índices superiores a
la longitud de String se establecen en la longitud de String. Para la versión de tres argumentos, si el
primer índice es superior (o igual) al segundo índice, el resultado es el valor String vacío.
Si los argumentos proporcionados no son (String, Int) ni (String, Int, Int), se les aplican las
conversiones estándar para intentar convertirlos en los tipos adecuados. Si no es posible convertirlos, el
resultado de la función será Undefined. Es compatible con la versión 2015-10-08 de SQL y versiones
posteriores.
Ejemplos:
substring("012345", 0) = "012345".
substring("012345", 2) = "2345".
substring("012345", 2.745) = "2345".
substring(123, 2) = "3".
substring("012345", -1) = "012345".
substring(true, 1.2) = "true".
substring(false, -2.411E247) = "false".
substring("012345", 1, 3) = "12".
substring("012345", -50, 50) = "012345".
substring("012345", 3, 1) = "".
sql_version()
Devuelve la versión de SQL especificada en esta regla. Es compatible con la versión 2015-10-08 de SQL y
Ejemplo:
367
Funciones
sql_version() = "2016-03-23"
sqrt(Decimal)
Devuelve la raíz cuadrada de un número. Los argumentos Decimal se redondean con doble precisión
posteriores.
Ejemplo: sqrt(9) = 3,0.
Int La raíz cuadrada del argumento.
Decimal La raíz cuadrada del argumento.
Boolean Undefined.
String La raíz cuadrada del argumento. Si la cadena no se

puede convertir en un valor Decimal, el resultado es
Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
startswith(String, string)
Devuelve Boolean, si el primer argumento de cadena comienza con el segundo argumento de cadena.
Si alguno de los argumentos es Null o Undefined, el resultado es Undefined. Es compatible con la
Ejemplo:
startswith("ranger","ran") = true
String String Si la primera cadena c
Otro valor Otro valor Ambos argumentos se

reglas de conversión e
la primera cadena com
Si alguno de los argum
tan(Decimal)
Devuelve la tangente de un número en radianes. Los valores Decimal se redondean con doble precisión
posteriores.
368
Funciones
Ejemplo: tan(3) = -0.1425465430742778
Int Decimal (con doble precisión), la tangente del argumento.
Decimal Decimal (con doble precisión), la tangente del argumento.
Boolean Undefined.
String Decimal (con doble precisión), la tangente del argumento.

Si la cadena no se puede convertir en un valor Decimal,
el resultado es Undefined.
Matriz Undefined.
Objeto Undefined.
Null Undefined.
tanh(Decimal)
Devuelve la tangente hiperbólica de un número en radianes. Los valores Decimal se redondean con doble
posteriores.
Ejemplo: tanh(2.3) = 0.9800963962661914
Int Decimal (con doble precisión), la tangente hiperbólica del

argumento.
Decimal Decimal (con doble precisión), la tangente hiperbólica del

argumento.
Boolean Undefined.
String Decimal (con doble precisión), la tangente hiperbólica del

Matriz Undefined.
Objeto Undefined.
Null Undefined.
Timestamp()
Devuelve la marca de hora actual en milisegundos desde las 00:00:00 UTC (hora universal coordinada),
jueves 1 de enero de 1970, según lo observado por el motor de reglas de AWS IoT. Es compatible con la
369
Funciones
Ejemplo: timestamp() = 1481825251155
topic(Decimal)
Devuelve el tema al que se ha enviado el mensaje que activó la regla. Si no se especifica ningún
parámetro, se devuelve todo el tema. El parámetro Decimal se utiliza para especificar un segmento
de tema concreto. 1 designa el primer segmento. Para el tema foo/bar/baz, topic(1) devuelve foo,
topic(2) devuelve bar y así sucesivamente. Es compatible con la versión 2015-10-08 de SQL y versiones
posteriores.
Ejemplos:
topic() = "things/myThings/thingOne"
topic(1) = "things"
Cuando se usa Basic Ingest (p. 319), el prefijo inicial del tema ($aws/rules/rule-name) no está
disponible para la función topic(). Por ejemplo, con el tema:
$aws/rules/BuildingManager/Buildings/Building5/Floor2/Room201/Lights
topic() = "Buildings/Building5/Floor2/Room201/Lights"
topic(3) = "Floor2"
Traceid()
Devuelve el ID de seguimiento (UUID) del mensaje MQTT o Undefined si el mensaje no se ha enviado
por MQTT. Es compatible con la versión 2015-10-08 de SQL y versiones posteriores.
Ejemplo:
traceid() = "12345678-1234-1234-1234-123456789012"
trunc(Decimal, int)
Trunca el primer argumento según el número del valor Decimal especificado por el segundo argumento.
Si el segundo argumento es inferior a cero, se establece en cero. Si el segundo argumento es superior
a 34, se establece en 34. Los ceros del final se eliminan del resultado. Es compatible con la versión
Ejemplos:
trunc(2.3, 0) = 2.
trunc(2.3123, 2) = 2.31.
trunc(2.888, 2) = 2,88.
trunc(2.00, 5) = 2.
Int Int El valor de origen.
Int/Decimal Int/Decimal El primer argumento s

el segundo argumento
valor Int, se redonde
370
Funciones
Int/Decimal/String Int/Decimal El primer argumento s

el segundo argumento
valor Int, se redonde
Los valores de tipo St
tipo Decimal. Si se p
cadena, el resultado o
trim(String)
Elimina todos los espacios en blanco del principio y del final del valor String proporcionado. Es
Ejemplo:
Trim(" hi ") = "hi"
Int La representación String de Int con todos los espacios

en blanco del principio y del final suprimidos.
Decimal La representación String de Decimal con todos los

espacios en blanco del principio y del final suprimidos.
Boolean La representación String de Boolean ("true" o "false")

con todos los espacios en blanco del principio y del final
suprimidos.
String El argumento String con todos los espacios en blanco

del principio y del final suprimidos.
Matriz La representación String del valor Array mediante

reglas de conversión estándar.
Objeto La representación String del objeto mediante reglas de

conversión estándar.
Null Undefined.
upper(String)
Muestra la versión en mayúsculas del valor String indicado. Los argumentos que no sean String
se convierten en String mediante las reglas de conversión estándar. Es compatible con la versión
Ejemplos:
upper("hello") = "HELLO"
upper(["hello"]) = "[\"HELLO\"]"
371
Literales
Literales
Puede especificar directamente objetos literales en las cláusulas SELECT y WHERE de su regla SQL, lo
que puede ser útil para pasar información.
Note
Los literales solo están disponibles cuando se utiliza SQL versión 2016-03-23 o versiones
posteriores.
Se utiliza una sintaxis de objeto JSON (pares clave-valor separados con comas, donde las claves son
cadenas y los valores son de tipo JSON escritos entre llaves {}). Por ejemplo:
Carga de entrada publicada en el tema a/b: {"lat_long": [47.606,-122.332]}
Instrucción SQL: SELECT {'latitude': get(lat_long, 0),'longitude':get(lat_long, 1)}

as lat_long FROM 'a/b'
La carga de salida obtenida sería: {"lat_long":{"latitude":47.606,"longitude":-122.332}}.
También puede especificar directamente matrices en las cláusulas SELECT y WHERE de su regla SQL, lo
que le permite agrupar información. Se utiliza una sintaxis JSON (elementos separados con comas entre
corchetes [] para crear un literal de Array). Por ejemplo:
Carga de entrada publicada en el tema a/b: {"lat": 47.696, "long": -122.332}
Instrucción SQL: SELECT [lat,long] as lat_long FROM 'a/b'
La carga de salida obtenida sería: {"lat_long": [47.606,-122.332]}.
Instrucciones case
Las instrucciones case se pueden utilizar para ejecutar bifurcaciones, como una instrucción switch o
instrucciones if/else.
Sintaxis:
CASE v WHEN t[1] THEN r[1]

WHEN t[2] THEN r[2] ...
WHEN t[n] THEN r[n]
ELSE r[e] END
La expresión v se evalúa y se compara con todas las expresiones t[i]. Si se encuentra una coincidencia,
la expresión r[i] correspondiente se convierte en el resultado de la instrucción case. Si hay más de una
posible coincidencia, se selecciona la primera de ellas. Si no hay ninguna coincidencia, se usa la expresión
re de la instrucción else como resultado. Si no hay ninguna coincidencia ni instrucción else, el resultado de
la instrucción case es Undefined. Por ejemplo:
Carga de entrada publicada en el tema a/b: {"color":"yellow"}
Instrucción SQL: SELECT CASE color WHEN 'green' THEN 'go' WHEN 'yellow' THEN
'caution' WHEN 'red' THEN 'stop' ELSE 'you are not at a stop light' END as
instructions FROM 'a/b'
La carga de salida obtenida sería: {"instructions":"caution"}.
Las instrucciones case necesitan como mínimo una cláusula WHEN. No se necesita una cláusula ELSE.
372
Extensiones JSON
Note
Si v es Undefined, el resultado de la instrucción case es Undefined.
Extensiones JSON
Puede utilizar las extensiones siguientes de la sintaxis ANSI SQL para facilitar el trabajo con objetos JSON
anidados.
"." "."
Este operador tiene acceso a los miembros de los objetos y las funciones JSON integrados, exactamente
igual que en ANSI SQL y en JavaScript. Por ejemplo:
SELECT foo.bar AS bar.baz FROM 'a/b'
Operador *
Funciona igual que el comodín * en ANSI SQL. Solo se utiliza en la cláusula SELECT y crea un objeto
JSON nuevo que contiene los datos del mensaje. Si la carga del mensaje no tiene el formato JSON, *
devuelve toda la carga del mensaje como bytes sin procesar. Por ejemplo:
SELECT * FROM 'a/b'
Aplicación de una función a un valor de atributo
A continuación, se muestra un ejemplo de carga JSON que podría publicar un dispositivo:
{
"deviceid" : "iot123",
"temp" : 54.98,
"humidity" : 32.43,
"coords" : {
"latitude" : 47.615694,
"longitude" : -122.3359976
}
}
En el ejemplo siguiente se aplica una función a un valor de atributo de una carga JSON:
SELECT temp, md5(deviceid) AS hashed_id FROM topic/#
El resultado de esta consulta es el objeto JSON siguiente:
{
"temp": 54.98,
"hashed_id": "e37f81fb397e595c4aeb5645b8cbbbd1"
}
Plantillas de sustitución
Puede utilizar una plantilla de sustitución para aumentar los datos JSON que se devuelven cuando se
activa una regla y AWS IoT realiza una acción. La sintaxis de una plantilla de sustitución es ${expresión},
donde expresión puede ser cualquier expresión compatible con AWS IoT en cláusulas SELECT o WHERE.
Esto incluye funciones, operadores e información presente en la carga del mensaje original.
373
Consultas de objetos anidados
Important
Dado que las expresiones en plantillas de sustitución se evalúan por separado de la declaración
"SELECT...", no se puede hacer referencia a un alias creado con la cláusula AS. Solo puede
hacer referencia a la información presente en la carga original, además de a las funciones y
operadores compatibles.
Para obtener más información acerca de las expresiones admitidas, consulte Referencia de la SQL de
AWS IoT (p. 320).
Las plantillas de sustitución aparecen en los parámetros de acción dentro de una regla:
{
"sql": "SELECT *, timestamp() AS timestamp FROM 'my/iot/topic'",
"actions": [{
"republish": {
"topic": "${topic()}/republish",
}
}]
}
Si esta regla se activa mediante el siguiente JSON publicado en my/iot/topic:
{
"deviceid": "iot123",
"temp": 54.98,
"humidity": 32.43,
"coords": {
"latitude": 47.615694,
"longitude": -122.3359976
}
}
Esta regla publica el siguiente JSON en my/iot/topic/republish, que AWS IoT utiliza para sustituir
${topic()}/republish:
{
"deviceid": "iot123",
"temp": 54.98,
"humidity": 32.43,
"coords": {
"latitude": 47.615694,
"longitude": -122.3359976
},
"timestamp": 1579637878451
}
Consultas de objetos anidados

Puede utilizar cláusulas SELECT anidadas para consultar atributos dentro de matrices y objetos JSON
internos. Es compatible con la versión SQL 2016-03-23 y versiones posteriores.
Considere el siguiente mensaje MQTT:
{
"e": [
374
Versiones de SQL
{ "n": "temperature", "u": "Cel", "t": 1234, "v": 22.5 },

{ "n": "light", "u": "lm", "t": 1235, "v": 135 },
{ "n": "acidity", "u": "pH", "t": 1235, "v": 7 }
]
}
Example
Puede convertir valores en una nueva matriz con la siguiente regla.
SELECT (SELECT VALUE n FROM e) as sensors FROM 'my/topic'
La regla generará la salida siguiente.
{
"sensors": [
"temperature",
"light",
"acidity"
]
}
Example
Usando el mismo mensaje MQTT, también puede consultar un valor específico dentro de un objeto
anidado con la siguiente regla.
SELECT (SELECT v FROM e WHERE n = 'temperature') as temperature FROM 'my/topic'
{
"temperature": [
{
"v": 22.5
}
]
}
Example
También puede aplanar la salida con una regla más complicada.
SELECT get((SELECT v FROM e WHERE n = 'temperature'), 0).v as temperature FROM 'topic'
{
"temperature": 22.5
}
Versiones de SQL
El motor de reglas de AWS IoT utiliza una sintaxis similar a SQL para seleccionar los datos de los
mensajes de MQTT. Las instrucciones SQL se interpretan según la versión de SQL especificada en
375
Versiones de SQL
la propiedad awsIotSqlVersion de un documento JSON que describe la regla. Para obtener más
información acerca de la estructura de los documentos de reglas JSON, consulte Creación de una
regla (p. 288). La propiedad awsIotSqlVersion le permite especificar la versión del motor de reglas
SQL de AWS IoT que desea utilizar. Cuando se implementa una nueva versión, puede continuar utilizando
una versión anterior o cambiar la regla para utilizar la nueva versión. Las reglas actuales seguirán
utilizando la versión con la que se crearon.
En el siguiente ejemplo de JSON se muestra cómo especificar la versión de SQL mediante la propiedad
awsIotSqlVersion:
{
"actions": [{
"republish": {
"topic": "my-mqtt-topic",
}
}]
}
AWS IoT admite actualmente las siguientes versiones de SQL:
• 2015-10-08: la versión de SQL original creada el 08/10/2015.

• 2016-03-23: la versión de SQL creada el 23/03/2016.
• beta: la versión beta de SQL más reciente. Si utiliza esta versión podría introducir cambios bruscos en
sus reglas.
Novedades de la versión del motor de reglas SQL del 23/03/2016

• Soluciones para seleccionar objetos JSON anidados.
• Soluciones para consultas de matriz.
• Compatibilidad con consultas dentro de objetos. Para obtener más información, consulte Consultas de
objetos anidados (p. 374).
• Compatibilidad con la generación de una matriz como objeto de nivel superior.
• Adición de la función encode(value, encodingScheme), que se puede aplicar en datos con formato
JSON y no JSON. Para obtener más información, consulte la función de codificación (p. 346).
Generación de Array como objeto de nivel superior

Esta característica permite que una regla devuelva una matriz como objeto de nivel superior. Por ejemplo,
si se recibe el mensaje MQTT siguiente:
{
"a": {"b":"c"},
"arr":[1,2,3,4]
}
Y la regla siguiente:
SELECT VALUE arr FROM 'topic'
376
Versiones de SQL
[1,2,3,4]
377
Flujo de datos del servicio de sombra del dispositivo
Servicio de sombra del dispositivo

para AWS IoT
La sombra de un dispositivo es un documento JSON que se utiliza para almacenar y recuperar información
del estado actual de un dispositivo. El servicio Device Shadow mantiene una sombra para cada dispositivo
que se conecta a AWS IoT. La sombra se puede utilizar para obtener y establecer el estado de un
dispositivo a través de MQTT o HTTP, sin tener en cuenta si el dispositivo está conectado o no a
Internet. La sombra de cada dispositivo se identifica de forma inequívoca mediante el nombre del objeto
correspondiente.
Contenido
• Flujo de datos del servicio de sombra del dispositivo (p. 378)
• Documentos del servicio de sombra del dispositivo (p. 386)
• Uso de sombras (p. 389)
• API RESTful de sombra de dispositivo (p. 398)
• Temas MQTT de sombra (p. 400)
• Sintaxis de los documentos de sombra del dispositivo (p. 407)
• Mensajes de error relacionados con las sombras (p. 411)

El servicio Device Shadow ejerce de intermediario, y permite a los dispositivos y las aplicaciones recuperar
y actualizar la sombra de un dispositivo.
Para ilustrar la forma en que los dispositivos y las aplicaciones se comunican con el servicio Device
Shadow, en esta sección le ayudamos a usar el cliente MQTT de AWS IoT y la CLI de AWS para simular
la comunicación entre una bombilla conectada a Internet, una aplicación y el servicio Device Shadow. En
los siguientes temas de MQTT de ejemplo se utiliza un dispositivo de su registro denominado myLightBulb.
Puede reemplazar este valor por su propio nombre de dispositivo.
El servicio Device Shadow utiliza temas MQTT para facilitar las comunicaciones entre las aplicaciones y
los dispositivos. Para ver cómo funciona, utilice el cliente MQTT de AWS IoT para suscribirse a los temas
MQTT siguientes con QoS 1:
$aws/things/myLightBulb/shadow/update/accepted
El servicio Device Shadow envía mensajes a este tema cuando se realiza correctamente una
actualización de la sombra del dispositivo.
$aws/things/myLightBulb/shadow/update/rejected
El servicio Device Shadow envía mensajes a este tema cuando se rechaza una actualización de la
sombra del dispositivo.
$aws/things/myLightBulb/shadow/update/delta
El servicio Device Shadow envía mensajes a este tema cuando se detecta una diferencia entre las
secciones reported y desired de la sombra del dispositivo. Para obtener más información, consulte /
update/delta (p. 403).
378
$aws/things/myLightBulb/shadow/get/accepted
El servicio Device Shadow envía mensajes a este tema cuando se presenta correctamente una
solicitud para obtener la sombra del dispositivo.
$aws/things/myLightBulb/shadow/get/rejected
El servicio Device Shadow envía mensajes a este tema cuando se rechaza una solicitud para obtener
la sombra del dispositivo.
$aws/things/myLightBulb/shadow/delete/accepted
El servicio Device Shadow envía mensajes a este tema cuando se elimina la sombra del dispositivo.
$aws/things/myLightBulb/shadow/delete/rejected
El servicio Device Shadow envía mensajes a este tema cuando se rechaza una solicitud para eliminar
la sombra del dispositivo.
$aws/things/myLightBulb/shadow/update/documents
El servicio Device Shadow publica un documento de estado en este tema cuando se realiza
correctamente una actualización en la sombra del dispositivo.
Para obtener más información acerca de todos los temas MQTT que utiliza el servicio Device Shadow,
consulte Temas MQTT de sombra (p. 400).
Note
Le recomendamos que se suscriba a los temas .../rejected para ver los errores que envía el
servicio Device Shadow.
Cuando la bombilla está online, se envía su estado actual al servicio Device Shadow transmitiendo un
mensaje MQTT al tema $aws/things/myLightBulb/shadow/update.
Note
Las sombras de dispositivo se crean la primera vez que se intenta actualizarlo. El servicio de
sombra de dispositivo detectará que no existe una sombra y creará una. Si la sombra existe, se
actualizará.
Para simular esto, utilice el cliente MQTT de AWS IoT para publicar el siguiente mensaje en el tema $aws/
things/myLightBulb/shadow/update:
{
"state": {
"reported": {
"color": "red"
}
}
}
Este mensaje establece el color de la bombilla en "rojo."
El servicio Device Shadow responde enviando el siguiente mensaje al tema $aws/things/

myLightBulb/shadow/update/accepted:
{
"messageNumber": 4,
"payload": {
"state": {
"reported": {
"color": "red"
379
}
},
"metadata": {
"reported": {
"color": {
"timestamp": 1469564492
}
}
},
"version": 1,
"timestamp": 1469564492
},
"qos": 0,
"timestamp": 1469564492848,
"topic": "$aws/things/myLightBulb/shadow/update/accepted"
}
Este mensaje indica que el servicio Device Shadow recibió la solicitud UPDATE y actualizó la sombra
del dispositivo. Si la sombra no existe, se crea. De lo contrario, la sombra se actualiza con los datos del
mensaje. Si no ve un mensaje publicado en $aws/things/myLightBulb/shadow/update/accepted,
consulte la suscripción a $aws/things/myLightBulb/shadow/update/rejected para ver los
mensajes de error.
Además, el servicio Device Shadow publica el siguiente mensaje en el tema $aws/things/

myLightBulb/shadow/update/documents.
{
"previous":null,
"current":{
"state":{
"reported":{
"color":"red"
}
},
"metadata":{
"reported":{
"color":{
"timestamp":1483467764
}
}
},
"version":1
},
}
Los mensajes se publican en el tema /update/documents siempre que se realiza correctamente una
actualización de una sombra del dispositivo. Para obtener más información sobre el contenido de los
mensajes publicados en este tema, consulte Temas MQTT de sombra (p. 400).
Una aplicación que interactúa con la bombilla pasa a estar online y solicita el estado actual de la bombilla.
La aplicación envía un mensaje vacío al tema $aws/things/myLightBulb/shadow/get. Para
simularlo, utilice el cliente MQTT de AWS IoT para publicar un mensaje vacío ("") en el tema $aws/
things/myLightBulb/shadow/get.
El servicio Device Shadow responde publicando la sombra del dispositivo solicitada en el tema $aws/
things/myLightBulb/shadow/get/accepted:
{
"messageNumber": 1,
"payload": {
380
"state": {
"reported": {
"color": "red"
}
},
"metadata": {
"reported": {
"color": {
"timestamp": 1469564492
}
}
},
"version": 1,
"timestamp": 1469564571
},
"qos": 0,
"timestamp": 1469564571533,
"topic": "$aws/things/myLightBulb/shadow/get/accepted"
}
Si no ve un mensaje en el tema $aws/things/myLightBulb/shadow/get/accepted, busque

posibles mensajes de error en el tema $aws/things/myLightBulb/shadow/get/rejected.
La aplicación muestra esta información para el usuario y este solicita un cambio de color de la bombilla
(de rojo a verde). Para ello, la aplicación publica un mensaje en el tema $aws/things/myLightBulb/
shadow/update:
{
"state": {
"desired": {
"color": "green"
}
}
}
Para simularlo, utilice el cliente MQTT de AWS IoT para publicar el mensaje anterior en el tema $aws/
things/myLightBulb/shadow/update.
El servicio Device Shadow responde enviando un mensaje al tema $aws/things/myLightBulb/

shadow/update/accepted:
{
"messageNumber": 5,
"payload": {
"state": {
"desired": {
"color": "green"
}
},
"metadata": {
"desired": {
"color": {
"timestamp": 1469564658
}
}
},
"version": 2,
"timestamp": 1469564658
},
"qos": 0,
"timestamp": 1469564658286,
381
y al tema $aws/things/myLightBulb/shadow/update/delta:
{
"messageNumber": 1,
"payload": {
"version": 2,
"timestamp": 1469564658,
"state": {
"color": "green"
},
"metadata": {
"color": {
"timestamp": 1469564658
}
}
},
"qos": 0,
"timestamp": 1469564658309,
"topic": "$aws/things/myLightBulb/shadow/update/delta"
}
El servicio Device Shadow publica un mensaje en este tema cuando acepta una actualización de la sombra
y, como resultado de esta, dicha sombra contiene valores distintos para el estado deseado y el estado
notificado.
El servicio Device Shadow también publica un mensaje en el tema $aws/things/myLightBulb/

shadow/update/documents:
{
"previous":{
"state":{
"reported":{
"color":"red"
}
},
"metadata":{
"reported":{
"color":{
}
}
},
"version":1
},
"current":{
"state":{
"desired":{
"color":"green"
},
"reported":{
"color":"red"
}
},
"metadata":{
"desired":{
"color":{
}
},
"reported":{
"color":{
382
}
}
},
"version":2
},
}
La bombilla está suscrita al tema $aws/things/myLightBulb/shadow/update/delta, por lo que

recibe el mensaje, cambia de color y publica su nuevo estado. Para simularlo, utilice el cliente MQTT de
AWS IoT para publicar el siguiente mensaje en el tema $aws/things/myLightBulb/shadow/update y
actualizar el estado de la sombra:
{
"state":{
"reported":{
"color": "green"
},
"desired": null
}
}
Como respuesta, el servicio Device Shadow envía un mensaje al tema $aws/things/myLightBulb/

shadow/update/accepted:
{
"messageNumber": 6,
"payload": {
"state": {
"reported": {
"color": "green"
},
"desired": null
},
"metadata": {
"reported": {
"color": {
"timestamp": 1469564801
}
},
"desired": {
"timestamp": 1469564801
}
},
"version": 3,
"timestamp": 1469564801
},
"qos": 0,
"timestamp": 1469564801673,
}
y al tema $aws/things/myLightBulb/shadow/update/documents:
{
"previous":{
"state":{
"reported":{
"color":"red"
}
},
383
"metadata":{
"reported":{
"color":{
}
}
},
"version":3
},
"current":{
"state":{
"reported":{
"color":"green"
}
},
"metadata":{
"reported":{
"color":{
}
}
},
"version":4
},
}
La aplicación solicita el estado actual al servicio Device Shadow y muestra los datos del estado más
reciente. Para simularlo, ejecute el comando siguiente:
aws iot-data get-thing-shadow --thing-name "myLightBulb" "output.txt" && cat "output.txt"
Note
En Windows, omita el && cat "output.txt" que muestra el contenido del archivo output.txt
a la consola. Puede abrir el archivo en el Bloc de notas o en cualquier editor de texto para ver el
El servicio Device Shadow devuelve el documento de sombra:
{
"state":{
"reported":{
"color":"green"
}
},
"metadata":{
"reported":{
"color":{
}
}
},
"version":3,
"timestamp":1469564864}
Para eliminar la sombra del dispositivo, publique un mensaje vacío en el tema $aws/things/
myLightBulb/shadow/delete. AWS IoT responderá publicando un mensaje en el tema $aws/
things/myLightBulb/shadow/delete/accepted:
384
Detección de un objeto conectado
"version" : 1,
"timestamp" : 1488565234
}
Detección de un objeto conectado

Para determinar si un dispositivo está conectado actualmente, incluya una configuración de conexión
en la sombra y utilice un mensaje Last Will and Testament (LWT) de MQTT, que establece el valor de la
conexión en false si se desconecta un dispositivo debido a un error.
Note
En la actualidad, el servicio Device Shadow de AWS IoT no tiene en cuenta los mensajes LWT
enviados a los temas reservados de AWS IoT (temas que comienzan por $), pero los clientes
suscritos y el motor de reglas de AWS IoT siguen procesándolos. Para que el servicio Device
Shadow reciba mensajes LWT, registre un mensaje LWT en un tema no reservado y cree una
regla que vuelva a publicar el mensaje en el tema reservado. El siguiente ejemplo muestra cómo
crear una regla que escuche mensajes del tema my/things/myLightBulb/update y los
vuelva a publicar en $aws/things/myLightBulb/shadow/update.
{
"rule": {
"sql": "SELECT * FROM 'my/things/myLightBulb/update'",
"description": "Turn my/things/ into $aws/things/",
"actions": [{
"republish": {
"topic": "$$aws/things/myLightBulb/shadow/update",
"roleArn": "arn:aws:iam::123456789012:role/aws_iot_republish"
}
}]
}
}
Cuando un dispositivo se conecta, registra un LWT que establece la configuración de conexión en false:
{
"state": {
"reported": {
"connected":"false"
}
}
}
También publica un mensaje en su tema de actualización ($aws/things/myLightBulb/shadow/

update) y establece su estado de conexión en true:
{
"state": {
"reported": {
"connected":"true"
}
}
}
Cuando el dispositivo se desconecta correctamente, publica un mensaje en su tema de actualización y

establece su estado de conexión en false:
385
Documentos del servicio de sombra del dispositivo
"state": {
"reported": {
"connected":"false"
}
}
}
Si el dispositivo se desconecta debido a un error, su mensaje LWT se publica automáticamente en el tema

de actualización.
Documentos del servicio de sombra del dispositivo

El servicio Device Shadow respeta todas las reglas de la especificación JSON. Los valores, objetos y
matrices se almacenan en el documento de sombra del dispositivo.
Contenido
• Propiedades del documento (p. 386)
• Control de versiones de sombra del dispositivo (p. 387)
• Token de cliente (p. 387)
• Ejemplo de documento (p. 387)
• Secciones vacías (p. 388)
• Matrices (p. 388)
Propiedades del documento

El documento de sombra de un dispositivo tiene las propiedades siguientes:
state
desired
El estado deseado del objeto. Las aplicaciones pueden escribir en esta parte del documento para
actualizar el estado de un objeto, sin tener que conectarse directamente a un objeto.
reported
El estado notificado del objeto. Los objetos escriben en esta parte del documento para informar de
su nuevo estado. Las aplicaciones leen esta parte del documento para determinar el estado de un
objeto.
metadata
Información acerca de los datos almacenados en la sección state del documento. Esto incluye las
marcas de tiempo, según la fecha de inicio Unix, para cada atributo de la sección state, lo que le
permite determinar cuándo se actualizaron.
Note
Los metadatos no contribuyen al tamaño de documento para establecer los límites del
servicio o el precio. Para obtener más información, consulte AWS IoT Service Limits.
timestamp
Indica cuándo AWS IoT transmitió el mensaje. Con la marca de tiempo que figura en el mensaje
y las marcas de tiempo para los atributos individuales que se muestran en la sección desired o
reported, un objeto puede determinar la edad de un elemento actualizado, aunque no disponga de
un reloj interno.
386
Control de versiones de sombra del dispositivo
clientToken
Una cadena única del dispositivo que le permite asociar respuestas a solicitudes en un entorno de
MQTT.
version
La versión del documento. Cada vez que el documento se actualiza, su número de versión se
incrementa. Se utiliza para garantizar que la versión del documento que se actualiza sea la más
reciente.
Para obtener más información, consulte Sintaxis de los documentos de sombra del dispositivo (p. 407).
Control de versiones de sombra del dispositivo

El servicio Device Shadow admite el control de versiones en cada mensaje de actualización (tanto
de solicitud como de respuesta), por lo que la versión del documento JSON se incrementa con cada
actualización de la sombra de un dispositivo. Esto permite garantizar dos cosas:
• Un cliente puede recibir un error si intenta sobrescribir una sombra con una versión más antigua. Se
informa al cliente de que debe volver a sincronizarlo para poder actualizar la sombra de un dispositivo.
• Un cliente puede decidir omitir un mensaje recibido si su versión es anterior a la que tiene almacenada.
En algunos casos, un cliente puede omitir la correlación de versiones no presentando una versión.
Token de cliente
Puede utilizar un token de cliente con mensajes basados en MQTT para verificar que el mismo token de
cliente esté contenido en una solicitud y en la respuesta a dicha solicitud. De esta forma se garantiza que
la respuesta y la solicitud estén asociadas.
Note
El token de cliente no puede ser superior a 64 bytes. Un token de cliente que es superior a 64
bytes provocará una respuesta 400 (solicitud errónea) y un mensaje de error clientToken no
válido.
Ejemplo de documento
A continuación, se muestra un ejemplo de documento de sombra:
{
"state" : {
"desired" : {
"color" : "RED",
"sequence" : [ "RED", "GREEN", "BLUE" ]
},
"reported" : {
"color" : "GREEN"
}
},
"metadata" : {
"desired" : {
"color" : {
"timestamp" : 12345
},
"sequence" : {
387
Secciones vacías
"timestamp" : 12345
}
},
"reported" : {
"color" : {
"timestamp" : 12345
}
}
},
"version" : 10,
"clientToken" : "UniqueClientToken",
"timestamp": 123456789
}
Secciones vacías
Un documento de sombra contiene una sección desired solo si tiene un estado deseado. Por ejemplo, el
documento siguiente es un documento de estado válido sin sección desired:
{
"reported" : { "temp": 55 }
}
La sección reported también puede estar vacía:
{
"desired" : { "color" : "RED" }
}
Si una actualización produce la nulidad de las secciones desired o reported, la sección se elimina
del documento. Para eliminar la sección desired de un documento (como respuesta, por ejemplo, a un
dispositivo que actualiza su estado), establezca la sección deseada en null:
{
"state": {
"reported": {
"color": "red"
},
"desired": null
}
}
También es posible que un documento de sombra no contenga las secciones desired o reported. En
tal caso, el documento de sombra estará vacío. Por ejemplo, el documento siguiente es válido:
{
}
Matrices
Las sombras son compatibles con las matrices, pero las tratan como valores normales, en el sentido de
que la actualización de una matriz sustituye toda la matriz. No es posible actualizar parte de una matriz.
Estado inicial:
388
Uso de sombras
"desired" : { "colors" : ["RED", "GREEN", "BLUE" ] }

}
Actualizar:
{
"desired" : { "colors" : ["RED"] }
}
Estado final:
{
"desired" : { "colors" : ["RED"] }
}
Las matrices no pueden tener valores nulos. Por ejemplo, la matriz siguiente no es válida y se rechazará.
{
"desired" : {
"colors" : [ null, "RED", "GREEN" ]
}
}
Uso de sombras
AWS IoT proporciona tres métodos para trabajar con la sombra de un dispositivo:
UPDATE
Crea la sombra de un dispositivo si este no existe o bien la actualiza con los datos suministrados
en la solicitud. Los datos se almacenan con la marca de tiempo para indicar la fecha de su última
actualización. Se envían mensajes a todos los suscriptores con la diferencia entre el estado desired
o reported (delta). Los objetos o las aplicaciones que reciben un mensaje pueden ejecutar una
acción en función de la diferencia entre los estados desired o reported. Por ejemplo, un dispositivo
puede actualizar su estado al estado deseado, o una aplicación puede actualizar su interfaz de usuario
para mostrar el cambio de estado del dispositivo.
GET
Recupera el último estado almacenado en la sombra del dispositivo (por ejemplo, durante el arranque
de un dispositivo para recuperar la configuración y el último estado de funcionamiento). Este método
devuelve todo el documento JSON, incluidos los metadatos.
DELETE
Elimina la sombra de un dispositivo, incluido todo su contenido. Esto elimina el documento JSON del
almacén de datos. No se puede restaurar la sombra de un dispositivo tras eliminarla, pero se puede
crear otra con el mismo nombre.
Compatibilidad del protocolo

Estos métodos se admiten con MQTT y una API RESTful sobre HTTPS. Dado que MQTT es un modelo
de comunicación de publicación/suscripción, AWS IoT implementa un conjunto de temas reservados.
Los objetos o las aplicaciones se suscriben a estos temas antes de publicar en un tema de solicitud para
389
Actualización de la sombra
implementar un comportamiento de solicitud-respuesta. Para obtener más información, consulte Temas

MQTT de sombra (p. 400) y API RESTful de sombra de dispositivo (p. 398).
Actualización de la sombra
Puede actualizar la sombra de un dispositivo mediante la API RESTful UpdateThingShadow (p. 399)
o publicando en el tema /update (p. 401). Las actualizaciones afectan únicamente a los campos
especificados en la solicitud.
Estado inicial:
{
"state": {
"reported" : {
"color" : { "r" :255, "g": 255, "b": 0 }
}
}
}
Se envía un mensaje de actualización:
{
"state": {
"desired" : {
"color" : { "r" : 10 },
"engine" : "ON"
}
}
}
El dispositivo recibe el estado desired en el tema /update/delta que se activa mediante el mensaje
/update anterior y, a continuación, ejecuta los cambios deseados. Cuando termina, el dispositivo debe
confirmar el estado actualizado a través de la sección reported del documento JSON de la sombra.
Estado final:
{
"state": {
"reported" : {
"color" : { "r" : 10, "g" : 255, "b": 0 },
"engine" : "ON"
}
}
}
Recuperación de un documento de sombra

Puede recuperar la sombra de un dispositivo mediante la API RESTful GetThingShadow (p. 398) o
suscribiéndose al tema /get (p. 404) y publicando en él. De este modo, recupera todo el documento y el
delta entre los estados desired o reported.
Ejemplo de documento:
{
"state": {
"desired": {
"lights": {
"color": "RED"
390
},
"engine": "ON"
},
"reported": {
"lights": {
"color": "GREEN"
},
"engine": "ON"
}
},
"metadata": {
"desired": {
"lights": {
"color": {
"timestamp": 123456
},
"engine": {
"timestamp": 123456
}
}
},
"reported": {
"lights": {
"color": {
"timestamp": 789012
}
},
"engine": {
"timestamp": 789012
}
},
"version": 10,
}
}
Respuesta:
{
"state": {
"desired": {
"lights": {
"color": "RED"
},
"engine": "ON"
},
"reported": {
"lights": {
"color": "GREEN"
},
"engine": "ON"
},
"delta": {
"lights": {
"color": "RED"
}
}
},
"metadata": {
"desired": {
"lights": {
"color": {
"timestamp": 123456
},
},
391
"engine": {
"timestamp": 123456
}
},
"reported": {
"lights": {
"color": {
"timestamp": 789012
}
},
"engine": {
"timestamp": 789012
}
},
"delta": {
"lights": {
"color": {
"timestamp": 123456
}
}
}
},
"version": 10,
}
Bloqueo optimista
Puede utilizar la versión del documento de estado para asegurarse de que actualiza la versión más
reciente del documento de sombra de un dispositivo. Cuando se suministra una versión con una solicitud
de actualización, el servicio rechaza la solicitud con un código de respuesta de conflicto HTTP 409 si la
versión actual del documento de estado no coincide con la versión suministrada.
Por ejemplo:
Documento inicial:
{
"state" : {
"desired" : { "colors" : ["RED", "GREEN", "BLUE" ] }
},
"version" : 10
}
Actualización: (la versión no coincide; se rechazará la solicitud)
{
"state": {
"desired": {
"colors": [
"BLUE"
]
}
},
"version": 9
}
Resultado:
409 Conflict
392
Eliminación de datos
Actualización: (la versión coincide; esta solicitud se aceptará)
{
"state": {
"desired": {
"colors": [
"BLUE"
]
}
},
"version": 10
}
Estado final:
{
"state": {
"desired": {
"colors": [
"BLUE"
]
}
},
"version": 11
}
Eliminación de datos
Puede eliminar datos de la sombra de un dispositivo publicando en el tema /update (p. 401) y definiendo
los campos que se van a suprimir con el valor nulo. Todo campo que tenga el valor null se eliminará del
documento.
Estado inicial:
{
"state": {
"desired" : {
"lights": { "color": "RED" },
"engine" : "ON"
},
"reported" : {
"lights" : { "color": "GREEN" },
"engine" : "OFF"
}
}
}
Se envía un mensaje de actualización:
{
"state": {
"desired": null,
"reported": {
"engine": null
}
}
}
Estado final:
393
Eliminación de una sombra
{
"state": {
"reported" : {
"lights" : { "color" : "GREEN" }
}
}
}
Puede eliminar todos los datos de la sombra de un dispositivo estableciendo su estado en el valor null.
Por ejemplo, si envía el mensaje siguiente, se eliminarán todos los datos de estado, pero la sombra del
dispositivo permanecerá.
{
"state": null
}
La sombra del dispositivo sigue existiendo, aunque su estado sea null. La versión de la sombra del
dispositivo se incrementará cuando se produzca la siguiente actualización.
Eliminación de una sombra

Puede eliminar el documento de sombra de un dispositivo mediante la API RESTful
DeleteThingShadow (p. 400) o publicando en el tema /delete (p. 406).
Note
Si se elimina la sombra de un dispositivo, no se elimina el objeto. Si se elimina un objeto, no se

elimina la correspondiente sombra del dispositivo.
Estado inicial:
{
"state": {
"desired" : {
"lights": { "color": "RED" },
"engine" : "ON"
},
"reported" : {
"lights" : { "color": "GREEN" },
"engine" : "OFF"
}
}
}
Se publica un mensaje vacío en el tema /delete.
Estado final:
HTTP 404 - resource not found
Estado delta
El estado delta es un tipo de estado virtual que contiene la diferencia entre los estados desired y
reported. Los campos de la sección desired que no están incluidos en la sección reported se
incluyen en el delta. Los campos que están en la sección reported y no están en la sección desired no
se incluyen en el delta. El delta contiene metadatos, y sus valores son iguales a los metadatos del campo
desired. Por ejemplo:
394
Estado delta
{
"state": {
"desired": {
"color": "RED",
"state": "STOP"
},
"reported": {
"color": "GREEN",
"engine": "ON"
},
"delta": {
"color": "RED",
"state": "STOP"
}
},
"metadata": {
"desired": {
"color": {
"timestamp": 12345
},
"state": {
"timestamp": 12345
},
"reported": {
"color": {
"timestamp": 12345
},
"engine": {
"timestamp": 12345
}
},
"delta": {
"color": {
"timestamp": 12345
},
"state": {
"timestamp": 12345
}
}
},
"version": 17,
}
}
Cuando los objetos anidados difieren, el delta contiene la ruta de acceso a la raíz.
{
"state": {
"desired": {
"lights": {
"color": {
"r": 255,
"g": 255,
"b": 255
}
}
},
"reported": {
"lights": {
"color": {
"r": 255,
"g": 0,
"b": 255
395
Observación de los cambios de estado
}
}
},
"delta": {
"lights": {
"color": {
"g": 255
}
}
}
},
"version": 18,
}
El servicio Device Shadow calcula la diferencia iterando por cada campo con el estado desired y
comparándolo con el estado reported.
Las matrices se tratan como valores. Si una matriz de la sección desired no coincide con la matriz de la
sección reported, toda la matriz deseada se copia en el delta.
Observación de los cambios de estado

Cuando se actualiza la sombra de un dispositivo, los mensajes se publican en dos temas MQTT:
• $aws/things/nombre de objeto/shadow/update/accepted
• $aws/things/nombre de objeto/shadow/update/delta
El mensaje enviado al tema update/delta está destinado al objeto cuyo estado se actualiza. Este
mensaje contiene únicamente la diferencia entre las secciones desired y reported del documento
de sombra del dispositivo. Tras recibir este mensaje, el dispositivo debe decidir si realizará el cambio
solicitado. Si cambia el estado del dispositivo, este debe publicar su nuevo estado actual en el tema $aws/
things/thing-name/shadow/update.
Los dispositivos y aplicaciones pueden suscribirse a uno de estos temas para recibir una notificación
cuando el estado del documento cambie.
A continuación, se muestra un ejemplo de este flujo:
1. Un dispositivo informa de su estado.

2. El sistema actualiza el documento de estado en su almacén de datos persistentes.
3. El sistema publica un mensaje delta que contiene únicamente el delta y está dirigido a los dispositivos
suscritos. Los dispositivos deben suscribirse a este tema para recibir actualizaciones.
4. La sombra del dispositivo publica un mensaje de aceptación que contiene todo el documento recibido,
incluidos los metadatos. Las aplicaciones deben suscribirse a este tema para recibir actualizaciones.
Orden de los mensajes

No se garantiza que los mensajes generados por el servicio de AWS IoT lleguen al dispositivo siguiendo un
orden específico.
Documento de estado inicial:
{
"state" : {
"reported" : { "color" : "blue" }
},
396
Recorte de mensajes de sombra
"version" : 10,
}
Actualización 1:
{
"state": { "desired" : { "color" : "RED" } },
"version": 10,
}
Actualización 2:
{
"state": { "desired" : { "color" : "GREEN" } },
"version": 11,
}
Documento de estado final:
{
"state": {
"reported": { "color" : "GREEN" }
},
"version": 12,
}
Se obtienen dos mensajes delta:
{
"state": {
"color": "RED"
},
"version": 11,
}
{
"state": { "color" : "GREEN" },
"version": 12,
}
El dispositivo puede recibir estos mensajes de forma desordenada. Dado que el estado de estos mensajes
es acumulable, un dispositivo puede descartar con toda seguridad todos los mensajes cuyo número de
versión sea anterior a la del mensaje del cual se hace un seguimiento. Si el dispositivo recibe el delta de la
versión 12 antes que el de la versión 11, puede descartar sin problemas el mensaje de la versión 11.
Recorte de mensajes de sombra

Para reducir el tamaño de los mensajes de sombra que se envían al dispositivo, defina una regla que
seleccione solo los campos que necesita el dispositivo y que después vuelva a publicar el mensaje en un
tema MQTT al que el dispositivo esté escuchando.
La regla se especifica en JSON y debe tener el aspecto siguiente:
397
API RESTful
{
"sql": "SELECT state, version FROM '$aws/things/+/shadow/update/delta'",
"actions": [{
"republish": {
"topic": "${topic(3)}/delta",
}
}]
}
La instrucción SELECT determina qué campos del mensaje se volverán a publicar en el tema especificado.
Se usa el comodín "+" para seleccionar todos los nombres de sombra. La regla especifica que todos
los mensajes coincidentes deben volver a publicarse en el tema especificado. En tal caso, la función
"topic()" se utiliza para especificar el tema en el que se vuelve a publicar. topic(3) toma el valor del
nombre de objeto del tema original. Para obtener más información sobre la creación de reglas, consulte
Reglas para AWS IoT (p. 285).
API RESTful de sombra de dispositivo

Una sombra expone el siguiente URI para actualizar la información de estado:
https://endpoint/things/thingName/shadow
El punto de enlace específico con su cuenta de AWS. Para recuperar su punto de enlace, ejecute el
comando describe-endpoint. El formato del punto de enlace es el siguiente:
identifier.iot.region.amazonaws.com
La API de RESTful de sombras sigue los mismos mapeos de puertos y protocolos HTTPS que se describe
en Protocolos (p. 276).
Acciones de API
• GetThingShadow (p. 398)
• UpdateThingShadow (p. 399)
• DeleteThingShadow (p. 400)
Note
Cuando utilice estas API, asegúrese de usar el puerto 8443, tal y como se describe en Protocolos,
mapeos de puertos y autenticación (p. 277).
GetThingShadow
Obtiene la sombra de objeto especificado.
El documento de estado de respuesta incluye el delta entre los estados desired y reported.
Solicitud
La solicitud incluye los encabezados HTTP estándar y el URI siguiente:
HTTP GET https://endpoint/things/thingName/shadow
398
UpdateThingShadow
Respuesta
En caso de éxito, la respuesta incluye encabezados HTTP estándar, así como el código y el cuerpo
siguientes:
HTTP 200
BODY: response state document
Para obtener más información, consulte Ejemplo de documento de estado de respuesta (p. 408).
Autorización
Para recuperar una sombra, se necesita una política que permita al intermediario ejecutar la acción
iot:GetThingShadow. El servicio Device Shadow acepta dos formas de autenticación: Signature
Version 4 con credenciales de IAM o autenticación mutua TLS con un certificado de cliente.
A continuación, se muestra una política de ejemplo que permite a un intermediario recuperar la sombra de
un dispositivo:
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iot:GetThingShadow",
"Resource": ["arn:aws:iot:region:account:thing/thing"]
}]
}
UpdateThingShadow
Actualiza la sombra del objeto especificado.
Las actualizaciones solo afectan a los campos especificados en el documento de estado de la solicitud.
Todos los campos que tengan el valor null se eliminarán de la sombra del dispositivo.
Solicitud
La solicitud incluye los encabezados HTTP estándar, así como el URI y el cuerpo siguientes:
HTTP POST https://endpoint/things/thingName/shadow

BODY: request state document
Para obtener más información, consulte Ejemplo de documento de estado de solicitud (p. 408).
Respuesta
siguientes:
HTTP 200
BODY: response state document
Para obtener más información, consulte Ejemplo de documento de estado de respuesta (p. 408).
Autorización
Para actualizar una sombra se necesita una política que permita al intermediario ejecutar la acción
iot:UpdateThingShadow. El servicio Device Shadow acepta dos formas de autenticación: Signature
Version 4 con credenciales de IAM o autenticación mutua TLS con un certificado de cliente.
399
DeleteThingShadow
A continuación, se muestra una política de ejemplo que permite a un intermediario actualizar la sombra de
un dispositivo:
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iot:UpdateThingShadow",
}]
}
DeleteThingShadow
Elimina la sombra de objeto especificado.
Solicitud
La solicitud incluye los encabezados HTTP estándar y el URI siguiente:
HTTP DELETE https://endpoint/things/thingName/shadow
Respuesta
siguientes:
HTTP 200
BODY: Empty response state document
Autorización
Para eliminar la sombra de un dispositivo se necesita una política que permita al intermediario ejecutar
la acción iot:DeleteThingShadow. El servicio Device Shadow acepta dos formas de autenticación:
Signature Version 4 con credenciales de IAM o autenticación mutua TLS con un certificado de cliente.
A continuación, se muestra una política de ejemplo que permite a un intermediario eliminar la sombra de
un dispositivo:
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": "iot:DeleteThingShadow",
}]
}
Temas MQTT de sombra

El servicio Device Shadow utiliza temas MQTT reservados para permitir a las aplicaciones y los
dispositivos obtener, actualizar o eliminar la información de estado de un dispositivo (sombra). Los
nombres de estos temas comienzan por $aws/things/nombre de objeto/shadow. La publicación y
suscripción de temas de sombra requiere una autorización basada en temas. AWS IoT se reserva el
derecho a añadir nuevos temas a la estructura de temas existente. Por este motivo, le recomendamos
400
/update
que evite las suscripciones de tipo comodín a los temas de sombra. Por ejemplo, evite suscribirse a filtros
de temas como $aws/things/thingName/shadow/#, ya que el número de temas que coinciden con
este filtro de temas puede aumentar a medida que AWS IoT incorpora nuevos temas de sombra. Para
consultar ejemplos de mensajes publicados en estos temas vaya a Flujo de datos del servicio de sombra
del dispositivo (p. 378).
A continuación se muestran los temas MQTT utilizados para interactuar con las sombras.
Temas
• /update (p. 401)
• /update/accepted (p. 402)
• /update/documents (p. 402)
• /update/rejected (p. 403)
• /update/delta (p. 403)
• /get (p. 404)
• /get/accepted (p. 405)
• /get/rejected (p. 405)
• /delete (p. 406)
• /delete/accepted (p. 406)
• /delete/rejected (p. 407)
/update
Publique un documento de estado de solicitud en este tema para actualizar la sombra del dispositivo:
$aws/things/thingName/shadow/update
Un cliente que intente actualizar el estado de un objeto debe enviar un documento de estado de solicitud
JSON como el siguiente:
{
"state" : {
"desired" : {
"color" : "red",
"power" : "on"
}
}
}
Un dispositivo que actualice su sombra enviará un documento de estado de solicitud JSON como el
siguiente:
{
"state" : {
"reported" : {
"color" : "red",
"power" : "on"
}
}
}
AWS IoT responde publicando en /update/accepted (p. 402) o en /update/rejected (p. 403).
Para obtener más información, consulte Documentos de estado de la solicitud (p. 408).
401
/update/accepted
Política de ejemplo
A continuación, mostramos un ejemplo de la política requerida:
{
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Action": ["iot:Publish"],
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/
update"]
}]
}
/update/accepted
AWS IoT publica un documento de estado de respuesta en este tema cuando acepta un cambio de la
sombra del dispositivo:
$aws/things/thingName/shadow/update/accepted
Para obtener más información, consulte Documentos de estado de la respuesta (p. 408).
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:region:account:topicfilter/$aws/things/thingName/shadow/
update/accepted"]
},
{
"Effect": "Allow",
"Action": ["iot:Receive"],
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/update/
accepted"]
}
]
}
/update/documents
AWS IoT publica un documento de estado en este tema siempre que se realiza una actualización correcta
de la sombra:
$aws/things/thingName/shadow/update/documents
El documento JSON contiene dos nodos principales: previous y current. El nodo previous incluye el
contenido del documento de sombra completo antes de realizar la actualización, mientras que current
contiene el documento de sombra completo después de realizar la actualización sin errores. Cuando se
actualiza (se crea) la sombra por primera vez, el nodo previous contiene null.
402
/update/rejected
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
update/documents"]
},
{
"Effect": "Allow",
accepted"]
}
]
}
/update/rejected
AWS IoT publica un documento de respuesta de error en este tema cuando rechaza un cambio de la
sombra del dispositivo:
$aws/things/thingName/shadow/update/rejected
Para obtener más información, consulte Documentos de respuesta de error (p. 411).
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
update/rejected"]
},
{
"Effect": "Allow",
rejected"]
}
]
}
/update/delta
AWS IoT publica un documento de estado de respuesta en este tema cuando acepta un cambio de la
sombra del dispositivo y el documento de estado de solicitud contiene valores distintos para los estados
desired y reported:
403
/get
$aws/things/thingName/shadow/update/delta
Detalles de la publicación
• Un mensaje publicado en update/delta incluye únicamente los atributos deseados que difieren entre
las secciones desired y reported. Contiene todos estos atributos, independientemente de si se
encuentran en el mensaje de actualización actual o si ya estaban almacenados en AWS IoT. No se
incluyen los atributos que no difieren entre las secciones desired y reported.
• Si un atributo se encuentra en la sección reported, pero no tiene equivalente en la sección desired,
no se incluye.
• Si un atributo se encuentra en la sección desired, pero no tiene equivalente en la sección reported,
se incluye.
• Si se elimina un atributo de la sección reported, pero sigue existiendo en la sección desired, se
incluye.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
update/delta"]
},
{
"Effect": "Allow",
delta"]
}
]
}
/get
Publique un mensaje vacío en este tema para obtener la sombra de objeto:
$aws/things/thingName/shadow/get
AWS IoT responde publicando en /get/accepted (p. 405) o en /get/rejected (p. 405).
{
"Version": "2012-10-17",
"Statement": [
404
/get/accepted
{
"Effect": "Allow",
"Action": [ "iot:Publish" ],
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/get"]
}
]
}
/get/accepted
AWS IoT publica un documento de estado de respuesta en este tema cuando devuelve la sombra del
dispositivo:
$aws/things/thingName/shadow/get/accepted
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
get/accepted"]
},
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/get/
accepted"]
}
]
}
/get/rejected
AWS IoT publica un documento de respuesta de error en este tema cuando no puede devolver la sombra
del dispositivo:
$aws/things/thingName/shadow/get/rejected
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
405
/delete
get/rejected"]
},
{
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/get/
rejected"]
}
]
}
/delete
Para eliminar la sombra de un dispositivo, publique un mensaje vacío para eliminar el tema:
$aws/things/thingName/shadow/delete
El contenido del mensaje no se tiene en cuenta.
AWS IoT responde publicando en /delete/accepted (p. 406) o en /delete/rejected (p. 407).
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
delete"]
},
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/
delete"]
}
]
}
/delete/accepted
AWS IoT publica un mensaje en este tema cuando se elimina la sombra de un dispositivo:
$aws/things/thingName/shadow/delete/accepted
{
"Version": "2012-10-17",
"Statement": [
406
/delete/rejected
{
"Effect": "Allow",
delete/accepted"]
},
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/delete/
accepted"]
}
]
}
/delete/rejected
AWS IoT publica un documento de respuesta de error en este tema cuando no puede eliminar la sombra
del dispositivo:
$aws/things/thingName/shadow/delete/rejected
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
delete/rejected"]
},
{
"Effect": "Allow",
"Resource": ["arn:aws:iot:region:account:topic/$aws/things/thingName/shadow/delete/
rejected"]
}
]
}
Sintaxis de los documentos de sombra del

dispositivo
El servicio Device Shadow utiliza los siguientes documentos en operaciones UPDATE, GET y DELETE
mediante la API RESTful (p. 398) o mensajes de publicación/suscripción MQTT (p. 400). Para obtener
más información, consulte Documentos del servicio de sombra del dispositivo (p. 386).
Ejemplos
• Documentos de estado de la solicitud (p. 408)
407
Documentos de estado de la solicitud
• Documentos de estado de la respuesta (p. 408)

• Documentos de respuesta de error (p. 411)
Documentos de estado de la solicitud

Los documentos de estado de la solicitud tienen el formato siguiente:
{
"state": {
"desired": {
"attribute1": integer2,
"attribute2": "string2",
...
"attributeN": boolean2
},
"reported": {
...
}
},
"clientToken": "token",
"version": version
}
• state — Las actualizaciones solo afectan a los campos especificados. Normalmente, utilizará la
propiedad desired o la propiedad reported, pero no ambas en la misma solicitud.
• desired: las propiedades de estado y los valores solicitados para actualizarlos en el dispositivo.
• reported: las propiedades de estado y los valores notificados por el dispositivo.
• clientToken: si se usa, puede hacer coincidir la solicitud y la respuesta correspondiente del token del
cliente.
• version — Si se utiliza, el servicio Device Shadow procesa la actualización solo si la versión
especificada coincide con la versión más reciente que tiene.
Documentos de estado de la respuesta

Los documentos de estado de respuesta tienen el siguiente formato en función del tipo de respuesta.
Documento de estado de la respuesta /aceptado

{
"state": {
"desired": {
...
}
},
"metadata": {
"desired": {
"attribute1": {
"timestamp": timestamp
},
"attribute2": {
408
},
...
"attributeN": {
}
}
},
"timestamp": timestamp,
"version": version
}
Documento de estado de la respuesta /delta

{
"state": {
...
}
},
"metadata": {
"attribute1": {
},
"attribute2": {
},
...
"attributeN": {
}
},
"version": version
}
Documento de estado de respuesta /documentos

{
"previous" : {
"state": {
"desired": {
...
},
"reported": {
...
}
},
"metadata": {
"desired": {
"attribute1": {
409
},
"attribute2": {
},
...
"attributeN": {
}
},
"reported": {
"attribute1": {
},
"attribute2": {
},
...
"attributeN": {
}
}
},
"version": version-1
},
"current": {
"state": {
"desired": {
...
},
"reported": {
...
}
},
"metadata": {
"desired": {
"attribute1": {
},
"attribute2": {
},
...
"attributeN": {
}
},
"reported": {
"attribute1": {
},
"attribute2": {
},
...
"attributeN": {
}
}
},
"version": version
410
Documentos de respuesta de error
},
"clientToken": "token"
}
Propiedades del documento de estado de la respuesta

• previous: después de una actualización correcta, contiene el objeto state antes de la actualización.
• current: después de una actualización correcta, contiene el objeto state después de la actualización.
• state
• reported — Solo está presente si un objeto ha notificado datos en la sección reported y contiene
únicamente los campos que se encontraban en el documento de estado de la solicitud.
• desired — Solo está presente si un objeto ha notificado datos en la sección desired y contiene
únicamente los campos que se encontraban en el documento de estado de la solicitud.
• delta: solo presente si los datos desired difieren de los datos reported actuales de la sombra.
• metadata — Contiene las marcas temporales de cada atributo de las secciones desired y reported
para que se pueda determinar cuándo se actualizó el estado.
• timestamp — Fecha y hora de inicio en que AWS IoT generó la respuesta.
• clientToken — Solo está presente si se ha utilizando un token de cliente al publicar un JSON válido
en el tema /update.
• version — La versión actual del documento de la sombra del dispositivo compartido en AWS IoT. Se
aumenta en una unidad con relación a la versión anterior del documento.
Documentos de respuesta de error

Los documentos de respuesta de error tienen el formato siguiente:
{
"code": error-code,
"message": "error-message",
"clientToken": "token"
}
• code — Código de respuesta HTTP que indica el tipo de error.

• message — Mensaje de texto que proporciona información adicional.
• timestamp — Fecha y hora en que AWS IoT generó la respuesta. Esta propiedad no está presente en
todos los documentos de respuesta de error.
• clientToken — Solo está presente si se ha utilizando un token de cliente al publicar un JSON válido
en el tema /update.
Para obtener más información, consulte Mensajes de error relacionados con las sombras (p. 411).
Mensajes de error relacionados con las sombras

El servicio Device Shadow publica un mensaje en el tema de errores (a través de MQTT) si se produce
un error al intentar cambiar el documento de estado. Este mensaje solo se genera como respuesta a
una solicitud de publicación en uno de los temas $aws reservados. Si el cliente actualiza el documento
mediante la API REST, recibe el código de error HTTP como parte de su respuesta y no se genera un
mensaje de error MQTT.
411
Mensajes de error
Código de error HTTP Mensajes de error
400 (solicitud errónea) • JSON no válido

• Falta un nodo necesario: estado
• El nodo de estado debe ser un objeto
• El nodo deseado debe ser un objeto
• El nodo notificado debe ser un objeto
• Versión no válida
• ClientToken no válido
Note
Un token de cliente que sea mayor de 64 bytes

provocará esta respuesta.
• JSON contiene demasiados niveles de anidamiento; el
máximo permitido es 6
• El estado contiene un nodo no válido
401 (sin autorización) • Sin autorización
403 (prohibido) • prohibido
404 (no encontrado) • Objeto no encontrado
409 (conflicto) • Conflicto de versiones
413 (carga demasiado grande) • La carga supera el tamaño máximo permitido
415 (tipo de medio incompatible) • Codificación documentada incompatible, se admite la

codificación UTF-8
429 (demasiadas solicitudes) • El servicio Device Shadow generará este mensaje de error
cuando haya más de diez solicitudes en tránsito.
500 (error de servidor interno) • Error de servicio interno
412
Conceptos clave de trabajos
Trabajos
Los trabajos de AWS IoT se pueden usar para definir un conjunto de operaciones remotas que se envían a
uno o más dispositivos conectados a AWS IoT o que se ejecutan en uno o más de esos dispositivos.
Tip
Para ver ejemplos de documentos de trabajo, vea el ejemplo jobs-agent.js en el AWS IoT SDK
para JavaScript.

tarea
Un trabajo es una operación remota que se envía a uno o varios dispositivos conectados a AWS IoT
y se ejecuta en ellos. Por ejemplo, puede definir un trabajo que indique a un conjunto de dispositivos
descargar e instalar actualizaciones de firmware y aplicaciones, reiniciar, rotar certificados o realizar
operaciones remotas de solución de problemas.
documento de trabajo
Para crear un trabajo, primero debe crear un documento de trabajo, que es una descripción de las
operaciones remotas que deben realizar los dispositivos.
Los documentos de trabajo son documentos JSON con codificación UTF-8 y deben contener
la información que necesitan los dispositivos para realizar un trabajo. Un documento de trabajo
contendrá una o más URL en las que el dispositivo puede descargar una actualización o cualquier otro
dato. El documento de trabajo puede almacenarse en un bucket de Amazon S3 o insertarse con el
comando que crea el trabajo.
destino
Cuando cree un trabajo, debe especificar una lista de destinos que son los dispositivos que deben
realizar las operaciones. Los destinos pueden ser objetos, grupos de objetos (p. 102) o ambos. El
servicio Jobs de AWS IoT envía un mensaje a cada destino para informarle de que hay un trabajo
disponible.
ejecución de trabajo
Una ejecución de trabajo es una instancia de un trabajo en un dispositivo de destino. El objetivo

inicia una ejecución de trabajo descargando el documento de trabajo. A continuación, realiza las
operaciones especificadas en el documento e informa de su progreso a AWS IoT. Un número de
ejecución es un identificador único de una ejecución de trabajo en un destino específico. El servicio
Jobs proporciona comandos para realizar un seguimiento del progreso de una ejecución de trabajo en
un destino y del progreso de un trabajo en todos los destinos.
trabajo de instantánea
De forma predeterminada, un trabajo se envía a todos los destinos especificados al crearlo. Después
de que esos destinos finalicen el trabajo (o informen de que no pueden hacerlo), el trabajo se
completa.
trabajo continuo
Un trabajo continuo se envía a todos los destinos especificados al crearlo. Sigue ejecutándose y se
envía a todos los nuevos dispositivos (objetos) que se añaden al grupo de destino. Por ejemplo, puede
413
usarse un trabajo continuo para incorporar o actualizar dispositivos a medida que se añaden a un
grupo. Puede hacer que un trabajo sea continuo estableciendo un parámetro opcional al crearlo.
despliegues
Puede especificar la rapidez con la que se notifica a los destinos la ejecución de un trabajo pendiente.
Esto le permite crear un despliegue por etapas para administrar mejor las actualizaciones, los reinicios
y otras operaciones.
Se puede añadir el campo siguiente a la solicitud CreateJob para especificar el número máximo de
destinos de trabajo de los que se informará por minuto. En este ejemplo se establece una tasa de
despliegue estática.
"jobExecutionRolloutConfig": {
"maximumPerMinute": "integer"
}
También puede definir una tasa de despliegue variable con el campo exponentialRate. En el
siguiente ejemplo se crea un despliegue que tiene una tasa exponencial.
"jobExecutionsRolloutConfig": {
"exponentialRate": {
"baseRatePerMinute": integer,
"incrementFactor": integer,
"rateIncreaseCriteria": {
"numberOfNotifiedThings": integer, // Set one or the other
"numberOfSucceededThings": integer // of these two values.
},
"maximumPerMinute": integer
}
}
Para obtener más información acerca de cómo configurar despliegues de trabajos, consulte la sección
sobre despliegue de trabajos y configuración de anulaciones.
abort
Puede crear un conjunto de condiciones para anular despliegues una vez se cumplan los criterios
que especifique. Para obtener más información, consulte Despliegue de trabajos y configuración de
anulaciones.
URL prefirmadas
Para permitir a un dispositivo acceso seguro y por tiempo limitado a los datos más allá de los incluidos
en el propio documento de trabajo, puede usar URL de Amazon S3 prefirmadas. Puede colocar sus
datos en un bucket de Amazon S3 y añadir un enlace de marcador de posición para los datos en el
documento de trabajo. Cuando el servicio Jobs recibe una solicitud de documento de trabajo, analiza
ese documento en busca de enlaces de marcador de posición y los sustituye por URL de Amazon S3
prefirmadas.
El enlace de marcador de posición tiene la forma siguiente:
${aws:iot:s3-presigned-url:https://s3.amazonaws.com/bucket/key}
en donde bucket es el nombre del bucket y clave es el objeto en el bucket para el que se está
realizando la vinculación.
414
Administrar trabajos
En el Regiones de Pekín y Ningxia, las URL prefirmadas sólo funcionan si el propietario del recurso
tiene una licencia ICP. Para obtener más información, consulte Amazon Simple Storage Service en la
documentación Getting Started with AWS Services in China .
tiempos de espera
Los tiempos de espera de trabajos permiten recibir una notificación cada vez que la ejecución de un
trabajo se bloquea en el estado IN_PROGRESS durante un periodo de tiempo más largo de lo previsto.
Existen dos tipos de temporizadores: temporizadores en curso y temporizadores de pasos.
Al crear una tarea, puede establecer un valor para la propiedad inProgressTimeoutInMinutes del
objeto TimeoutConfig opcional. El temporizador en curso no se puede actualizar y se aplica a todas
las ejecuciones de trabajos para el trabajo. Cuando la ejecución de un trabajo permanece en estado
IN_PROGRESS durante un periodo superior a este intervalo, la ejecución del trabajo producirá un error
y cambiará al estado final TIMED_OUT. AWS IoT también publica una notificación MQTT.
También puede establecer un temporizador de pasos para la ejecución de un trabajo especificando un

valor para stepTimeoutInMinutes al llamar a UpdateJobExecution. El temporizador de pasos se
aplica únicamente a la ejecución del trabajo que actualice. Puede establecer un nuevo valor para este
temporizador cada vez que actualice la ejecución de un trabajo. También puede crear un temporizador
de pasos al llamar a StartNextPendingJobExecution. Si la ejecución del trabajo permanece en estado
IN_PROGRESS durante un periodo superior a este intervalo del temporizador de pasos, generará un
error y cambiará al estado terminal TIMED_OUT. El temporizador de pasos no tiene ningún efecto en el
temporizador en curso que establezca al crear un trabajo.
El siguiente diagrama y la descripción ilustran las formas en las que los tiempos de espera en curso y
por pasos interactúan entre sí.
Job Creation (Creación de trabajo): CreateJob establece un temporizador en curso que vence
en veinte minutos. Este temporizador se aplica a todas las ejecuciones de trabajos y no se puede
actualizar.
12:00 PM (00:00 h): Se inicia la ejecución del trabajo y cambia al estado IN_PROGRESS. El

temporizador en curso se pone en funcionamiento.
12:05 PM (00:05 h): UpdateJobExecution crea un temporizador de pasos con un valor de 7

minutos. Si no se crea un temporizador de pasos nuevo, la ejecución del trabajo agota su tiempo a las
12:12 PM (00:12 h).
12:10 PM (00:10 h): UpdateJobExecution crea un temporizador de pasos nuevo con un valor de

5 minutos. El temporizador del paso anterior se descarta. Si no se crea un temporizador de pasos
nuevo, la ejecución del trabajo agota su tiempo a las 12:15 PM (00:15 h).
12:13 PM (00:13 h): UpdateJobExecution crea un temporizador de pasos nuevo con un valor de

9 minutos. El tiempo de ejecución del trabajo se agota a las 12:20 (00:20 h) ya que el temporizador
en curso vence a las 12:20 (00:20 h). El temporizador de pasos no puede superar el límite absoluto
creado por el temporizador en curso.
UpdateJobExecution también puede descartar un temporizador de pasos que ya se ha creado

mediante la creación de un nuevo temporizador de pasos con un valor de -1.
Puede utilizar la consola de AWS IoT, la API HTTPS de trabajos, la AWS Command Line Interface o
los SDK de AWS para crear y administrar trabajos. Para obtener más información, consulte API de
415
administración y control de trabajo (p. 438), la referencia de comandos de la CLI de AWS: iot o SDK y
herramientas de AWS.
El objetivo principal de los trabajos es notificar a los dispositivos de una actualización de software o de
firmware. A la hora de enviar código a los dispositivos, la práctica recomendada es firmar el archivo
de código. Esto permite que los dispositivos detecten si el código se ha modificado en su tránsito. Las
instrucciones en la siguiente sección se han escrito partiendo del supuesto de que desea firmar con código
la actualización de software que está enviando a sus dispositivos.
Para obtener más información, consulte ¿Qué es Code Signing for AWS IoT?
Antes de crear un trabajo debe crear un documento del trabajo. Si utiliza la firma de código para AWS
IoT, debe cargar su documento de trabajo en un bucket de Amazon S3 con control de versiones. Para
obtener más información acerca de cómo crear un bucket de Amazon S3 y cargar archivos en él, consulte
la sección sobre comenzar a usar Amazon Simple Storage Service en la guía de introducción para Amazon
S3.
Su documento del trabajo puede contener una URL de Amazon S3 que apunte a su archivo de código
(u otro archivo). Las URL de Amazon S3 prefirmadas son válidas durante un tiempo limitado, por lo que
no se generan hasta que un dispositivo solicita un documento de trabajo. Dado que la URL prefirmada
no se ha creado cuando se crea el documento del trabajo, en su lugar se pone una URL de marcador de
posición en el documento de trabajo. La URL de marcador de posición tiene un aspecto similar al siguiente:
${aws:iot:s3-presigned-url:https://s3.region.amazonaws.com/<bucket>/<code
file>} donde bucket es el bucket de Amazon S3 que contiene el archivo de código y code file es la
clave de Amazon S3 del archivo de código.
Cuando un dispositivo solicita el documento de trabajo, AWS IoT genera la URL prefirmada y sustituye la
URL de marcador de posición por la URL prefirmada. El documento del trabajo se envía al dispositivo.
Al crear un trabajo que usa direcciones URL de Amazon S3 prefirmadas, debe proporcionar un rol de IAM
que conceda permiso para descargar archivos desde el bucket de Amazon S3 donde se guardan los datos
o las actualizaciones. El rol debe conceder permiso también para que AWS IoT asuma el rol.
Puede especificar un tiempo de espera opcional para la URL prefirmada. Para obtener más información,
consulte CreateJob (p. 454).
Para conceder permiso al servicio de trabajos para que asuma el rol
1. Inicie sesión en la Consola de administración de AWS y abra la consola de IAM en https://

console.aws.amazon.com/iam/.
2. Seleccione Roles en el panel de navegación.
3. Busque el rol y elíjalo.
4. En la pestaña Trust Relationships (Relaciones de confianza), elija Edit trust relationship (Editar
relación de confianza).
5. En la página Edit Trust Relationship (Editar relación de confianza), sustituya el documento de la
política por el siguiente JSON:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
"Service": [
"iot.amazonaws.com"
]
},
416
Creación y administración de trabajos (consola)
}
]
}
6. Elija Update Trust Policy.

7. Si el trabajo utiliza un documento de trabajo que es un objeto de Amazon S3, elija Permissions
(Permisos) y, con el JSON siguiente, añada una política que conceda permiso para descargar archivos
desde su bucket de Amazon S3:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "s3:GetObject",
"Resource": "arn:aws:s3:::your_S3_bucket/*"
}
]
}
Creación y administración de trabajos (consola)

Si utiliza firma con código para AWS IoT, debe agregar dos URL de marcador de posición a su documento
de trabajo:
El marcador de posición para el archivo de código deberá ser parecido al siguiente: ${aws:iot:s3-
presigned-url:https://s3.amazonaws.com/<my-s3-bucket>/<my-code-file>}.
Note
En la actualidad, no se admiten versiones para marcadores de posición de URL prefirmadas para

los trabajos. Si actualiza el archivo de código y lo copia en la misma ubicación de Amazon S3,
debe crear una nueva firma y, a continuación, hacer referencia a la nueva versión de la firma en el
documento del trabajo.
El marcador de posición para la firma deberá ser parecido al siguiente: ${aws:iot:code-sign-

signature:s3://<region>.<my-s3-bucket>/<my-code-file>@<code-file-version-id>}.
Para crear un trabajo
1. Vaya a la consola de AWS IoT.

2. En el panel de navegación, elija Manage (Administrar) y, a continuación, Jobs (Trabajos).
3. Elija Create a job (Crear un trabajo).
4. Elija Create a custom job (Crear un trabajo personalizado).
5. Escriba un ID alfanumérico para el trabajo y una descripción opcional.
Note
No es recomendable utilizar datos personales en las descripciones o ID de trabajo.

6. Seleccione el dispositivo o los grupos de dispositivos que desea actualizar.
7. En Add a job file (Añadir un archivo de trabajo), elija Select (Seleccionar) y, a continuación, seleccione
el documento del trabajo.
8. Seleccione Sign image for me (Firmar imagen para mí). Si no va a firmar con código la actualización
puede omitir este paso.
417
Creación y administración de trabajos (CLI)
9. Cree o elija un perfil de firma con código. Si no va a firmar con código la actualización puede omitir
este paso.
10. En Pre-sign resource URLs (Prefirmar direcciones URL de recursos), elija I want to pre-sign my URLs
and have configured my job file (Quiero prefirmar mis direcciones URL y hacer que se configure el
archivo de mi trabajo. Si no va a firmar con código la actualización puede omitir este paso.
11. Elija un rol y un tiempo de caducidad para la URL prefirmada.
12. En Job type (Tipo de trabajo), elija la opción adecuada para la actualización y, a continuación,
seleccione Next (Siguiente).
13. Especifique los valores de configuración avanzada y, a continuación, seleccione Create (Crear).
Después de crear el trabajo, la consola genera una firma JSON y la coloca en su documento del trabajo.
Puede usar la consola de AWS IoT para ver el estado de un trabajo, cancelarlo o eliminarlo.
1. Vaya a la consola de AWS IoT.

2. En el panel de navegación, elija Manage (Administrar) y, a continuación, Jobs (Trabajos).

En esta sección se describe cómo crear y administrar trabajos.
Creación de trabajos
Utilice el comando CreateJob para crear un trabajo de AWS IoT. El trabajo se pone en cola para la
ejecución en los destinos (objetos o grupos de objetos) que especifique. Para crear un trabajo de AWS
IoT necesita un documento de trabajo que pueda incluirse en el cuerpo de la solicitud o como un enlace a
un documento de Amazon S3. Si el trabajo incluye la descarga de archivos mediante direcciones URL de
Amazon S3 prefirmadas, necesita un ARN de rol de IAM que tenga permiso para descargar el archivo y
conceda permiso al servicio Jobs de AWS IoT para asumir el rol.
Firma con código con trabajos

Si utiliza la firma con código para AWS IoT, debe iniciar un trabajo de firma con código e incluir el resultado
en el documento del trabajo. Utilice el comando start-signing-job para crear un trabajo de firma con código.
start-signing-job devuelve un ID de trabajo. Utilice el comando describe-signing-job para obtener la
ubicación de Amazon S3 donde se almacena la firma. Después podrá descargar la firma desde Amazon
S3. Para obtener más información sobre trabajos de firma con código, consulte la sección sobre firma con
código para AWS IoT.
El documento de trabajo debe contener un marcador de posición de URL prefirmada para su archivo de
código, y el resultado de la firma JSON en un bucket de Amazon S3 con el comando start-signing-job,
encerrado en un elemento codesign:
{
"presign": "${aws:iot:s3-presigned-url:https://s3.region.amazonaws.com/bucket/image}",
"codesign": {
"rawPayloadSize": <image-file-size>,
"signature": <signature>,
"signatureAlgorithm": <signature-algorithm>,
"payloadLocation": {
"s3": {
"bucketName": <my-s3-bucket>,
"key": <my-code-file>,
"version": <code-file-version-id>
}
418
}
}
}
Creación de un trabajo con un documento de trabajo

El siguiente comando muestra cómo crear un trabajo mediante un documento de trabajo (job-
document.json) almacenado en un bucket de Amazon S3 (jobBucket) y un rol con permiso para
descargar archivos desde Amazon S3 (S3DownloadRole).

--job-id 010 \
--targets arn:aws:iot:us-east-1:123456789012:thing/thingOne \
--document-source https://s3.amazonaws.com/my-s3-bucket/job-document.json \
--timeout-config inProgressTimeoutInMinutes=100 \
--job-executions-rollout-config "{ \"exponentialRate\": { \"baseRatePerMinute\": 50,
\"incrementFactor\": 2, \"rateIncreaseCriteria\": { \"numberOfNotifiedThings\": 1000,
\"numberOfSucceededThings\": 1000}}, \"maximumPerMinute\": 1000}" \
--abort-config "{ \"criteriaList\": [ { \"action\": \"CANCEL\", \"failureType\":
\"FAILED\", \"minNumberOfExecutedThings\": 100, \"thresholdPercentage\": 20}, { \"action
\": \"CANCEL\", \"failureType\": \"TIMED_OUT\", \"minNumberOfExecutedThings\": 200,
\"thresholdPercentage\": 50}]}" \
--presigned-url-config "{\"roleArn\":\"arn:aws:iam::123456789012:role/
S3DownloadRole\", \"expiresInSec\":3600}"
El trabajo se ejecuta en thingOne.
El parámetro timeout-config opcional especifica la cantidad de tiempo que cada dispositivo tiene para
finalizar su ejecución del trabajo. El temporizador comienza cuando el estado de ejecución del trabajo se
establece en IN_PROGRESS. Si el estado de ejecución del trabajo no se establece en otro estado final
antes de que se cumpla el plazo, se establecerá en TIMED_OUT.
El temporizador en curso no se puede actualizar y se aplica a todas las ejecuciones de trabajos para
el trabajo. Cuando la ejecución de un trabajo permanece en estado IN_PROGRESS durante un periodo
superior a este intervalo, la ejecución del trabajo producirá un error y cambiará al estado final TIMED_OUT.
AWS IoT también publica una notificación MQTT.
Para obtener más información acerca de cómo crear configuraciones sobre despliegues de trabajos y
anulaciones, consulte Despliegue de trabajos y configuración de anulaciones.
Note
Los documentos de Jobs que está especificados como archivos de Amazon S3 se recuperan en el
momento en el que crea el trabajo. Si cambia el contenido del archivo Amazon S3 que usó como
origen de su documento de trabajo después de haber creado el trabajo, no cambia lo que se envía
a los destinos del trabajo.
Actualización de un trabajo
Para actualizar un trabajo se utiliza el comando UpdateJob. Puede actualizar los campos description,
presignedUrlConfig, jobExecutionsRolloutConfig, abortConfig y timeoutConfig para un
trabajo.
aws iot update-job \

--job-id 010 \
--description "updated description" \
--timeout-config inProgressTimeoutInMinutes=100 \
--job-executions-rollout-config "{ \"exponentialRate\": { \"baseRatePerMinute\": 50,
\"incrementFactor\": 2, \"rateIncreaseCriteria\": { \"numberOfNotifiedThings\": 1000,
\"numberOfSucceededThings\": 1000}, \"maximumPerMinute\": 1000}}" \
419
--abort-config "{ \"criteriaList\": [ { \"action\": \"CANCEL\", \"failureType\":

\"FAILED\", \"minNumberOfExecutedThings\": 100, \"thresholdPercentage\": 20}, { \"action
\": \"CANCEL\", \"failureType\": \"TIMED_OUT\", \"minNumberOfExecutedThings\": 200,
\"thresholdPercentage\": 50}]}" \
--presigned-url-config "{\"roleArn\":\"arn:aws:iam::123456789012:role/S3DownloadRole\",
\"expiresInSec\":3600}"
Para obtener más información, consulte Despliegue de trabajos y configuración de anulaciones.
Cancelación de un trabajo
Para cancelar un trabajo se utiliza el comando CancelJob. Al cancelar un trabajo, AWS IoT dejará de
desplegar nuevas ejecuciones de trabajos para el trabajo. También cancela la ejecución de cualquier
trabajo que se encuentre en estado QUEUED. AWS IoT deja las ejecuciones de los trabajos en estado final
intactas, ya que el dispositivo ya ha completado el trabajo. Si el estado de la ejecución de un trabajo es
IN_PROGRESS, también se mantendrá intacta a menos que se use el parámetro opcional --force.
El siguiente comando muestra cómo cancelar un trabajo con ID 010.
aws iot cancel-job --job-id 010
El comando muestra el resultado siguiente:
{
"jobArn": "string",
"jobId": "string",
"description": "string"
}
Cuando se cancela un trabajo, se cancelan las ejecuciones de trabajos con estado QUEUED. Las
ejecuciones de trabajos en estado IN_PROGRESS se cancelarán si especifica el parámetro opcional --
force. Las ejecuciones de trabajo con un estado terminal no se cancelarán.
Warning
Si se cancela un trabajo en estado IN_PROGRESS (al establecer el parámetro --force), se

cancelarán las ejecuciones de trabajos en curso, y se hará que el dispositivo que está ejecutando
el trabajo no pueda actualizar el estado de ejecución del trabajo. Actúe con precaución y
asegúrese de que cada dispositivo que esté ejecutando un trabajo cancelado pueda recuperarse
a un estado válido.
El estado de un trabajo cancelado o de una de sus ejecuciones de trabajos es a la larga coherente: AWS
IoT detiene lo antes posible la programación de nuevas ejecuciones de trabajos y las ejecuciones en
dispositivos de trabajos con estado QUEUED. Cambiar el estado de la ejecución de un trabajo a CANCELED
puede llevar algo de tiempo, según el número de dispositivos y otros factores.
Si un trabajo se cancela porque cumple los criterios definidos por un objeto AbortConfig, el servicio
añade valores rellenados automáticamente para los campos reasonCode y comment. Puede crear sus
propios valores reasonCode cuando el trabajo se cancela por iniciativa del usuario.
Cancelación de una ejecución de trabajo

Puede utilizar el comando CancelJobExecution para cancelar la ejecución de un trabajo en un dispositivo.
Cancela la ejecución de un trabajo que se encuentra en estado QUEUED. Si desea cancelar la ejecución de
un trabajo en curso, debe utilizar el parámetro --force.
420
El siguiente comando muestra cómo cancelar la ejecución de un trabajo del trabajo 010 que se ejecuta en
myThing.
aws iot cancel-job-execution --job-id 010 --thing-name myThing
El comando no muestra ninguna salida.
Se cancela la ejecución de un trabajo que se encuentra en estado QUEUED. La ejecución de un trabajo en

estado IN_PROGRESS se cancela si especifica el parámetro opcional --force. Las ejecuciones de trabajo
con un estado terminal no se pueden cancelar.
Warning
Cuando se cancela la ejecución de un trabajo con estado IN_PROGRESS, el dispositivo no

puede actualizar el estado de ejecución del trabajo. Actúe con precaución y asegúrese de que el
dispositivo pueda recuperarse a un estado válido.
Si la ejecución del trabajo se encuentra en estado final, o si la ejecución del trabajo está en
estado IN_PROGRESS y el parámetro --force no está definido en true, el comando genera
InvalidStateTransitionException.
El estado de la ejecución de un trabajo cancelada es a la larga coherente. Cambiar el estado de la

ejecución de un trabajo a CANCELED puede llevar algo de tiempo, dependiendo de varios factores.
Eliminación de un trabajo
Puede utilizar el comando DeleteJob para eliminar un trabajo y sus ejecuciones. De forma predeterminada,
solo puede eliminar un trabajo en estado final (SUCCEEDED o CANCELED). En caso contrario, se produce
una excepción. Podrá eliminar un trabajo con estado IN_PROGRESS si el parámetro force está definido
en true.
Ejecute el siguiente comando para eliminar un trabajo:
aws iot delete-job --job-id 010 --force|--no-force

Warning
Cuando se elimina un trabajo que se encuentra en estado IN_PROGRESS, el dispositivo que

está ejecutando el trabajo no puede obtener acceso a la información del trabajo ni actualizar el
estado de su ejecución. Actúe con precaución y asegúrese de que cada dispositivo que ejecute un
trabajo eliminado pueda recuperarse a un estado válido.
Eliminar un trabajo podría llevar algún tiempo, en función del número de ejecuciones de trabajos creadas
para el trabajo y otros factores. Aunque el trabajo se esté eliminando, como estado del trabajo se
muestra DELETION_IN_PROGRESS. Si se intenta eliminar o cancelar un trabajo cuyo estado ya es
DELETION_IN_PROGRESS, se producirá un error.
Solo puede haber 10 trabajos con estado DELETION_IN_PROGRESS al mismo tiempo. De lo contrario, se
genera LimitExceededException.
Obtención de un documento de trabajo

Utilice el comando GetJobDocument para recuperar un documento de trabajo para un trabajo. Un
documento de trabajo es una descripción de las operaciones remotas que deben ejecutar los dispositivos.
421
Ejecute el siguiente comando para obtener un documento de trabajo:
aws iot get-job-document --job-id 010
El comando devuelve el documento de trabajo para el trabajo especificado:
{
"document": "{\n\t\"operation\":\"install\",\n\t\"url\":\"http://amazon.com/
firmWareUpate-01\",\n\t\"data\":\"${aws:iot:s3-presigned-url:https://s3.amazonaws.com/job-
test-bucket/datafile}\"\n}"
}
Note
Al usar este comando para recuperar un documento de trabajo, las URL de marcador de posición
no se sustituirán por URL de Amazon S3 prefirmadas. Cuando un dispositivo llama a la API de
MQTT GetPendingJobExecutions (p. 500), las URL de marcador de posición se sustituyen por
URL de Amazon S3 prefirmadas en el documento de trabajo.
Enumeración de trabajos
Puede utilizar el comando ListJobs para obtener una lista de todos los trabajos de su cuenta de AWS. Los
datos del trabajo y los datos de ejecución del trabajo se conservan durante un tiempo limitado. Ejecute el
siguiente comando para listar todos los trabajos de su cuenta de AWS:
aws iot list-jobs
El comando devuelve todos los trabajos en su cuenta ordenados por estado del trabajo:
{
"jobs": [
{
"status": "IN_PROGRESS",
"lastUpdatedAt": 1486687079.743,
"jobArn": "arn:aws:iot:us-east-1:123456789012:job/013",
"createdAt": 1486687079.743,
"targetSelection": "SNAPSHOT",
"jobId": "013"
},
{
"status": "SUCCEEDED",
"createdAt": 1486685868.444,
"completedAt": 148668789.690,
"jobId": "012"
},
{
"status": "CANCELED",
"createdAt": 1486678850.575,
"jobId": "011"
}
]
}
422
Descripción de un trabajo
Ejecute el comando DescribeJob para obtener el estado de un trabajo. El siguiente comando muestra
cómo describir un trabajo:
$ aws iot describe-job --job-id 010
El comando devuelve el estado de un trabajo especificado. Por ejemplo:
{
"documentSource": "https://s3.amazonaws.com/job-test-bucket/job-document.json",
"job": {
"targets": [
"arn:aws:iot:us-east-1:123456789012:thing/myThing"
],
"jobProcessDetails": {
"numberOfCanceledThings": 0,
"numberOfFailedThings": 0,
"numberOfInProgressThings": 0,
"numberOfQueuedThings": 0,
"numberOfRejectedThings": 0,
"numberOfRemovedThings": 0,
"numberOfSucceededThings": 0,
"numberOfTimedOutThings": 0,
"processingTargets": [
arn:aws:iot:us-east-1:123456789012:thing/thingOne,
arn:aws:iot:us-east-1:123456789012:thinggroup/thinggroupOne,
arn:aws:iot:us-east-1:123456789012:thing/thingTwo,
arn:aws:iot:us-east-1:123456789012:thinggroup/thinggroupTwo
]
},
"presignedUrlConfig": {
"expiresInSec": 60,
"roleArn": "arn:aws:iam::123456789012:role/S3DownloadRole"
},
"jobId": "010",
"createdAt": 1486593195.006,
},
}
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
"failureType": "string",
"minNumberOfExecutedThings": integer,
"thresholdPercentage": integer
}
]
},
"timeoutConfig": {
423
"inProgressTimeoutInMinutes": number
}
}
}
Enumeración de ejecuciones para un trabajo

Un trabajo que se ejecuta en un dispositivo específico se representa mediante un objeto de ejecución de
trabajo. Ejecute el comando ListJobExecutionsForJob para enumerar todas las ejecuciones de trabajo para
un trabajo. A continuación se muestra cómo enumerar las ejecuciones para un trabajo:
aws iot list-job-executions-for-job --job-id 010
El comando devuelve una lista de ejecuciones de trabajo:
{
"executionSummaries": [
{
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/thingOne",
"jobExecutionSummary": {
"status": "QUEUED",
"queuedAt": 1486593196.378,
"executionNumber": 1234567890
}
},
{
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/thingTwo",
"queuedAt": 1486593196.378,
"startedAt": 1486593345.659,
}
}
]
}
Enumeración de ejecuciones de trabajo para un objeto

Ejecute el comando ListJobExecutionsForThing para enumerar todas las ejecuciones de trabajo que se
ejecutan en un objeto. A continuación se muestra cómo listar las ejecuciones de trabajos para un objeto:
aws iot list-job-executions-for-thing --thing-name thingOne
El comando devuelve una lista de ejecuciones de trabajo que se ejecutan o se han ejecutado en el objeto
especificado:
{
{
"status": "QUEUED",
"queuedAt": 1486687082.071,
},
424
"jobId": "013"
},
{
"startAt": 1486685870.729,
"queuedAt": 1486685870.729,
},
"jobId": "012"
},
{
"status": "SUCCEEDED",
"startAt": 1486678853.415,
"queuedAt": 1486678853.415,
},
"jobId": "011"
},
{
"startAt": 1486593196.378,
"queuedAt": 1486593196.378,
},
"jobId": "010"
}
]
}
Descripción de una ejecución de trabajo

Ejecute el comando DescribeJobExecution para obtener el estado de la ejecución de un trabajo. Debe
especificar un ID de trabajo y el nombre del objeto y, opcionalmente, un número de ejecución para
identificar la ejecución del trabajo. A continuación se muestra cómo describir la ejecución de un trabajo:
aws iot describe-job-execution --job-id 017 --thing-name thingOne
El comando devuelve JobExecution (p. 443). Por ejemplo:
{
"execution": {
"jobId": "017",
"executionNumber": 4516820379,
"thingArn": "arn:aws:iot:us-east-1:123456789012:thing/thingOne",
"versionNumber": 123,
"createdAt": 1489084805.285,
"startedAt": 1489086279.937,
"approximateSecondsBeforeTimedOut": 100,
"statusDetails": {
"detailsMap": {
"percentComplete": "10"
}
}
425
Dispositivos y trabajos
}
}
Eliminación de una ejecución de trabajo

Ejecute el comando DeleteJobExecution para eliminar la ejecución de un trabajo. Debe especificar un
ID de trabajo, un nombre de objeto y un número de ejecución para identificar la ejecución del trabajo. A
continuación se muestra cómo eliminar la ejecución de un trabajo:
aws iot delete-job-execution --job-id 017 --thing-name thingOne --execution-number

1234567890 --force|--no-force
De forma predeterminada, el estado de ejecución de los trabajos debe ser QUEUED o un estado final
(SUCCEEDED, FAILED, REJECTED, TIMED_OUT, REMOVED o CANCELED). En caso contrario, se produce un
error. Para eliminar la ejecución de un trabajo con estado IN_PROGRESS, puede establecer el parámetro
force en true.
Warning
Cuando se elimina la ejecución de un trabajo con estado IN_PROGRESS, el dispositivo que está
ejecutando el trabajo no puede obtener acceso a la información del trabajo ni actualizar el estado
de su ejecución. Actúe con precaución y asegúrese de que el dispositivo pueda recuperarse a un
estado válido.
Device communication with jobs
Los dispositivos pueden comunicarse con el servicio Jobs de AWS IoT mediante uno de estos
métodos:
• MQTT
• HTTP Signature Version 4
• HTTP TLS
Using the MQTT protocol
La comunicación entre el servicio Jobs de AWS IoT y sus dispositivos puede realizarse a través
del protocolo MQTT. Los dispositivos se suscriben a temas MQTT para recibir notificaciones de
trabajos nuevos y respuestas del servicio Jobs de AWS IoT. Los dispositivos publican en temas MQTT
para consultar o actualizar el estado de una ejecución de trabajo. Cada dispositivo tiene su propio
tema MQTT general. Para obtener más información acerca de cómo publicar en temas de MQTT y
suscribirse a ellos, consulte Agente de mensajes de AWS IoT (p. 266).
Note
Debe utilizar el punto de enlace correcto al comunicarse con el servicio Jobs de AWS IoT a
través de MQTT. Utilice el comando DescribeEndpoint para buscarlo. Por ejemplo, si ejecuta
este comando:
aws iot describe-endpoint --endpoint-type iot:Data
426
obtendrá un resultado similar al siguiente:
{
"endpointAddress": "a1b2c3d4e5f6g7.iot.us-west-2.amazonaws.com"
}
Con este método, el dispositivo utiliza su propio certificado y su propia clave privada para
autenticarse en el servicio Jobs de AWS IoT.
Los dispositivos pueden realizar las siguientes tareas:
• Recibir notificaciones cuando se añade o se quita una ejecución de trabajo de la lista de ejecuciones
de trabajo pendientes para un dispositivo mediante la suscripción al tema de MQTT $aws/
things/thing-name/jobs/notify, donde thing-name es el nombre del objeto asociado al
dispositivo.
• Recibir notificaciones cuando la siguiente ejecución de trabajo pendiente ha cambiado mediante la
suscripción al tema de MQTT $aws/things/thing-name/jobs/notify-next, donde thing-
name es el nombre del objeto asociado al dispositivo.
• Actualizar el estado de una ejecución de trabajo llamando a la API UpdateJobExecution (p. 514).
• Consultar el estado de una ejecución de trabajo llamando a la API DescribeJobExecution (p. 509).
• Recuperar una lista de ejecuciones de trabajo pendientes llamando a la API
GetPendingJobExecutions (p. 500).
• Recuperar la siguiente ejecución de trabajo pendiente llamando a la API
DescribeJobExecution (p. 509) con jobId $next.
• Obtener e iniciar la ejecución de trabajo pendiente siguiente llamando a la API
StartNextPendingJobExecution (p. 504).
El servicio Jobs de AWS IoT publica los mensajes de éxito y error en un tema de MQTT. El tema se
forma añadiendo accepted o rejected al tema utilizado para realizar la solicitud. Por ejemplo, si se
publica un mensaje de solicitud en el tema $aws/things/myThing/jobs/get, el servicio Jobs de
AWS IoT publica mensajes de éxito en el tema $aws/things/myThing/jobs/get/accepted y
publica los mensajes rechazados en el tema $aws/things/myThing/jobs/get/rejected.
Using HTTP Signature Version 4
La comunicación entre el servicio Jobs de AWS IoT y los dispositivos puede realizarse a través de
HTTP Signature Version 4 en el puerto 443. Este es el método utilizado por los SDK de AWS y la CLI.
Para obtener más información sobre estas herramientas, consulte la referencia de comandos de la CLI
de AWS: iot-jobs-data o SDK y herramientas de AWS y consulte la sección IotJobsDataPlane para su
idioma.
Note
Debe utilizar el punto de enlace correcto al comunicarse con el servicio Jobs de AWS IoT
a través de HTTP Signature Version 4 o con un SDK de AWS o un comando de la CLI
IotJobsDataPlane. Utilice el comando DescribeEndpoint para buscarlo. Por ejemplo, si
ejecuta este comando:
aws iot describe-endpoint --endpoint-type iot:Jobs
{
"endpointAddress": "a1b2c3d4e5f6g7.jobs.iot.us-west-2.amazonaws.com"
}
427
Programación de dispositivos para trabajar con trabajos
Con este método de comunicación, el dispositivo utiliza credenciales de IAM para

autenticarse en el servicio Jobs de AWS IoT.
Los siguientes comandos están disponibles a través de este método:
• DescribeJobExecution
aws iot-jobs-data describe-job-execution ...

• GetPendingJobExecutions
aws iot-jobs-data get-pending-job-executions ...

• StartNextPendingJobExecution
aws iot-jobs-data start-next-pending-job-execution ...

• UpdateJobExecution
aws iot-jobs-data update-job-execution ...
Using HTTP TLS
La comunicación entre el servicio Jobs de AWS IoT y los dispositivos puede producirse a través de
HTTP TLS en el puerto 8443 utilizando un cliente de software de terceros que admita este protocolo.
Note
Debe utilizar el punto de enlace correcto al comunicarse con el servicio Jobs de AWS IoT
a través de HTTP TLS. Utilice el comando DescribeEndpoint para buscarlo. Por ejemplo, si
ejecuta este comando:
aws iot describe-endpoint --endpoint-type iot:Jobs
{
"endpointAddress": "a1b2c3d4e5f6g7.jobs.iot.us-west-2.amazonaws.com"
}
Con este método, el dispositivo utiliza la autenticación basada en certificados X.509 (por
ejemplo, utilizando su propio certificado y su propia clave privada).
Los siguientes comandos están disponibles a través de este método:
Programación de dispositivos para trabajar con

trabajos
En los ejemplos de esta sección se utiliza MQTT para ilustrar cómo funciona un dispositivo con el servicio
Jobs de AWS IoT. También puede utilizar los comandos de la CLI o la API correspondientes. Para estos
ejemplos, supondremos que un dispositivo llamado MyThing se suscribe a los siguientes temas de MQTT:
• $aws/things/MyThing/jobs/notify (o bien $aws/things/MyThing/jobs/notify-next)
428
• $aws/things/MyThing/jobs/get/accepted
• $aws/things/MyThing/jobs/get/rejected
• $aws/things/MyThing/jobs/jobId/get/accepted
• $aws/things/MyThing/jobs/jobId/get/rejected
Si utiliza firma con código para AWS IoT, el código del dispositivo debe verificar la firma del archivo de
código. La firma se encuentra en el documento de trabajo, en la propiedad codesign. Para obtener más
información sobre cómo verificar una firma en un archivo de código, consulte el ejemplo de agente de
dispositivo.
Flujo de trabajo del dispositivo

Hay dos formas en las que un dispositivo puede gestionar los trabajos que debe ejecutar.
Option a: Get the next job
1. Cuando un dispositivo está online, debe suscribirse al tema notify-next del dispositivo.
2. Llame a la API de MQTT de DescribeJobExecution (p. 509) con jobId $next para obtener
el siguiente trabajo, su documento de trabajo y otros detalles, incluido el estado guardado en
statusDetails. Si el documento de trabajo tiene una forma en archivo de código, debe verificar
la firma antes de seguir procesando la solicitud del trabajo.
3. Llame a la API de MQTT de UpdateJobExecution (p. 514) para actualizar el estado del trabajo.
También puede combinar este paso y el anterior en una llamada. El dispositivo puede llamar a
4. Si lo prefiere, puede añadir un temporizador de pasos estableciendo un valor
para stepTimeoutInMinutes si llama a UpdateJobExecution (p. 514) o
5. Realice las acciones especificadas por el documento de trabajo con la API de MQTT de
UpdateJobExecution (p. 514) para informar del progreso del trabajo.
6. Siga monitorizando la ejecución del trabajo llamando a la API de MQTT
DescribeJobExecution (p. 509) con este jobId. Si la ejecución de trabajo se cancela o se elimina
al mismo tiempo que el dispositivo está ejecutando el trabajo, el dispositivo debería ser capaz de
recuperarse a un estado válido.
7. Llame a la API de MQTT de UpdateJobExecution (p. 514) cuando termine con el trabajo para
actualizar el estado del trabajo e informar del éxito o error.
8. El siguiente trabajo disponible para su ejecución (si lo hubiera) cambiará, puesto que el estado
de la ejecución del trabajo ha cambiado a estado final. Se notifica al dispositivo que la siguiente
ejecución de trabajo pendiente ha cambiado. En este momento, el dispositivo debe continuar
como se describe en el paso 2.
Si el dispositivo sigue online, seguirá recibiendo notificaciones de la siguiente ejecución de trabajo

pendiente, incluidos sus datos de ejecución del trabajo, cuando complete un trabajo o cuando se
añada una nueva ejecución de trabajo pendiente. Cuando se produzca esto, el dispositivo seguirá
como se describe en el paso 2.
Option b: Pick from available jobs
1. Cuando un dispositivo está online, debe suscribirse al tema notify del objeto.
2. Llame a la API de MQTT de GetPendingJobExecutions (p. 500) para obtener una lista de
ejecuciones de trabajo pendientes.
3. Si la lista contiene una o más ejecuciones de trabajo, elija una.
4. Llame a la API de MQTT DescribeJobExecution (p. 509) para obtener el documento de trabajo y
otros detalles, incluido cualquier estado guardado en statusDetails.
429
5. Llame a la API de MQTT de UpdateJobExecution (p. 514) para actualizar el estado del trabajo.
Si el campo includeJobDocument está establecido en true en este comando, el dispositivo
puede omitir el paso anterior y recuperar el documento de trabajo en este momento.
6. Si lo prefiere, puede añadir un temporizador de pasos estableciendo un valor para
stepTimeoutInMinutes si llama a UpdateJobExecution (p. 514).
7. Realice las acciones especificadas por el documento de trabajo con la API de MQTT de
UpdateJobExecution (p. 514) para informar del progreso del trabajo.
8. Siga monitorizando la ejecución del trabajo llamando a la API de MQTT
DescribeJobExecution (p. 509) con este jobId. Si la ejecución de trabajo se cancela o se elimina
al mismo tiempo que el dispositivo está ejecutando el trabajo, el dispositivo debería ser capaz de
9. Llame a la API de MQTT de UpdateJobExecution (p. 514) cuando termine con el trabajo para
actualizar el estado del trabajo e informar del éxito o error.
Si el dispositivo continúa online, se le notificarán todas las ejecuciones de trabajo pendientes cuando
una nueva ejecución de trabajo pendiente esté disponible. Cuando se produzca esto, el dispositivo
podrá seguir como se describe en el paso 2.
Si el dispositivo no puede ejecutar el trabajo, debe llamar a la API de MQTT de

UpdateJobExecution (p. 514) para actualizar el estado del trabajo a REJECTED.
Inicio de un nuevo trabajo

New job notification
Cuando se crea un trabajo nuevo, el servicio Jobs de AWS IoT publica un mensaje en el tema $aws/
things/thing-name/jobs/notify para cada dispositivo de destino.
More Information(1)
El mensaje contiene la siguiente información:
{
"timestamp":1476214217017,
"jobs":{
"QUEUED":[{
"jobId":"0001",
"queuedAt":1476214216981,
"lastUpdatedAt":1476214216981,
"versionNumber" : 1
}]
}
}
El dispositivo recibe este mensaje en el tema '$aws/things/thingName/jobs/notify' cuando

la ejecución del trabajo está en la cola.
Get job information
Para obtener más información sobre la ejecución de un trabajo, el dispositivo llama a la API de MQTT
DescribeJobExecution (p. 509) con el campo includeJobDocument establecido en true (el valore
predeterminado).
More Information(2)
Si la solicitud es correcta, el servicio Jobs de AWS IoT publica un mensaje en el tema $aws/things/
MyThing/jobs/0023/get/accepted:
430
{
"clientToken" : "client-001",
"timestamp" : 1489097434407,
"execution" : {
"approximateSecondsBeforeTimedOut": number,
"jobId" : "023",
"status" : "QUEUED",
"queuedAt" : 1489097374841,
"lastUpdatedAt" : 1489097374841,
"versionNumber" : 1,
"jobDocument" : {
< contents of job document >
}
}
}
Note
Si se produce un error en la solicitud, el servicio Jobs de AWS IoT publica un mensaje en el

tema $aws/things/MyThing/jobs/0023/get/rejected.
El dispositivo ahora tiene el documento de trabajo que puede usar para realizar las operaciones remotas
para el trabajo. Si el documento de trabajo contiene una URL prefirmada de Amazon S3 el dispositivo
puede usar esa URL para descargar los archivos necesarios para el trabajo.
Informe del estado de la ejecución de trabajo

Update execution status
A medida que el dispositivo ejecute el trabajo, puede llamar a la API de MQTT de

UpdateJobExecution (p. 514) para actualizar el estado de la ejecución de trabajo.
Por ejemplo, un dispositivo puede actualizar el estado de ejecución de trabajo a IN_PROGRESS

mediante la publicación del siguiente mensaje en el tema $aws/things/MyThing/jobs/0023/
update:
{
"status":"IN_PROGRESS",
"statusDetails": {
"progress":"50%"
},
"expectedVersion":"1",
"clientToken":"client001"
}
Jobs responde mediante la publicación de un mensaje en el tema $aws/things/MyThing/

jobs/0023/update/accepted o $aws/things/MyThing/jobs/0023/update/rejected:
{
"clientToken":"client001",
"timestamp":1476289222841
}
El dispositivo puede combinar las dos solicitudes anteriores llamando a

StartNextPendingJobExecution (p. 504). Esto obtiene e inicia la ejecución del trabajo pendiente y
431
permite al dispositivo actualizar el estado de ejecución del trabajo. Esta solicitud también devuelve el
documento de trabajo cuando hay una ejecución de trabajo pendiente.
Si el trabajo contiene un valor TimeoutConfig, el temporizador en curso empezará a funcionar.

También puede establecer un temporizador de pasos para la ejecución de un trabajo especificando un
valor para stepTimeoutInMinutes al llamar a UpdateJobExecution. El temporizador de pasos se
aplica únicamente a la ejecución del trabajo que actualice. Puede establecer un nuevo valor para este
temporizador cada vez que actualice la ejecución de un trabajo. También puede crear un temporizador
de pasos al llamar a StartNextPendingJobExecution. Si la ejecución del trabajo permanece en estado
IN_PROGRESS durante un periodo superior a este intervalo del temporizador de pasos, generará un
error y cambiará al estado terminal TIMED_OUT. El temporizador de pasos no tiene ningún efecto en el
temporizador en curso que establezca al crear un trabajo.
El campo status se puede definir en IN_PROGRESS, SUCCEEDED o FAILED. No puede actualizar el

estado de una ejecución de trabajo que ya está en estado terminal.
Report execution completed
Cuando el dispositivo ha acabado de ejecutar el trabajo, llama a la API de MQTT de

UpdateJobExecution (p. 514). Si el trabajo se realizó correctamente, establezca status en
SUCCEEDED y, en la carga del mensaje, en statusDetails, añada otra información acerca del
trabajo, como pares nombre-valor. Los temporizadores en curso y de pasos finalizan cuando se
completa la ejecución del trabajo.
More Information(4)
Por ejemplo:
{
"status":"SUCCEEDED",
"statusDetails": {
"progress":"100%"
},
"clientToken":"client-001"
}
Si el trabajo no se realizó correctamente, establezca status en FAILED y, en statusDetails,

añada información acerca del error que se ha producido:
{
"status":"FAILED",
"statusDetails": {
"errorCode":"101",
"errorMsg":"Unable to install update"
},
"clientToken":"client-001"
}
Note
El atributo statusDetails puede contener cualquier número de pares nombre-valor.
Cuando el servicio Jobs de AWS IoT recibe esta actualización, publica un mensaje en el tema $aws/
things/MyThing/jobs/notify para indicar que la ejecución del trabajo se ha completado:
{
"timestamp":1476290692776,
"jobs":{}
432
Trabajos adicionales
Additional jobs
Si hay otras ejecuciones de trabajo pendientes para el dispositivo, se incluyen en el mensaje publicado
en $aws/things/MyThing/jobs/notify.
More Information(5)
Por ejemplo:
{
"timestamp":1476290692776,
"jobs":{
"QUEUED":[{
"jobId":"0002",
"queuedAt":1476290646230,
"lastUpdatedAt":1476290646230
}],
"IN_PROGRESS":[{
"jobId":"0003",
"queuedAt":1476290646230,
"lastUpdatedAt":1476290646230
}]
}
}
Notificaciones de trabajos
El servicio Jobs de AWS IoT publica mensajes de MQTT para temas reservados cuando los trabajos están
pendientes o cuando cambia la primera ejecución del trabajo en la lista. Los dispositivos pueden realizar
un seguimiento de los trabajos pendientes suscribiéndose a estos temas.
Las notificaciones de trabajo se publican en temas MQTT como cargas JSON. Existen dos tipos de
notificaciones:
• Una ListNotification contiene una lista de no más de 10 ejecuciones de trabajos pendientes. Las
ejecuciones de trabajo de esta lista tienen valores de estado IN_PROGRESS o QUEUED. Se almacenan
por estado (ejecuciones de trabajo IN_PROGRESS antes que las ejecuciones de trabajo QUEUED) y, a
continuación, por las veces que se incluyeron en la cola.
Una ListNotification se publica siempre que se cumple uno de los siguientes criterios.
• Se pone en cola una nueva ejecución de trabajo o se cambia a un estado no terminal (IN_PROGRESS
o QUEUED).
• Una ejecución de trabajo antigua cambia a un estado terminal (FAILED, SUCCEEDED, CANCELED,
TIMED_OUT, REJECTED o REMOVED).
• NextNotification contiene información resumida sobre la ejecución del trabajo a continuación en la
cola.
Se publica una NextNotification siempre que cambia la ejecución del primer trabajo de la lista.
• Se añade a la lista una nueva ejecución del trabajo como QUEUED y se coloca el primero en la lista.
• El estado de la ejecución de un trabajo existente que no estaba en el primer lugar en la lista cambia
de QUEUED a IN_PROGRESS y pasa a colocarse en primer lugar en la lista. (Esto sucede cuando no
hay otras ejecuciones de trabajos de IN_PROGRESS en la lista o cuando la ejecución del trabajo cuyo
433
estado cambia de QUEUED a IN_PROGRESS estaba en la cola antes que cualquier otra ejecución de
trabajo de IN_PROGRESS de la lista.)
• El estado de la ejecución del trabajo existente que se encuentra en el primer lugar de la lista cambia a
un estado terminal y se quita de la lista.
Para obtener más información acerca de cómo publicar en temas de MQTT y suscribirse a ellos, consulte
Agente de mensajes de AWS IoT (p. 266).
Note
Las notificaciones no están disponibles cuando se usa HTTP Signature Version 4 o HTTP TLS
para comunicarse con trabajos.
Job pending
El servicio Jobs de AWS IoT publica un mensaje en un tema de MQTT cuando se añade un trabajo
a la lista de ejecuciones de trabajos pendientes para un objeto o se quita un trabajo de dicha lista, o
cuando cambia la primera ejecución del trabajo en la lista:
• $aws/things/thingName/jobs/notify
• $aws/things/thingName/jobs/notify-next
More Information(6)
Los mensajes contienen las siguientes cargas de ejemplo:
$aws/things/thingName/jobs/notify:
{
"timestamp" : 10011,
"jobs" : {
"IN_PROGRESS" : [ {
"jobId" : "other-job",
"queuedAt" : 10003,
"executionNumber" : 1,
"versionNumber" : 1
} ],
"QUEUED" : [ {
"jobId" : "this-job",
"queuedAt" : 10011,
"versionNumber" : 0
} ]
}
}
$aws/things/thingName/jobs/notify-next:
{
"timestamp" : 10011,
"execution" : {
"jobId" : "other-job",
"status" : "IN_PROGRESS",
"queuedAt" : 10009,
"jobDocument" : {"c":"d"}
434
}
}
Los valores del estado de ejecución de trabajo posibles son QUEUED, IN_PROGRESS, FAILED,
SUCCEEDED, CANCELED, TIMED_OUT, REJECTED y REMOVED.
La siguiente serie de ejemplos muestra las notificaciones que se publican en cada tema a medida que
se crean las ejecuciones de trabajo y se cambian de un estado a otro.
En primer lugar se crea un trabajo llamado job1. La notificación se publica en el tema jobs/notify:
{
"timestamp": 1517016948,
"jobs": {
"QUEUED": [
{
"jobId": "job1",
"queuedAt": 1517016947,
"lastUpdatedAt": 1517016947,
"versionNumber": 1
}
]
}
}
La notificación se publica en el tema jobs/notify-next:
{
"timestamp": 1517016948,
"execution": {
"jobId": "job1",
"status": "QUEUED",
"queuedAt": 1517016947,
"versionNumber": 1,
"jobDocument": {
"operation": "test"
}
}
}
Cuando se crea otro trabajo (job2), esta notificación se publica en el tema jobs/notify:
{
"timestamp": 1517017192,
"jobs": {
"QUEUED": [
{
"jobId": "job1",
"queuedAt": 1517016947,
"versionNumber": 1
},
{
"jobId": "job2",
"queuedAt": 1517017191,
"versionNumber": 1
435
}
]
}
}
No se publica una notificación en el tema jobs/notify-next porque el siguiente trabajo de la cola

(job1) no ha cambiado. Cuando job1 comienza a ejecutarse, su estado cambia a IN_PROGRESS. No
se publican notificaciones ya que la lista de trabajos y el siguiente trabajo en la cola no han cambiado.
Cuando se añade un tercer trabajo (job3), esta notificación se publica en el tema jobs/notify:
{
"timestamp": 1517017906,
"jobs": {
"IN_PROGRESS": [
{
"jobId": "job1",
"queuedAt": 1517016947,
"startedAt": 1517017472,
"versionNumber": 2
}
],
"QUEUED": [
{
"jobId": "job2",
"queuedAt": 1517017191,
"versionNumber": 1
},
{
"jobId": "job3",
"queuedAt": 1517017905,
"versionNumber": 1
}
]
}
}
No se publica una notificación en el tema jobs/notify-next porque el siguiente trabajo en la cola

sigue siendo job1.
Cuando job1 finaliza, su estado cambia a SUCCEEDED y se publica esta notificación en el tema
jobs/notify:
{
"timestamp": 1517186269,
"jobs": {
"QUEUED": [
{
"jobId": "job2",
"queuedAt": 1517017191,
"versionNumber": 1
},
{
"jobId": "job3",
"queuedAt": 1517017905,
436
"versionNumber": 1
}
]
}
}
En este punto, job1 se ha eliminado de la cola y el siguiente trabajo que ejecutar es job2. La
notificación se publica en el tema jobs/notify-next:
{
"timestamp": 1517186269,
"execution": {
"jobId": "job2",
"status": "QUEUED",
"queuedAt": 1517017191,
"versionNumber": 1,
"jobDocument": {
"operation": "test"
}
}
}
Si job3 tiene que empezar a ejecutarse antes que job2 (lo cual no se recomienda), el estado de
job3 puede cambiarse a IN_PROGRESS. Si esto sucede, job2 deja de ser el siguiente en la cola y se
publica esta notificación en el tema jobs/notify-next:
{
"timestamp": 1517186779,
"execution": {
"jobId": "job3",
"queuedAt": 1517017905,
"startedAt": 1517186779,
"versionNumber": 2,
"jobDocument": {
"operation": "test"
}
}
}
No se publica ninguna notificación en el tema jobs/notify, dado que no se ha añadido o eliminado

ningún trabajo.
Si el dispositivo rechaza job2 y actualiza su estado a REJECTED, se publica esta notificación en el

tema jobs/notify:
{
"timestamp": 1517189392,
"jobs": {
"IN_PROGRESS": [
{
"jobId": "job3",
"queuedAt": 1517017905,
"startedAt": 1517186779,
437
Uso de las API de trabajos de AWS IoT
"versionNumber": 2
}
]
}
}
Si job3 (que aún está en curso) se elimina de forma forzada, esta notificación se publica en el tema
jobs/notify:
{
"timestamp": 1517189551,
"jobs": {}
}
En este momento, la cola está vacía. La notificación se publica en el tema jobs/notify-next:
{
"timestamp": 1517189551
}
Uso de las API de trabajos de AWS IoT

En el servicio Jobs de AWS IoT se usan dos categorías de API:
• Las que se utilizan para la administración y el control de trabajos.

• Las que utilizan los dispositivos que ejecutan esos trabajos.
Por lo general, las de administración y control de trabajos utilizan una API de protocolo HTTPS. Los
dispositivos pueden usar una API de protocolo HTTPS o MQTT. (La API de HTTPS se ha diseñado para
un volumen reducido de llamadas normalmente cuando se crean trabajos y se hace un seguimiento de
ellos. Normalmente, abre una conexión para una solicitud única y, a continuación, cierra la conexión
después de que se reciba la respuesta. La API de MQTT permite el sondeo largo. Se ha diseñado para
cantidades grandes de tráfico que pueden escalar millones de dispositivos).
Note
Cada API HTTPS de Jobs de AWS IoT tiene un comando correspondiente que le permite llamar
a la API desde la AWS CLI. Los comandos están en minúsculas, con guiones entre las palabras
que conforman el nombre de la API. Por ejemplo, puede invocar la API CreateJob en la CLI
escribiendo lo siguiente:
aws iot create-job ...
API de administración y control de trabajo

Tipos de datos de administración y control de trabajo
Las aplicaciones de administración y control utilizan los siguientes tipos de datos para comunicarse con el
servicio Jobs de AWS IoT.
Tarea
Job data type
El objeto Job contiene detalles acerca de un trabajo.
438
Syntax (1)
{
"jobArn": "string",
"jobId": "string",
"status": "IN_PROGRESS|CANCELED|SUCCEEDED",
"forceCanceled": boolean,
"targetSelection": "CONTINUOUS|SNAPSHOT",
"comment": "string",
"targets": ["string"],
"description": "string",
"createdAt": timestamp,
"lastUpdatedAt": timestamp,
"completedAt": timestamp,
"processingTargets": ["string"],
"numberOfCanceledThings": long,
"numberOfSucceededThings": long,
"numberOfFailedThings": long,
"numberOfRejectedThings": long,
"numberOfQueuedThings": long,
"numberOfInProgressThings": long,
"numberOfRemovedThings": long,
"numberOfTimedOutThings": long
},
"expiresInSec": number,
"roleArn": "string"
},
},
}
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
}
]
},
"timeoutConfig": {
"inProgressTimeoutInMinutes": long
}
}
Description (1)
jobArn
Un ARN que identifica el trabajo con el formato "arn:aws:iot:region:account:job/jobId".

jobId
El identificador único asignado a este trabajo cuando se creó.
439
status
El estado del trabajo: IN_PROGRESS, CANCELED o SUCCEEDED.

targetSelection
Especifica si el trabajo sigue ejecutándose (CONTINUOUS) o si se ha completado después de

que los objetos especificados como destino hayan completado el trabajo (SNAPSHOT). Si el
estado es CONTINUOUS, es posible también que el trabajo solo pueda ejecutarse en un objeto
cuando se detecte un cambio en un destino. Por ejemplo, se ejecutará un trabajo en un objeto
cuando este se añada a un grupo de destino, incluso después de que los objetos originales del
grupo completen el trabajo.
comment
Si el trabajo se ha actualizado, describe el motivo de la actualización.

targets
Una lista de grupos de objetos y objetos de AWS IoT a los que debe enviarse el trabajo.
description
Una descripción breve de texto.

createdAt
El tiempo, en segundos, desde la fecha de inicio, cuando se creó el trabajo.

lastUpdatedAt
El tiempo, en segundos, desde la fecha de inicio, cuando se actualizó el trabajo por última vez.
completedAt
El tiempo, en segundos, desde la fecha de inicio, cuando se completó el trabajo.

jobProcessDetails
Detalles acerca del proceso de trabajo:

processingTargets
Una lista de los grupos de objeto y objetos de AWS IoT que ejecutan actualmente el trabajo.
numberOfCanceledThings
El número de objetos de AWS IoT que cancelaron el trabajo.

numberOfSucceededThings
El número de objetos de AWS IoT que han completado correctamente el trabajo.

numberOfFailedThings
El número de objetos de AWS IoT que no han completado correctamente el trabajo.

numberOfRejectedThings
El número de objetos de AWS IoT que rechazaron el trabajo.

numberOfQueuedThings
El número de objetos de AWS IoT que están esperando la ejecución del trabajo.
numberOfInProgressThings
El número de objetos de AWS IoT que están ejecutando actualmente el trabajo.

numberOfRemovedThings
El número de objetos de AWS IoT que ya no están programados para ejecutar el trabajo
porque se han eliminado o quitado del grupo que era un destino del trabajo.
440
numberOfTimedOutThings
El número de objetos cuyo estado de ejecución del trabajo es TIMED_OUT.

presignedUrlConfig
Información de configuración de las URL de Amazon S3 prefirmadas.

expiresInSec
Tiempo (en segundos) durante el que las URL prefirmadas son válidas. Los valores válidos
son 60-3600. El valor predeterminado es 3600 segundos. Cuando el servicio Jobs de AWS
IoT recibe una solicitud de MQTT para el documento de trabajo, se generan URL prefirmadas.
roleArn
El ARN del rol de IAM que concede permiso para descargar archivos de un bucket de
Amazon S3. El rol debe conceder permiso también para que AWS IoT descargue los
archivos. Para obtener más información acerca de cómo crear y configurar el rol, consulte
Creación de trabajos (p. 418).
jobExecutionRolloutConfig
Opcional. Le permite crear un despliegue almacenado de un trabajo.

maximumPerMinute
El número máximo de objetos (dispositivos) a los que se envía el trabajo para su ejecución,
por minuto.
exponentialRate
Permite crear una tasa exponencial para el despliegue de un trabajo.

baseRatePerMinute
El número mínimo de objetos al que se notificará un trabajo pendiente, por minuto, al

empezar a desplegarse un trabajo. Este parámetro le permite definir la tasa inicial del
despliegue.
incrementFactor
El factor exponencial para aumentar la tasa de despliegue para un trabajo.

rateIncreaseCriteria
Los criterios para iniciar el aumento en la tasa de despliegue de un trabajo. Puede

especificar numberOfNotifiedThings o numberOfSucceededThing, pero no
ambos.
numberOfNotifiedThings
El umbral del número de objetos notificados que iniciará el aumento en la tasa de

despliegue.
El umbral del número de objetos con éxito que iniciará el aumento en la tasa de
despliegue.
abortConfig
Opcional. Detalles sobre los criterios de anulación del trabajo.

criteriaList
La lista de criterios de anulación para definir reglas para anular el trabajo.
441
action
El tipo de acción de anulación para iniciar la anulación de un trabajo.

failureType
El tipo de error de ejecución de trabajo para definir una regla para iniciar un trabajo de
anulación.
minNumberOfExecutedThings
Número mínimo de objetos ejecutados antes de evaluar una regla de anulación.

thresholdPercentage
El umbral como porcentaje del total de objetos ejecutados que inicia la anulación de un
trabajo.
timeoutConfig
Opcional. Especifica la cantidad de tiempo que cada dispositivo tiene para finalizar su ejecución
del trabajo. El temporizador se pone en marcha cuando el estado de ejecución del trabajo se
establece en IN_PROGRESS. Si el estado de ejecución del trabajo no se establece en otro estado
terminal antes de que se cumpla el plazo, se establecerá en TIMED_OUT.
inProgressTimeoutInMinutes
Especifica la cantidad de tiempo, en minutos, que tiene este dispositivo para finalizar la
ejecución de este trabajo. Un temporizador se inicia o reinicia, siempre que el estado de
ejecución del trabajo se especifica como IN_PROGRESS con este campo relleno. Si el
estado de ejecución del trabajo no se ha establecido en un estado terminal antes de que el
temporizador venza, o antes de que se envíe otra actualización de estado de ejecución del
trabajo con este campo rellenado, el estado se establece en TIMED_OUT.
JobSummary
JobSummary data type
El objeto JobSummary contiene un resumen de trabajos.

Syntax (2)
{
"jobArn": "string",
"jobId": "string",
"status": "IN_PROGRESS|CANCELED|SUCCEEDED",
"thingGroupId": "string",
"createdAt": timestamp,
"completedAt": timestamp
}
Description (2)
jobArn
Un ARN que identifica el trabajo.

jobId

status
Estado del trabajo. Puede ser IN_PROGRESS, CANCELED o SUCCEEDED.
442
targetSelection
Especifica si el trabajo sigue ejecutándose (CONTINUOUS) o si se ha completado después de

que todos los objetos especificados como destino hayan completado el trabajo (SNAPSHOT). Si
el estado es CONTINUOUS, es posible también que el trabajo solo pueda ejecutarse en un objeto
cuando se detecte un cambio en un destino. Por ejemplo, se ejecutará un trabajo en un objeto
cuando este se añada a un grupo de destino, incluso después de que los objetos originales del
grupo completen el trabajo.
thingGroupId
El ID del grupo de objetos.

createdAt
La marca de tiempo UNIX de cuando se creó el trabajo.

lastUpdatedAt
La marca de tiempo UNIX de la última actualización del trabajo.

completedAt
La marca de tiempo UNIX de cuando se completó el trabajo.
JobExecution
JobExection data type
El objeto JobExecution representa la ejecución de un trabajo en un dispositivo.

Syntax (3)
{
"approximateSecondsBeforeTimedOut": 50,
"forceCanceled": true|false,
"jobId": "string",
"queuedAt": timestamp,
"startedAt": timestamp,
"status": "QUEUED|IN_PROGRESS|FAILED|SUCCEEDED|CANCELED|TIMED_OUT|REJECTED|
REMOVED",
"statusDetails": {
"detailsMap": {
"string": "string" ...
},
"status": "string"
},
"thingArn": "string",
"versionNumber": 123
}
Description (3)
approximateSecondsBeforeTimedOut
El número estimado de segundos restantes antes de que el estado de ejecución del trabajo
cambie a TIMED_OUT. El intervalo de tiempo de espera puede estar en cualquier momento entre
1 minuto y 7 días (1 a 10 080 minutos). El tiempo de espera de ejecución de trabajo real puede
producirse hasta un máximo de 60 segundos más tarde que la duración estimada.
443
jobId

executionNumber
Un número que identifica la ejecución de este trabajo en este dispositivo. Se puede utilizar
después en comandos que devuelven o actualizan la información de ejecución de trabajo.
thingArn
El ARN de objeto de AWS IoT.

queuedAt
El tiempo, en segundos, desde la fecha de inicio, cuando se puso en cola la ejecución de trabajo.
lastUpdatedAt
El tiempo, en segundos, desde la fecha de inicio, cuando se actualizó la ejecución de trabajo por
última vez.
startedAt
El tiempo, en segundos, desde la fecha de inicio, cuando se inició la ejecución.

status
El estado de la ejecución de trabajo. Puede ser QUEUED, IN_PROGRESS, FAILED, SUCCEEDED,

CANCELED, TIMED_OUT, REJECTED o REMOVED.
statusDetails
Un conjunto de pares nombre-valor que describen el estado de ejecución del trabajo.
JobExecutionSummary
JobExecutionSummary data type
El objeto JobExecutionSummary contiene información del resumen de resumen de ejecución de

trabajo:
Syntax (4)
{
"status": "QUEUED|IN_PROGRESS|FAILED|SUCCEEDED|CANCELED|TIMED_OUT|REJECTED|REMOVED"
}
Description (4)
executionNumber
Un número que identifica la ejecución de un trabajo en un dispositivo. Se puede utilizar después

en comandos que devuelven o actualizan la información de ejecución de trabajo.
queuedAt
lastUpdatedAt
última vez.
444
startAt

status
El estado de ejecución del trabajo: QUEUED, IN_PROGRESS, FAILED, SUCCEEDED, CANCELED,

TIMED_OUT, REJECTED o REMOVED.
JobExecutionSummaryForJob
JobExecutionSummaryForJob data type
El objeto JobExecutionSummaryForJob contiene un resumen de información acerca de las

ejecuciones de trabajo para un trabajo específico.
Syntax (5)
{
{
"thingArn": "arn:aws:iot:us-west-2:123456789012:thing/MyThing",
"queuedAt": 1541526002.609,
}
},
...
]
}
Description (5)
thingArn
El ARN de objeto de AWS IoT.

jobExecutionSummary
Un objeto JobExecutionSummary (p. 444).
JobExecutionSummaryForThing
JobExecutionSummaryForThing data type
El objeto JobExecutionSummaryForThing contiene un resumen de información acerca de una

ejecución de trabajo en un objeto específico.
Syntax (6)
{
{
"queuedAt": 1541526002.609,
},
"jobId": "MyThingJob"
445
},
...
]
}
Description (6)
jobId

jobExecutionSummary
Un objeto JobExecutionSummary (p. 444).
Comandos HTTPS y de la CLI de administración y control de

trabajos
Los siguientes comandos están disponibles para aplicaciones de administración y control en la CLI a través
del protocolo HTTPS. Para obtener el valor del parámetro endpoint-url en los comandos de la CLI,
utilice el siguiente comando.
aws iot describe-endpoint --endpoint-type=iot:Jobs
Este comando genera el siguiente resultado.
{
"endpointAddress": "unique-.jobs.iot.us-west-2.amazonaws.com"
}
AssociateTargetsWithJob command
Asocia un grupo con un trabajo continuo. Para obtener más información, consulte
CreateJob (p. 454). Deben cumplirse los siguientes criterios:
• El trabajo debe haberse creado con el campo targetSelection establecido en CONTINUOUS.

• El estado del trabajo debe ser actualmente IN_PROGRESS.
• El número total de destinos asociados con un trabajo no debe ser superior a 100.
HTTPS (1)
Solicitud:
POST /jobs/jobId/targets
{
"targets": [ "string" ],
"comment": "string"
}
jobId
446
targets
Una lista de ARN del grupo de objetos que definen los destinos del trabajo.
comment
Opcional. Una cadena de comentario que describe el motivo por el que el trabajo se asoció con
los destinos.
Respuesta:
{
"jobArn": "string",
"jobId": "string",
}
jobArn
Un ARN que identifica al trabajo.

jobId

description
CLI (1)
Sinopsis:
aws iot associate-targets-with-job \

--targets <value> \
--job-id <value> \
[--comment <value>] \
[--cli-input-json <value>] \
[--generate-cli-skeleton]
cli-input-json formato:
{
"targets": [
"string"
],
"jobId": "string",
"comment": "string"
}
Campos cli-input-json:
Nombre Tipo Descripción
destinos list Una lista de ARN del grupo de

objetos que definen los destinos
Miembro: TargetArn del trabajo.
TargetArn string
447
jobId string El identificador único asignado

a este trabajo cuando se creó.
Longitud máx.: 64; mín.: 1
Patrón: [a-zA-Z0-9_-]+
comment string Una cadena opcional que

describe el motivo por el que
Longitud máx.: 2028 el trabajo se asoció con los
destinos.
patrón: [^\\p{C}]+
Salida:
{
"jobArn": "string",
"jobId": "string",
}
Campos de salida de la CLI:
jobArn string Un ARN que identifica al

trabajo.

Descripción string Una descripción breve de texto.
Longitud máx.: 2028
patrón: [^\\p{C}]+
CancelJob
CancelJob command
Cancela un trabajo.
HTTPS (2)
Solicitud:
PUT /jobs/jobId/cancel
{
"force": boolean,
"reasonCode": "string"
}
448
jobId

force
[Opcional] Si true, se cancelan las ejecuciones de trabajos con estado IN_PROGRESS y QUEUED.
Si no, solo se cancelan las ejecuciones de trabajos con estado QUEUED. El valor predeterminado
es false.
Warning
La cancelación de un trabajo con estado IN_PROGRESS hará que un dispositivo que esté
ejecutando el trabajo no pueda actualizar su estado de ejecución. Actúe con precaución
y asegúrese de que cada dispositivo que ejecute un trabajo que se cancela sea capaz de
comment
[Opcional] Una cadena de comentario que describe el motivo por el que se canceló el trabajo.
reasonCode
[Opcional] Una cadena de código de motivo que explica por qué se ha cancelado el trabajo. Si un
trabajo se cancela porque cumple las condiciones definidas por abortConfig, este campo se
rellena automáticamente.
Respuesta:
{
"jobArn": "string",
"jobId": "string",
}
jobArn
El ARN de trabajo.
jobId

description
CLI (2)
Sinopsis:
aws iot cancel-job \

--job-id <value> \
[--force <value>] \
[--comment <value>] \
[--reasonCode <value>] \
449
"jobId": "string",
"force": boolean,
"comment": "string"
}

force booleano Si es true, se cancelan los

trabajos con estado QUEUED
e IN_PROGRESS. Si no, solo
se cancelan los trabajos con
estado QUEUED.
Warning
La cancelación de un
trabajo con estado
IN_PROGRESS hará
que un dispositivo
que esté ejecutando
el trabajo no pueda
actualizar su estado
de ejecución. Actúe
con precaución y
asegúrese de que
cada dispositivo que
ejecute un trabajo que
se cancela sea capaz
de recuperarse a un
estado válido.
comment string Una cadena opcional que

describe el motivo por el que se
Longitud máx.: 2028 canceló el trabajo.
patrón: [^\\p{C}]+
reasonCode string Una cadena opcional que

explica el motivo por el que
Longitud máx.: 128 se canceló el trabajo. Si el
trabajo se canceló porque
patrón: [\p{Upper}\p{Digit}_]+ cumple los criterios definidos
por abortConfig, este campo
se rellena automáticamente.
Salida:
{
"jobArn": "string",
"jobId": "string",
450
jobArn string El ARN de trabajo.

patrón: [^\\p{C}]+
CancelJobExecution
CancelJobExecution command
Cancela la ejecución de un trabajo en un dispositivo.

HTTPS (3)
Solicitud:
PUT /things/thingName/jobs/jobId/cancel
{
"force": boolean,
"expectedVersion": "string",
"statusDetails": {
"string": "string"
...
}
}
thingName
El nombre del elemento cuya ejecución del trabajo se cancelará.

jobId
El identificador único asignado al trabajo cuando se creó.

force
Opcional. Si true, se puede cancelar la ejecución de un trabajo con estado IN_PROGRESS o

QUEUED. Si no, solo se puede cancelar la ejecución de un trabajo con estado QUEUED. Si intenta
cancelar la ejecución de un trabajo con estado IN_PROGRESS y no establece force en true, se
generará InvalidStateTransitionException. El valor predeterminado es false.
Warning
La cancelación de un trabajo con estado IN_PROGRESS hará que un dispositivo que esté
ejecutando el trabajo no pueda actualizar su estado de ejecución. Actúe con precaución
y asegúrese de que cada dispositivo que ejecute un trabajo que se cancela sea capaz de
451
expectedVersion
Opcional. La versión actual esperada de la ejecución de trabajos. Cada vez que actualiza
la ejecución de trabajos, aumenta su versión. Si la versión de la ejecución del trabajo
almacenada en el servicio Jobs de AWS IoT no coincide, la actualización se rechaza con un error
VersionConflictException y se devuelve un código ErrorResponse con los datos de
estado de la ejecución del trabajo actual. (Esto hace que no sea necesario realizar una solicitud
DescribeJobExecution aparte para obtener los datos de estado de ejecución del trabajo).
statusDetails
Opcional. Un conjunto de pares nombre-valor que describen el estado de ejecución del trabajo.
Respuesta:
{
}
CLI (3)
Sinopsis:
aws iot cancel-job-execution \

--job-id <value> \
--thing-name <value> \
[--force | --no-force] \
[--expected-version <value>] \
[--status-details <value>] \
{
"jobId": "string",
"thingName": "string",
"force": boolean,
"expectedVersion": long,
"statusDetails": {
"string": "string"
}
}
jobId string El trabajo que se va a cancelar.
thingName string El nombre del elemento

cuya ejecución del trabajo se
Longitud máx.: 128 min.: 1 cancelará.
Patrón: [a-zA-Z0-9:_-]+
452
force booleano Opcional. Si true, se cancela

la ejecución del trabajo si esta
tiene estado IN_PROGRESS
o QUEUED. Si no, se cancela
solo la ejecución del trabajo si
esta tiene estado QUEUED. No
obstante, si intenta cancelar
la ejecución de un trabajo
con estado IN_PROGRESS
y no establece --force en
true, entonces se generará
InvalidStateTransitionException.
El valor predeterminado es
false.
Warning
La cancelación de un
trabajo con estado
IN_PROGRESS hará
que un dispositivo
el trabajo no pueda
actualizar su estado
de ejecución. Actúe
con precaución y
asegúrese de que
se cancela sea capaz
de recuperarse a un
estado válido.
expectedVersion long Opcional. La versión actual

esperada de la ejecución
Clase de Java: java.lang.Long de trabajos. Cada vez que
actualiza la ejecución de
trabajos, aumenta su versión.
Si la versión de la ejecución
del trabajo almacenada en
el servicio Jobs de AWS IoT
no coincide, la actualización
se rechaza con un error
VersionMismatch y
se devuelve un código
ErrorResponse con
los datos de estado de la
ejecución del trabajo actual.
(Esto hace que no sea
necesario realizar una solicitud
DescribeJobExecution
aparte para obtener los datos
de estado de ejecución del
trabajo).
453
statusDetails map Un conjunto de pares nombre-

valor que describen el estado
Clave: DetailsKey de ejecución del trabajo. Si no
se especifica, statusDetails
Valor: DetailsValue no se modifica.
DetailsKey string
Longitud máx.: 128 min.: 1
DetailsValue string
patrón: [^\\p{C}]*+
Salida:
Ninguna
CreateJob
CreateJob command
Crea un trabajo. Puede proporcionar el documento de trabajo como enlace a un archivo en un bucket
de Amazon S3 (parámetro documentSource) o en el cuerpo de la solicitud (parámetro document).
Un trabajo puede ser continuo si se establece el parámetro opcional targetSelection en

CONTINUOUS. (El valor predeterminado es SNAPSHOT). Un trabajo continuo puede utilizarse para
integrar o actualizar dispositivos a medida que se añaden a un grupo, ya que continúa ejecutándose,
y lo hace en objetos añadidos recientemente, incluso después de que los objetos del grupo que en el
momento en el que se creó el trabajo hubieran completado el trabajo.
Un trabajo puede tener un valor TimeoutConfig opcional que establece el valor del temporizador en
curso. El temporizador en curso no se puede actualizar y se aplica a todas las ejecuciones del trabajo.
Se realizan las siguientes validaciones en los argumentos para la API CreateJob:
• El argumento targets debe ser una lista de ARN de grupo de objetos u objetos válidos. Todos los
objetos y grupos de objetos deben estar en la cuenta de AWS.
• El argumento documentSource debe ser una URL de Amazon S3 válida para un
documento de trabajo. Las URL de Amazon S3 tienen la siguiente forma: https://
s3.amazonaws.com/bucketName/objectName.
• El documento almacenado en la URL especificada por el argumento documentSource debe ser un
documento JSON con codificación UTF-8.
• El tamaño del documento de trabajo está limitado a 32 KB debido al límite del tamaño de un
mensaje MQTT (128 KB) y el cifrado.
• jobId debe ser exclusivo dentro de su cuenta de AWS.
HTTPS (4)
Solicitud:
454
PUT /jobs/jobId
{
"targets": [ "string" ],
"document": "string",
"documentSource": "string",
"presignedUrlConfigData": {
"roleArn": "string",
"expiresInSec": "integer"
},
},
}
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
}
]
},
"timeoutConfig": {
}
}
jobId
Un identificador de trabajo, que debe ser exclusivo para su cuenta de AWS. Recomendamos
utilizar un UUID. Aquí pueden utilizarse caracteres alfanuméricos, "-" y "_".
targets
Una lista de ARN de grupo de objetos u objetos que define los destinos del trabajo.
document
Opcional. El documento de trabajo.

documentSource
Opcional. Un enlace de Amazon S3 al documento de trabajo.

description
Opcional. Una descripción breve de texto.

presignedUrlConfigData
Opcional. Información de configuración de las URL de Amazon S3 prefirmadas.

roleArn
El ARN del rol de IAM que contiene permisos para acceder al bucket de Amazon S3. Este es
el bucket que contiene los datos que los dispositivos descargan con las URL de Amazon S3
455
prefirmadas. Este rol debe también conceder el permiso de AWS IoT para asumir el rol. Para
obtener más información, consulte Creación de trabajos (p. 418).
expiresInSec
targetSelection
Opcional. Especifica si el trabajo sigue ejecutándose (CONTINUOUS) o si se ha completado

después de que todos los objetos especificados como destino hayan completado el trabajo
(SNAPSHOT). Si el estado es CONTINUOUS, es posible que el trabajo también pueda
programarse para la ejecución en un objeto cuando se detecte un cambio en un destino. Por
ejemplo, se programará un trabajo para la ejecución en un objeto cuando este se añada a un
grupo de destino, incluso después de que los objetos originales del grupo completen el trabajo.

maximumPerMinute
El número máximo de objetos al que se enviará el trabajo para la ejecución (por minuto).
Los valores válidos son de 1 a 1000. Si no se especifica, el valor predeterminado es 1000.
El número real de objetos que recibe el objeto puede ser inferior durante cualquier intervalo
de minutos determinado (debido a la latencia del sistema), pero no es superior al valor
especificado.
exponentialRate

baseRatePerMinute
El número mínimo de objetos al que se notificará un trabajo pendiente, por minuto, al

empezar a desplegarse un trabajo. Este parámetro le permite definir la tasa inicial del
despliegue.
incrementFactor

Los criterios para iniciar el aumento en la tasa de despliegue de un trabajo. Los valores
establecidos para numberOfNotifiedThings o numberOfSucceededThings, pero
no ambos.

despliegue.
despliegue.
abortConfig

criteriaList

action
456
failureType
anulación.

thresholdPercentage
trabajo.
timeoutConfig
Respuesta:
{
"jobArn": "string",
"jobId": "string",
}
jobArn
El ARN del trabajo.

jobId
El identificador único asignado a este trabajo.

description
Una descripción de texto breve opcional del trabajo.
CLI (4)
Sinopsis:

--job-id <value> \
--targets <value> \
[--document-source <value>] \
[--document <value>] \
[--description <value>] \
[--presigned-url-config <value>] \
[--target-selection <value>] \
457
[--job-executions-rollout-config <value>] \
[--abort-config <value>] \
[--timeout-config <value>] \
[--document-parameters <value>] \
{
"jobId": "string",
"targets": [
"string"
],
"document": "string",
"expiresInSec": long
},
"targetSelection": "string",
},
}
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
}
]
},
"timeoutConfig": {
},
"documentParameters": {
"string": "string"
}
}
jobId string Un identificador de trabajo,

que debe ser exclusivo
Longitud máx.: 64; mín.: 1 para su cuenta de AWS.
Recomendamos utilizar un
Patrón: [a-zA-Z0-9_-]+ UUID. Aquí se pueden usar los
caracteres alfanuméricos, "-" y
"_".
458
destinos list Una lista de grupos de objetos y

objetos a los que debe enviarse
Miembro: TargetArn el trabajo.
TargetArn string
documentSource string Un enlace de S3 al documento

de trabajo.
documento string El documento de trabajo.
patrón: [^\\p{C}]+
presignedUrlConfig PresignedUrlConfig Información de configuración de

las URL de S3 prefirmadas.
roleArn string El ARN de un rol de IAM

que concede permiso para
Longitud máx.: 2048; mín.: 20 descargar archivos desde el
bucket de Amazon S3 en el que
se almacenaron los datos o
las actualizaciones del trabajo.
El rol debe conceder permiso
también para que AWS IoT
descargue los archivos.
expiresInSec long Tiempo (en segundos) durante

el que las URL prefirmadas
Clase de Java: java.lang.Long son válidas. Los valores
válidos son 60-3600. El valor
Rango máx.: 3600; mín.: 60 predeterminado es 3600
segundos. Cuando el servicio
Jobs de AWS IoT recibe una
solicitud de MQTT para el
documento de trabajo, se
generan URL prefirmadas.
459
targetSelection string Especifica si el trabajo sigue

ejecutándose (CONTINUOUS)
Enum: CONTINUOUS | o si se ha completado después
SNAPSHOT de que todos los objetos
especificados como destino
hayan completado el trabajo
(SNAPSHOT). Si el estado es
continuo, es posible también
que el trabajo solo pueda
ejecutarse en un objeto cuando
se detecte un cambio en
un destino. Por ejemplo, se
ejecutará un trabajo en un
objeto cuando este se añada
a un grupo de destino, incluso
después de que los objetos
originales del grupo completen
el trabajo.
jobExecutionsRolloutConfig JobExecutionsRolloutConfig Le permite crear un despliegue

almacenado del trabajo.
maximumPerMinute integer El número máximo de objetos a

los que se notificará un trabajo
Clase de Java: java.lang.Integer pendiente (por minuto). Este
parámetro permite crear un
Rango máx.: 1000; mín.: 1 despliegue almacenado.
exponentialRate ExponentialRolloutRate La tasa de aumento para el

despliegue de un trabajo. Este
parámetro le permite definir
una tasa exponencial para el
despliegue de un trabajo.
baseRatePerMinute Clase de Java: java.lang.Integer El número mínimo de objetos

del que se notificará de un
trabajo pendiente, por minuto,
al empezar a desplegarse
un trabajo. Este parámetro le
permite definir la tasa inicial del
despliegue.
incrementFactor Clase de Java: El factor exponencial para

java.lang.Double aumentar la tasa de despliegue
para un trabajo.
rateIncreaseCriteria RateIncreaseCriteria Permite definir criterios para

iniciar el aumento en la tasa
de despliegue de un trabajo.
Establezca un valor para
numberOfNotifiedThings o
numberOfSucceededThings,
pero no ambos.
460
numberOfNotifiedThings Clase de Java: El umbral del número de

java.lang.Double objetos notificados que iniciará
el aumento de la tasa de
despliegue.
numberOfSucceededThings Clase de Java: El umbral del número de

java.lang.Double objetos con éxito que iniciará
el aumento de la tasa de
despliegue.
abortConfig AbortConfig Permite crear criterios para

anular un trabajo.
criteriaList AbortCriteria La lista de criterios de anulación

para definir reglas para anular
el trabajo.
action Clase de Java: java.lang.String El tipo de acción de anulación

(CANCEL) para iniciar la anulación de un
trabajo.
failureType Clase de Java: java.lang.String El tipo de error de ejecución

(FAILED | REJECTED | de trabajo para definir una
TIMED_OUT | ALL) regla para iniciar un trabajo de
anulación.
minNumberOfExecutedThings Clase de Java: Número mínimo de objetos

java.lang.Integer) ejecutados antes de evaluar
una regla de anulación.
thresholdPercentage Clase de Java: El umbral como porcentaje del

java.lang.Double) total de objetos ejecutados
que iniciará la anulación de un
trabajo.
AWS IoT admite hasta dos

dígitos después del decimal
(por ejemplo, 10.9 y 10.99, pero
no 10.999).
timeoutConfig TimeoutConfig Especifica la cantidad de

tiempo que cada dispositivo
tiene para finalizar su ejecución
del trabajo. El temporizador
se pone en marcha cuando el
estado de ejecución del trabajo
se establece en IN_PROGRESS.
Si el estado de ejecución del
trabajo no se establece en otro
estado terminal antes de que se
cumpla el plazo, se establecerá
en TIMED_OUT.
461
inProgressTimeoutInMinutes long Especifica la cantidad de

tiempo, en minutos, que tiene
este dispositivo para finalizar
la ejecución de este trabajo.
Un temporizador se inicia o
reinicia, siempre que el estado
de ejecución del trabajo se
especifica como IN_PROGRESS
con este campo relleno. Si
el estado de ejecución del
trabajo no se ha establecido
en un estado terminal antes
de que el temporizador venza,
o antes de que se envíe otra
actualización de estado de
ejecución del trabajo con este
campo rellenado, el estado se
establece en TIMED_OUT.
documentParameters map Parámetros para el documento

de trabajo.
Clave: ParameterKey
Valor: ParameterValue
ParameterKey string
ParameterValue string
patrón: [^\\p{C}]+
Salida:
{
"jobArn": "string",
"jobId": "string",
}

a este trabajo.
462
Descripción string La descripción del trabajo.
patrón: [^\\p{C}]+
DeleteJob
DeleteJob command
Elimina un trabajo y sus ejecuciones de trabajo relacionadas.
La eliminación de un trabajo puede tardar tiempo, en función del número de ejecuciones de trabajo
creadas para el trabajo y otros factores diversos. Aunque el trabajo se está eliminando, el estado del
trabajo se muestra como "DELETION_IN_PROGRESS". Si se intenta eliminar o cancelar un trabajo
cuyo estado ya es DELETION_IN_PROGRESS, se producirá un error.
HTTPS (5)
Sintaxis de la solicitud:
DELETE /jobs/jobId?force=force
Parámetros de solicitud del URI:
Nombre Tipo ¿Sol.? Descripción
jobId JobId sí El ID del trabajo que se

va a eliminar.
force ForceFlag no (Opcional) Cuando

es verdadero,
puede eliminar un
trabajo con estado
"IN_PROGRESS". De
lo contrario, solo puede
eliminar un trabajo
que se encuentre
en estado terminal
("SUCCEEDED" o
"CANCELED"), o
se producirá una
excepción. El valor
predeterminado es
false.
Note
La eliminación
de un trabajo
con estado
"IN_PROGRESS"
hace que un
dispositivo
que esté
ejecutando
463

el trabajo
no pueda
acceder a la
información
del trabajo
o actualizar
el estado de
ejecución
del trabajo.
Actúe con
precaución
y asegúrese
de que cada
dispositivo
que ejecute
un trabajo que
se elimine
sea capaz de
recuperarse
a un estado
válido.
Errores:
InvalidRequestException
El contenido de la solicitud no es válido. Por ejemplo, se devuelve este código cuando una
solicitud UpdateJobExecution contiene detalles de estado no válido. El mensaje contiene detalles
acerca del error.
Código de respuesta de HTTP: 400

InvalidStateTransitionException
Una actualización intentó cambiar el trabajo o la ejecución de trabajo a un estado que no es

válido debido a su estado actual (por ejemplo, un intento de cambiar una solicitud con un estado
SUCCEEDED a un estado IN_PROGRESS). En este caso, el cuerpo del mensaje de error
también contiene el campo executionState.

ResourceNotFoundException
El recurso especificado no existe.

ThrottlingException
El índice supera el límite.

ServiceUnavailableException
El servicio no está disponible temporalmente.
464
CLI (5)
Sinopsis:
aws iot delete-job \

--job-id <value> \
{
"jobId": "string",
"force": boolean
}
jobId string El ID del trabajo que se va a

eliminar.
force booleano (Opcional) Cuando es

verdadero, puede eliminar
un trabajo con estado
IN_PROGRESS. De lo
contrario, solo puede eliminar
un trabajo que se encuentre en
estado terminal (SUCCEEDED
o CANCELED), o se producirá
una excepción. El valor
predeterminado es false.
Note
La eliminación de un
trabajo con estado
IN_PROGRESS hace
que un dispositivo
el trabajo no
pueda acceder a
la información del
trabajo o actualizar el
estado de ejecución
del trabajo. Actúe
con precaución y
asegúrese de que
se elimine sea capaz
de recuperarse a un
estado válido.
465
Salida:
Ninguna
DeleteJobExecution
DeleteJobExecution command
Elimina una ejecución de trabajo.

HTTPS (6)
Sintaxis de la solicitud:
DELETE /things/thingName/jobs/jobId/executionNumber/executionNumber?force=force
Parámetros de solicitud del URI:
jobId JobId sí El ID del trabajo cuya

ejecución se eliminará.
thingName ThingName sí El nombre del

elemento cuya
ejecución del trabajo
se eliminará.
executionNumber ExecutionNumber sí El ID de la ejecución

del trabajo que se va a
eliminar.
force ForceFlag no Cuando es verdadero,

puede eliminar la
ejecución de un
trabajo con estado
IN_PROGRESS.
De lo contrario, solo
puede eliminar una
ejecución de trabajo
que se encuentre
en estado terminal
(SUCCEEDED,
FAILED, TIMED_OUT,
REJECTED,
REMOVED o
CANCELED) o
se producirá una
excepción. El valor
predeterminado es
false.
Note
La eliminación
de la
ejecución de
un trabajo
466

con estado
IN_PROGRESS
hará que un
dispositivo
no pueda
acceder a la
información
del trabajo
o actualizar
el estado de
ejecución
del trabajo.
Actúe con
precaución
y asegúrese
de que el
dispositivo
sea capaz de
recuperarse
a un estado
válido.
Errores:
solicitud UpdateJobExecution contiene detalles de estado no válido. El mensaje contiene detalles
acerca del error.

InvalidStateTransitionException
Una actualización intentó cambiar la ejecución de trabajo a un estado que no es válido debido al
estado actual de la ejecución de trabajo (por ejemplo, un intento de cambiar una solicitud con un
estado SUCCEEDED a un estado IN_PROGRESS). En este caso, el cuerpo del mensaje de error
también contiene el campo executionState.


ThrottlingException

ServiceUnavailableException
El servicio no está disponible temporalmente.
467
CLI (6)
Sinopsis:
aws iot delete-job-execution \

--job-id <value> \
--execution-number <value> \
{
"jobId": "string",
"executionNumber": long,
"force": boolean
}
jobId string El ID del trabajo cuya ejecución

se eliminará.
thingName string El nombre del elemento

cuya ejecución del trabajo se
Longitud máx.: 128 min.: 1 eliminará.
executionNumber long El ID de la ejecución del trabajo

que se va a eliminar.
Clase de Java: java.lang.Long
force booleano Cuando es verdadero,

puede eliminar la ejecución
de un trabajo con estado
IN_PROGRESS. De lo
contrario, solo puede eliminar
una ejecución de trabajo que se
encuentre en estado terminal
(SUCCEEDED, FAILED,
TIMED_OUT, REJECTED,
REMOVED o CANCELED) o
se producirá una excepción. El
valor predeterminado es false.
Note
La eliminación de
la ejecución de un
trabajo con estado
IN_PROGRESS hará
468

que un dispositivo
no pueda acceder
a la información del
trabajo o actualizar el
estado de ejecución
del trabajo. Actúe
con precaución y
asegúrese de que el
dispositivo sea capaz
de recuperarse a un
estado válido.
Salida:
Ninguna
DescribeJob
DescribeJob command
Obtiene los detalles del trabajo especificado.

HTTPS (7)
Solicitud:
GET /jobs/jobId
jobId
Respuesta:
{
"job": Job
}
documentSource
Un enlace de Amazon S3 al documento de trabajo.

job
Un objeto Tarea (p. 438).
CLI (7)
Sinopsis:
aws iot describe-job \

--job-id <value> \
469
{
"jobId": "string"
}

Salida:
{
"job": {
"jobArn": "string",
"jobId": "string",
"status": "string",
"targets": [
"string"
],
"expiresInSec": long
},
},
}
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
}
]
},
"createdAt": "timestamp",
"lastUpdatedAt": "timestamp",
"completedAt": "timestamp",
"processingTargets": [
"string"
470
],
"numberOfCanceledThings": "integer",
"numberOfSucceededThings": "integer",
"numberOfFailedThings": "integer",
"numberOfRejectedThings": "integer",
"numberOfQueuedThings": "integer",
"numberOfInProgressThings": "integer",
"numberOfRemovedThings": "integer",
"numberOfTimedOutThings": "integer"
},
"documentParameters": {
"string": "string"
},
"timeoutConfig": {
}
}
}
documentSource string Un enlace de Amazon S3 al

documento de trabajo.
tarea Tarea Información acerca del trabajo.
jobArn string Un ARN que identifica el

trabajo con el formato:
"arn:aws:iot:region:account:job/
jobId".


un destino. Por ejemplo,
un trabajo se ejecuta en un
dispositivo cuando el objeto
que representa al dispositivo se
añada a un grupo de destino,
incluso después de que los
objetos originales del grupo
completen el trabajo.
471
status string El estado del trabajo:

IN_PROGRESS, CANCELED o
enum: IN_PROGRESS | SUCCEEDED.
CANCELED | SUCCEEDED
forceCanceled booleano Es true si el trabajo se canceló

con el parámetro opcional
Clase de Java: force establecido en true.
java.lang.Boolean
comment string Si el trabajo se ha actualizado,

describe el motivo de la
Longitud máx.: 2028 actualización.
patrón: [^\\p{C}]+
destinos list Una lista de grupos de objetos

y objetos de AWS IoT a los que
Miembro: TargetArn debe enviarse el trabajo.
TargetArn string
patrón: [^\\p{C}]+
presignedUrlConfig PresignedUrlConfig Configuración de las URL de

Amazon S3 prefirmadas.

bucket de Amazon S3 en el que
se almacenaron los datos o
las actualizaciones del trabajo.
también para que el servicio
Jobs de AWS IoT descargue los
archivos.


472



a los que se notificará un
despliegue.

para un trabajo.

pero no ambos.

el aumento en la tasa de
despliegue.

despliegue.

anular un trabajo.

el trabajo.

trabajo.

anulación.
473


java.lang.Double) total de objetos ejecutados que
inicia la anulación de un trabajo.

no 10.999).
createdAt timestamp El tiempo, en segundos, desde

la fecha de inicio, cuando se
creó el trabajo.
lastUpdatedAt timestamp El tiempo, en segundos, desde

actualizó el trabajo por última
vez.
completedAt timestamp El tiempo, en segundos, desde

completó el trabajo.
jobProcessDetails JobProcessDetails Detalles acerca del proceso de

trabajo.
processingTargets list Los dispositivos en los que se

ejecuta el trabajo.
Miembro:
ProcessingTargetName
Clase de Java: java.util.List
ProcessingTargetName string
numberOfCanceledThings integer El número de objetos que

cancelaron el trabajo.
Clase de Java: java.lang.Integer
numberOfSucceededThings integer El número de objetos que han

completado correctamente el
Clase de Java: java.lang.Integer trabajo.
numberOfFailedThings integer El número de objetos en los

que se produjo un error al
Clase de Java: java.lang.Integer ejecutar el trabajo.
numberOfRejectedThings integer El número de objetos que

rechazaron el trabajo.
numberOfQueuedThings integer El número de objetos de

IoT que están esperando la
Clase de Java: java.lang.Integer ejecución de trabajo.
474
numberOfInProgressThings integer El número de objetos que

ejecutan actualmente el trabajo.
numberOfRemovedThings integer El número de objetos de IoT

que ya no están programados
Clase de Java: java.lang.Integer para ejecutar el trabajo porque
se han eliminado o quitado del
grupo que era un destino del
trabajo.
numberOfTimedOutThings integer El número de objetos cuyo

Clase de Java: java.lang.Integer es TIMED_OUT.
documentParameters map Los parámetros especificados

para el documento de trabajo.
Clave: ParameterKey
ParameterKey string
patrón: [^\\p{C}]+

del trabajo. Un temporizador
trabajo no se establece en
otro estado terminal antes de
que se cumpla el plazo del
temporizador, se establecerá en
TIMED_OUT.
475

tiempo, en minutos, que
tiene este dispositivo para
finalizar la ejecución de este
trabajo. El intervalo de tiempo
de espera puede estar en
cualquier momento entre 1
minuto y 7 días (1 a 10 080
minutos). El temporizador en
curso no se puede actualizar
y se aplica a todas las
ejecuciones de trabajos para
el trabajo. Cuando un trabajo
permanece en estado de
ejecución IN_PROGRESS
durante un periodo superior
a este intervalo, la ejecución
del trabajo generará error y
cambiará al estado terminal
TIMED_OUT.
DescribeJobExecution command
Obtiene los detalles de una ejecución de trabajo. El estado de la ejecución del trabajo debe ser
SUCCEEDED o FAILED.
HTTPS (8)
Solicitud:
GET /things/thingName/jobs/jobId?executionNumber=executionNumber
jobId

thingName
El nombre de objeto asociado con el dispositivo en el que se está ejecutando la ejecución de

trabajo.
executionNumber
Opcional. Un número que se usa para especificar la ejecución de un trabajo en un dispositivo.

(Consulte JobExecution (p. 443).) Si no se especifica, se devuelve la ejecución de trabajo más
reciente.
Respuesta:
{
"execution": { JobExecution }
}
476
execution
Un objeto JobExecution (p. 443).
CLI (8)
Sinopsis:
aws iot describe-job-execution \

--job-id <value> \
[--execution-number <value>] \
{
"jobId": "string",
"executionNumber": long
}

thingName string El nombre del objeto en el que

se está ejecutando la ejecución
Longitud máx.: 128 min.: 1 de trabajo.
executionNumber long Una cadena (que consta de

dígitos del "0" al "9") que se usa
Clase de Java: java.lang.Long para especificar una ejecución
de trabajo determinada en un
dispositivo concreto.
Salida:
{
"execution": {
"approximateSecondsBeforeTimedOut": "number"
"jobId": "string",
"status": "string",
"statusDetails": {
"detailsMap": {
"string": "string"
}
},
477
"queuedAt": "timestamp",
"startedAt": "timestamp",
"versionNumber": long
}
}
ejecución JobExecution Información acerca de la

ejecución de trabajo.
approximateSecondsBeforeTimedOut
long El número estimado de
segundos restantes antes de
que el estado de ejecución del
trabajo cambie a TIMED_OUT.
El intervalo de tiempo de
espera puede estar en
cualquier momento entre 1
minuto y 7 días (1 a 10 080
minutos). El tiempo de espera
de ejecución de trabajo real
puede producirse hasta un
máximo de 60 segundos más
tarde que la duración estimada.
Este valor no se incluye si
la ejecución del trabajo ha
alcanzado un estado terminal.

al trabajo cuando se creó.
status string El estado de la ejecución de

trabajos (IN_PROGRESS,
enum: QUEUED | QUEUED, FAILED,
IN_PROGRESS | SUCCEEDED SUCCEEDED, TIMED_OUT,
| FAILED | | TIMED_OUT | CANCELED o REJECTED).
REJECTED | REMOVED |
CANCELED
forceCanceled booleano Es true si la ejecución del

trabajo se canceló con el
Clase de Java: parámetro opcional force
java.lang.Boolean establecido en true.
statusDetails JobExecutionStatusDetails Un conjunto de pares nombre-

de ejecución del trabajo.
detailsMap map El estado de la ejecución de

trabajo.
Clave: DetailsKey
Valor: DetailsValue
478
DetailsKey string
DetailsValue string
thingArn string El ARN del objeto en el que se

está ejecutando la ejecución de
trabajo.
queuedAt timestamp El tiempo, en segundos, desde

puso en cola la ejecución de
trabajo.
startedAt timestamp El tiempo, en segundos, desde

inició la ejecución.

actualizó la ejecución de trabajo
por última vez.

dígitos del "0" al "9") que
Clase de Java: java.lang.Long identifica esta ejecución de
trabajo en este dispositivo. Se
puede utilizar en comandos
que devuelven o actualizan la
información de ejecución del
trabajo.
versionNumber long La versión de la ejecución de

trabajos. Las versiones de
ejecución de trabajo aumentan
cada vez que un dispositivo las
actualiza.
GetJobDocument
GetJobDocument command
Obtiene el documento de trabajo para un trabajo.

Note
Las URL de marcador de posición no se reemplazan por las URL de Amazon S3 prefirmadas
en el documento devuelto. Las URL prefirmadas se generan solo cuando el servicio Jobs de
AWS IoT recibe una solicitud a través de MQTT.
479
HTTPS (9)
Solicitud:
GET /jobs/jobId/job-document
jobId
Respuesta:
{
"document": "string"
}
document
El contenido del documento de trabajo.
CLI (9)
Sinopsis:
aws iot get-job-document \

--job-id <value> \
{
"jobId": "string"
}

Salida:
{
"document": "string"
}
480
documento string El contenido del documento de

trabajo.
ListExecutionsForJob command
Obtiene una lista de ejecuciones de trabajo para un trabajo.

HTTPS (10)
Solicitud:
GET /jobs/jobId/things?status=status&maxResults=maxResults&nextToken=nextToken
jobId

status
Opcional. Un filtro que le permite buscar trabajos que tienen el estado especificado: QUEUED,
IN_PROGRESS, SUCCEEDED, FAILED, TIMED_OUT, REJECTED, REMOVED o CANCELED.
maxResults
Opcional. El número máximo de resultados que se van a devolver por solicitud.

nextToken
Opcional. El token para recuperar el siguiente grupo de resultados.
Respuesta:
{
"executionSummaries": [ JobExecutionSummary ... ]
}
executionSummaries
Una lista de objetos JobExecutionSummary (p. 444) asociados al ID de trabajo especificado.
CLI (10)
Sinopsis:
aws iot list-job-executions-for-job \

--job-id <value> \
[--status <value>] \
[--max-results <value>] \
[--next-token <value>] \
481
{
"jobId": "string",
"status": "string",
"maxResults": "integer",
"nextToken": "string"
}

status string El estado del trabajo.
enum: QUEUED |
IN_PROGRESS | SUCCEEDED
| FAILED | TIMED_OUT |
CANCELED
maxResults integer El número máximo de

resultados que se van a
Clase de Java: java.lang.Integer devolver por solicitud.
Rango máx.: 250; mín.: 1
nextToken string El token para recuperar el

siguiente grupo de resultados.
Salida:
{
{
"status": "string",
}
}
],
}

executionSummaries list Una lista de resúmenes de

Miembro:
JobExecutionSummaryForJob
482

JobExecutionSummaryForJob JobExecutionSummaryForJob
thingArn string El ARN del objeto en el que se

está ejecutando la ejecución de
trabajo.
jobExecutionSummary JobExecutionSummary Contiene una subred de

información acerca de una

trabajo.
enum: QUEUED |
CANCELED

trabajo.


por última vez.

trabajo en este dispositivo.
Se puede utilizar después en
comandos que devuelven o
actualizan la información de
nextToken string El token para el conjunto

siguiente de resultados o nulo si
no hay resultados adicionales.
ListJobExecutionsForThing command
Obtiene una lista de ejecuciones de trabajo para un objeto.

HTTPS (11)
Solicitud:
483
GET /things/thingName/jobs?status=status&maxResults=maxResults&nextToken=nextToken
thingName
El nombre de un objeto para el que aparecerá JobExecutions.

status
Un filtro opcional que le permite buscar trabajos que tienen el estado especificado: QUEUED,
IN_PROGRESS, SUCCEEDED, FAILED, TIMED_OUT, REJECTED, REMOVED o CANCELED.
maxResults
El número máximo de resultados que se van a devolver por solicitud.

nextToken
El token para el conjunto siguiente de resultados o null si no hay resultados adicionales.
Respuesta:
{
"executionSummaries": [ JobExecutionSummary ... ]
}
executionSummaries
Una lista de los objetos JobExecutionSummary (p. 444) para las ejecuciones de trabajo
asociadas al objeto especificado.
CLI (11)
Sinopsis:
aws iot list-job-executions-for-thing \

{
"status": "string",
}
thingName string El nombre del objeto.
484
status string Un filtro opcional que le permite

buscar trabajos que tienen un
enum: QUEUED | estado especificado.
CANCELED

resultados que se van a
Clase de Java: java.lang.Integer devolver por solicitud.

Salida:
{
{
"jobId": "string",
"status": "string",
}
}
],
}
executionSummaries list Una lista de resúmenes de

Miembro:
JobExecutionSummaryForThing
JobExecutionSummaryForThing JobExecutionSummaryForThing

jobExecutionSummary JobExecutionSummary Contiene una subred de

información acerca de una
485

trabajo.
enum: QUEUED |
CANCELED

trabajo.


por última vez.

trabajo en este dispositivo.
Se puede utilizar después en
comandos que devuelven o
actualizan la información de

ListJobs
ListJobs command
Obtiene una lista de los objetos de la cuenta de AWS.

HTTPS (12)
Solicitud:
GET /jobs?
status=status&targetSelection=targetSelection&thingGroupName=thingGroupName&thingGroupId=thingGroup
status
Opcional. Un filtro que le permite buscar trabajos que tienen el estado especificado:
IN_PROGRESS, CANCELED o SUCCEEDED.
targetSelection
Opcional. Un filtro que le permite buscar trabajos que tienen el valor targetSelection
especificado: CONTINUOUS o SNAPSHOT.
486
thingGroupName
Opcional. Un filtro que le permite buscar trabajos que tienen el nombre de grupo de objetos
especificado como un destino.
thingGroupId
Opcional. Un filtro que le permite buscar trabajos que tienen el ID de grupo de objetos
especificado como un destino.
maxResults
Opcional. El número máximo de resultados que se van a devolver por solicitud.

nextToken
Opcional. El token para recuperar el siguiente grupo de resultados.
Respuesta:
{
"jobs": [ JobSummary ... ],
}
jobs
Una lista de objetos JobSummary (p. 442), uno para cada trabajo de la cuenta de AWS que
coincide con los criterios de filtrado especificados.
CLI (12)
Sinopsis:
aws iot list-jobs \

[--target-selection <value>] \
[--thing-group-name <value>] \
[--thing-group-id <value>] \
{
"status": "string",
"nextToken": "string",
"thingGroupName": "string",
"thingGroupId": "string"
}
status string Un filtro opcional que le permite

buscar trabajos que tienen un
estado especificado.
487

enum: IN_PROGRESS |

el trabajo.

resultados que devolver por
Clase de Java: java.lang.Integer solicitud.

thingGroupName string Un filtro que limita los trabajos

devueltos a los del grupo
Longitud máx.: 128 min.: 1 especificado.
thingGroupId string Un filtro que limita los trabajos

devueltos a los del grupo
Longitud máx.: 128; mín.: 1 especificado.
Patrón: [a-zA-Z0-9-]+
Salida:
{
"jobs": [
{
"jobArn": "string",
"jobId": "string",
"thingGroupId": "string",
"status": "string",
"createdAt": "timestamp",
"completedAt": "timestamp"
}
],
488
}
jobs list Una lista de trabajos.
Miembro: JobSummary
JobSummary JobSummary

thingGroupId string El ID del grupo de objetos.

el trabajo.
status string El estado del resumen de

objetos.
enum: IN_PROGRESS |
createdAt timestamp El tiempo, en segundos, desde

creó el trabajo.

489

actualizó el trabajo por última
vez.
completedAt timestamp El tiempo, en segundos, desde

completó el trabajo.

UpdateJob
UpdateJob command
Actualiza los campos admitidos del trabajo especificado. Los valores actualizados de
timeoutConfig surten efecto solo en ejecuciones recientemente en curso. Las ejecuciones en curso
en ese momento siguen haciéndolo con la antigua configuración de tiempo de espera.
HTTPS (13)
Solicitud:
PATCH /jobs/jobId
{
"roleArn": "string"
},
"baseRatePerMinute": number,
"incrementFactor": number,
"numberOfNotifiedThings": number,
"numberOfSucceededThings": number
},
"maximumPerMinute": number
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
"minNumberOfExecutedThings": number,
"thresholdPercentage": number
}
]
},
"timeoutConfig": {
}
}
jobId
Un identificador de trabajo que debe ser exclusivo para su cuenta de AWS. Recomendamos
utilizar un UUID. Aquí pueden utilizarse caracteres alfanuméricos, "-" y "_".
490
description
Opcional. Una descripción breve de texto.

presignedUrlConfigData
Opcional. Información de configuración de las URL de Amazon S3 prefirmadas.

roleArn
El ARN del rol de IAM que contiene permisos para acceder al bucket de Amazon S3. Este es
el bucket que contiene los datos que los dispositivos descargan con las URL de Amazon S3
prefirmadas. Este rol debe también conceder el permiso de AWS IoT para asumir el rol. Para
obtener más información, consulte Creación de trabajos (p. 418).
expiresInSec

maximumPerMinute
El número máximo de objetos al que se enviará el trabajo para la ejecución (por minuto). Los
valores válidos son de 1 a 1000. Si no se especifica, el valor predeterminado es 1000. El
número real de objetos que recibe el trabajo puede ser inferior durante cualquier intervalo de
minutos determinado (por la latencia del sistema), pero no es superior al valor especificado.
exponentialRate

baseRatePerMinute
El número mínimo de objetos a los que se notificará un trabajo pendiente, por minuto,
al empezar a desplegarse un trabajo. Este parámetro le permite definir la tasa inicial del
despliegue.
incrementFactor

Los criterios para iniciar el aumento en la tasa de despliegue de un trabajo. Los valores
establecidos para numberOfNotifiedThings o numberOfSucceededThings, pero
no ambos.

despliegue.
despliegue.
abortConfig

criteriaList
491
action

failureType
anulación.

thresholdPercentage
trabajo.
timeoutConfig
Respuesta:
HTTP/1.1 200
Si la acción se realiza correctamente, el servicio devuelve una respuesta HTTP 200 con un cuerpo
HTTP vacío.
CLI (13)
Sinopsis:
aws iot update-job \

--job-id <value> \
[--description <value>] \
[--presigned-url-config <value>] \
[--job-executions-rollout-config <value>] \
[--abort-config <value>] \
[--timeout-config <value>] \
{
"roleArn": "string"
},
492
"baseRatePerMinute": number,
"incrementFactor": number,
"numberOfNotifiedThings": number,
"numberOfSucceededThings": number
}
},
"maximumPerMinute": number
},
"abortConfig": {
"criteriaList": [
{
"action": "string",
"minNumberOfExecutedThings": number,
"thresholdPercentage": number
}
]
},
"timeoutConfig": {
}
}
jobId string Un identificador de trabajo

que debe ser exclusivo
Longitud máx.: 64; mín.: 1 para su cuenta de AWS.
Recomendamos utilizar un
Patrón: [a-zA-Z0-9_-]+ UUID. Aquí se pueden usar los
caracteres alfanuméricos, "-" y
"_".
patrón: [^\\p{C}]+
presignedUrlConfig PresignedUrlConfig Información de configuración de

las URL de S3 prefirmadas.

bucket de S3 en el que se
almacenaron los datos o las
actualizaciones del trabajo.
también para que AWS IoT
descargue los archivos.

493





a los que se notificará un
despliegue.

para un trabajo.

pero no ambos.

despliegue.

despliegue.

anular un trabajo.

el trabajo.
494

trabajo.

anulación.


java.lang.Double) total de objetos ejecutados que
inicia la anulación de un trabajo.

no 10.999).

del trabajo. El temporizador
trabajo no se establece en otro
estado terminal antes de que se
cumpla el plazo, se establecerá
en TIMED_OUT.

tiempo, en minutos, que tiene
este dispositivo para finalizar
la ejecución de este trabajo.
Un temporizador se inicia o
reinicia, siempre que el estado
especifica como IN_PROGRESS
con este campo relleno. Si
el estado de ejecución del
trabajo no se ha establecido
en un estado terminal antes
de que el temporizador venza,
o antes de que se envíe otra
actualización de estado de
ejecución del trabajo con este
campo rellenado, el estado se
establece en TIMED_OUT.
495
API de MQTT y HTTPS de dispositivo de trabajo
documentParameters map Parámetros para el documento

de trabajo.
Clave: ParameterKey
ParameterKey string
patrón: [^\\p{C}]+
Salida:
HTTP/1.1 200
Si la acción se realiza correctamente, el servicio devuelve una respuesta HTTP 200 con un cuerpo
HTTP vacío.

Tipos de datos de MQTT y HTTPS de dispositivo
Los siguientes tipos de datos se utilizan para comunicarse con el servicio de Jobs de AWS IoT a través de
protocolos HTTPS y MQTT.
JobExecution
JobExecution data type
Contiene datos acerca de la ejecución de trabajo.

Syntax (7)
{
"jobId" : "string",
"thingName" : "string",
"jobDocument" : "string",
REMOVED",
"statusDetails": {
"string": "string"
},
"queuedAt" : "timestamp",
"startedAt" : "timestamp",
"lastUpdatedAt" : "timestamp",
"versionNumber" : "number",
}
496
Description (7)
jobId

thingName
El nombre del objeto que está ejecutando el trabajo.

jobDocument
El contenido del documento de trabajo.

status
El estado de la ejecución de trabajo. Puede ser: QUEUED, IN_PROGRESS, FAILED,

SUCCEEDED, CANCELED, TIMED_OUT, REJECTED o REMOVED.
statusDetails

queuedAt
startedAt

lastUpdatedAt
última vez.
versionNumber
La versión de la ejecución de trabajos. Las versiones de ejecución de trabajo aumentan cada vez
que un dispositivo las actualiza.
executionNumber
Un número que identifica la ejecución de un trabajo en un dispositivo. Se puede utilizar después

en comandos que devuelven o actualizan la información de ejecución de trabajo.
JobExecutionState
JobExecutionState data type
Contiene datos acerca del estado de una ejecución de trabajo.

Syntax (8)
{
REMOVED",
"statusDetails": {
"string": "string"
...
}
"versionNumber": "number"
}
497
Description (8)
status
El estado de la ejecución de trabajo. Puede ser: QUEUED, IN_PROGRESS, FAILED,

SUCCEEDED, CANCELED, TIMED_OUT, REJECTED o REMOVED.
statusDetails

versionNumber
La versión de la ejecución de trabajos. Las versiones de ejecución de trabajo aumentan cada vez
que un dispositivo las actualiza.
JobExecutionSummary
JobExecutionSummary data type
Contiene una subred de información acerca de una ejecución de trabajo.

Syntax (9)
{
"jobId": "string",
"versionNumber": "number",
}
Description (9)
jobId

queuedAt
startedAt

lastUpdatedAt
última vez.
versionNumber
La versión de la ejecución de trabajos. Las versiones de ejecución del trabajo se incrementan

cada vez que el servicio Jobs de AWS IoT recibe una actualización desde un dispositivo.
executionNumber
Un número que identifica la ejecución de un trabajo en un dispositivo.
498
ErrorResponse
ErrorResponse data type
Contiene información acerca de un error que se produjo durante una operación del servicio Jobs de
AWS IoT.
Syntax (10)
{
"code": "ErrorCode",
"message": "string",
"clientToken": "string",
"executionState": JobExecutionState
}
Description (10)
code
ErrorCode se puede establecer en:

InvalidTopic
La solicitud se envió a un tema en el espacio de nombres de Jobs de AWS IoT que no está
asignado a ninguna API.
InvalidJson
El contenido de la solicitud podría no interpretarse como un formato JSON con codificación

UTF-8 válida.
InvalidRequest
solicitud UpdateJobExecution contiene detalles de estado no válido. El mensaje contiene
detalles acerca del error.
InvalidStateTransition
Una actualización intentó cambiar la ejecución de trabajo a un estado que no es válido debido
al estado actual de la ejecución de trabajo (por ejemplo, un intento de cambiar una solicitud
con un estado SUCCEEDED a un estado IN_PROGRESS). En este caso, el cuerpo del
mensaje de error también contiene el campo executionState.
ResourceNotFound
El JobExecution especificado por el tema de la solicitud no existe.

VersionMismatch
La versión esperada especificada en la solicitud no coincide con la versión de la ejecución del

trabajo en el servicio Jobs de AWS IoT. En este caso, el cuerpo del mensaje de error también
contiene el campo executionState.
InternalError
Se ha producido un error interno al procesar la solicitud.

RequestThrottled
La solicitud se ha limitado.
TerminalStateReached
Se produce cuando un comando para describir un trabajo se realiza en un trabajo que está en
un estado terminal.
499
message
Una cadena de mensajes de error.

clientToken
Una cadena arbitraria utilizada para correlacionar una solicitud con su respuesta.
timestamp
El tiempo, en segundos, desde la fecha de inicio.

executionState
Un objeto JobExecutionState (p. 497). Este campo se incluye solo cuando el campo code tiene
el valor InvalidStateTransition o VersionMismatch. Esto hace que no sea necesario en
esos casos realizar una solicitud DescribeJobExecution independiente para obtener los datos
de estado de ejecución de trabajo actuales.
Comandos de dispositivos
Los siguientes comandos están disponibles a través de los protocolos MQTT y HTTPS.
GetPendingJobExecutions
GetPendingJobExecutions command
Obtiene la lista de todos los trabajos para un objeto que no está en un estado terminal.
MQTT (12)
Para invocar esta API, publique un mensaje en $aws/things/thingName/jobs/get.
Carga de solicitud:
{ "clientToken": "string" }
clientToken
Opcional. Un token de cliente utilizado para correlacionar solicitudes y respuestas. Introduzca un

valor arbitrario aquí y se reflejará en la respuesta.
Para recibir la respuesta, suscríbase a:
• $aws/things/thingName/jobs/get/accepted y
• $aws/things/thingName/jobs/get/rejected o
• $aws/things/thingName/jobs/get/# para ambos.
Carga de respuesta:
{
"inProgressJobs" : [ JobExecutionSummary ... ],
"queuedJobs" : [ JobExecutionSummary ... ],
"timestamp" : 1489096425069,
"clientToken" : "client-001"
}
inProgressJobs
Una lista de objetos JobExecutionSummary (p. 498) con el estado IN_PROGRESS.
500
queuedJobs
Una lista de objetos JobExecutionSummary (p. 498) con el estado QUEUED.

clientToken
Un token de cliente utilizado para correlacionar solicitudes y respuestas.

timestamp
El tiempo, en segundos, desde la fecha de inicio, cuando se envió el mensaje.
HTTPS (12)
Solicitud:
GET /things/thingName/jobs
thingName
El nombre del objeto asociado con el dispositivo.
Respuesta:
{
"inProgressJobs" : [ JobExecutionSummary ... ],
"queuedJobs" : [ JobExecutionSummary ... ]
}
inProgressJobs
Una lista de objetos JobExecutionSummary (p. 498).

queuedJobs
Una lista de objetos JobExecutionSummary (p. 498).
CLI (12)
Sinopsis:
aws iot-jobs-data get-pending-job-executions \

{
"thingName": "string"
}
thingName string El nombre del objeto que está

ejecutando el trabajo.
501

Salida:
{
"inProgressJobs": [
{
"jobId": "string",
"queuedAt": long,
"startedAt": long,
"lastUpdatedAt": long,
"versionNumber": long,
}
],
"queuedJobs": [
{
"jobId": "string",
"queuedAt": long,
"startedAt": long,
}
]
}
inProgressJobs list Una lista de objetos

JobExecutionSummary con el
Miembro: estado IN_PROGRESS.
JobExecutionSummary
JobExecutionSummary JobExecutionSummary

queuedAt long El tiempo, en segundos, desde

trabajo.
startedAt long El tiempo, en segundos, desde

Clase de Java: java.lang.Long inició la ejecución.
lastUpdatedAt long El tiempo, en segundos, desde

502

por última vez.
versionNumber long La versión de la ejecución

de trabajos. Las versiones
incrementan cada vez que
recibe una actualización desde
un dispositivo.
executionNumber long Un número que identifica la

ejecución de un trabajo en un
Clase de Java: java.lang.Long dispositivo.
queuedJobs list Una lista de objetos

JobExecutionSummary con el
Miembro: estado QUEUED.
JobExecutionSummary
JobExecutionSummary JobExecutionSummary


trabajo.


por última vez.
versionNumber long La versión de la ejecución

de trabajos. Las versiones
incrementan cada vez que
recibe una actualización desde
un dispositivo.

Clase de Java: java.lang.Long dispositivo.
503
StartNextPendingJobExecution
StartNextPendingJobExecution command
Obtiene e inicia la siguiente ejecución de trabajo pendiente para un objeto (estado IN_PROGRESS o
QUEUED).
• Las ejecuciones de trabajo con el estado IN_PROGRESS se devuelven en primer lugar.

• Las ejecuciones de trabajo se devuelven en el orden en el que se crearon.
• Si la siguiente ejecución de trabajo pendiente es QUEUED, su estado cambia a IN_PROGRESS y
los detalles del estado de la ejecución de trabajo se establecen según se haya especificado.
• Si la siguiente ejecución de trabajo pendiente está ya en IN_PROGRESS, los detalles del estado no
cambiarán.
• Si no hay ejecuciones de trabajo pendientes, la respuesta no incluirá el campo execution.
• Si lo prefiere, puede crear un temporizador de pasos estableciendo un valor para la propiedad
stepTimeoutInMinutes. Si no actualiza el valor de esta propiedad mediante la ejecución de
UpdateJobExecution, la ejecución del trabajo agotará el tiempo de espera cuando venza el
temporizador de pasos.
MQTT (13)
Para invocar esta API, publique un mensaje en $aws/things/thingName/jobs/start-next.
Carga de solicitud:
{
"statusDetails": {
"string": "job-execution-state"
...
},
"stepTimeoutInMinutes": long,
"clientToken": "string"
}
statusDetails
Un conjunto de pares nombre-valor que describen el estado de ejecución del trabajo. Si no se

especifica, statusDetails no se modifica.
stepTimeOutInMinutes
Especifica la cantidad de tiempo que tiene este dispositivo para finalizar la ejecución de este
trabajo. Si el estado de ejecución del trabajo no se ha establecido en un estado terminal antes
de que este temporizador venza o antes de que se restablezca el temporizador (llamando a
UpdateJobExecution, estableciendo el estado en IN_PROGRESS y especificando un valor
de tiempo de espera nuevo en el campo stepTimeoutInMinutes) el estado de ejecución se
establece automáticamente en TIMED_OUT. Configurar este tiempo de espera no tiene ningún
efecto en el tiempo de espera de la ejecución de ese trabajo que se pueda haber especificado
cuando se creó el trabajo (CreateJob con el campo timeoutConfig).
clientToken
Un token de cliente utilizado para correlacionar solicitudes y respuestas. Introduzca un valor

arbitrario aquí y se reflejará en la respuesta.
• $aws/things/thingName/jobs/start-next/accepted y
504
• $aws/things/thingName/jobs/start-next/rejected o
• $aws/things/thingName/jobs/start-next/# para ambos.
Carga de respuesta:
{
"execution" : JobExecutionData,
"timestamp" : timestamp,
"clientToken" : "string"
}
execution
Un objeto JobExecution (p. 496). Por ejemplo:
{
"execution" : {
"jobId" : "022",
"thingName" : "MyThing",
"jobDocument" : "< contents of job document >",
"queuedAt" : 1489096123309,
"executionNumber" : 1234567890
},
"timestamp" : 1489088524284,
}
timestamp
El tiempo, en milisegundos, desde la fecha de inicio, cuando se envió el mensaje al dispositivo.

clientToken
HTTPS (13)
Solicitud:
PUT /things/thingName/jobs/$next
{
"statusDetails": {
"string": "string"
...
},
"stepTimeoutInMinutes": long
}
thingName

statusDetails

505
stepTimeOutInMinutes
trabajo. Si el estado de ejecución del trabajo no se ha establecido en un estado terminal antes
de que este temporizador venza o antes de que se restablezca el temporizador (llamando a
UpdateJobExecution, estableciendo el estado en IN_PROGRESS y especificando un valor
de tiempo de espera nuevo en el campo stepTimeoutInMinutes) el estado de ejecución se
establece automáticamente en TIMED_OUT. Configurar este tiempo de espera no tiene ningún
efecto en el tiempo de espera de la ejecución de ese trabajo que se pueda haber especificado
cuando se creó el trabajo (CreateJob con el campo timeoutConfig).
Respuesta:
{
"execution" : JobExecution
}
execution
Un objeto JobExecution (p. 496). Por ejemplo:
{
"execution" : {
"jobId" : "022",
"jobDocument" : "< contents of job document >",
"queuedAt" : 1489096123309,
"executionNumber" : 1234567890
},
"timestamp" : 1489088524284,
}
CLI (13)
Sinopsis:
aws iot-jobs-data start-next-pending-job-execution \

{--step-timeout-in-minutes <value>] \
{
"statusDetails": {
"string": "string"
},
"stepTimeoutInMinutes": long
}
506
thingName string El nombre del objeto asociado

con el dispositivo.

Clave: DetailsKey de ejecución del trabajo. Si no
se especifica, statusDetails no
Valor: DetailsValue se modifica.
stepTimeOutInMinutes long Especifica la cantidad

de tiempo que tiene este
dispositivo para finalizar la
ejecución de este trabajo. Si el
no se ha establecido en un
estado terminal antes de que
este temporizador venza o
antes de que se restablezca
el temporizador (llamando
a UpdateJobExecution,
estableciendo el estado en
IN_PROGRESS y especificando
un valor de tiempo de
espera nuevo en el campo
stepTimeoutInMinutes)
el estado de ejecución se
establece automáticamente
en TIMED_OUT. Configurar
este tiempo de espera no tiene
ningún efecto en el tiempo de
espera de la ejecución de ese
trabajo que se pueda haber
especificado cuando se creó
el trabajo (CreateJob con el
campo timeoutConfig).
DetailsKey string
DetailsValue string
Salida:
507
"execution": {
"jobId": "string",
"status": "string",
"statusDetails": {
"string": "string"
},
"queuedAt": long,
"startedAt": long,
"jobDocument": "string"
}
}
ejecución JobExecution Un objeto JobExecution.



trabajo. Puede ser: QUEUED,
enum: QUEUED | IN_PROGRESS, FAILED,
IN_PROGRESS | SUCCEEDED SUCCEEDED, CANCELED,
| FAILED | TIMED_OUT | TIMED_OUT, REJECTED o
REJECTED | REMOVED | REMOVED.
CANCELED

Clave: DetailsKey de ejecución del trabajo.
Valor: DetailsValue
DetailsKey string
DetailsValue string

508

trabajo.


por última vez.

actualiza.

Clase de Java: java.lang.Long dispositivo. Se puede utilizar
después en comandos que
devuelven o actualizan la
información de ejecución de
trabajo.
jobDocument string El contenido del documento de

trabajo.
DescribeJobExecution command
Obtiene información detallada acerca de una ejecución de trabajo.
Puede establecer jobId en $next para devolver la siguiente ejecución de trabajo pendiente para un
objeto (estado IN_PROGRESS o QUEUED).
MQTT (14)
Para invocar esta API, publique un mensaje en $aws/things/thingName/jobs/jobId/get.
Carga de solicitud:
{
"includeJobDocument": boolean,
}
thingName

jobId
509
También puede usar $next para devolver la siguiente ejecución de trabajo pendiente para un
objeto (estado IN_PROGRESS o QUEUED). En este caso, las ejecuciones de trabajo con el
estado IN_PROGRESS se devuelven en primer lugar. Las ejecuciones de trabajo se devuelven en
el orden en el que se crearon.
executionNumber
Opcional. Un número que identifica la ejecución de un trabajo en un dispositivo. Si no se

especifica, se devuelve la ejecución de trabajo más reciente.
includeJobDocument
Opcional. Cuando no se establece en false, la respuesta contiene el documento de trabajo. El

valor predeterminado es true.
clientToken

• $aws/things/thingName/jobs/jobId/get/accepted y
• $aws/things/thingName/jobs/jobId/get/rejected o
• $aws/things/thingName/jobs/jobId/get/# para ambos.
Carga de respuesta:
{
"execution" : JobExecutionData,
"timestamp": "timestamp",
}
execution

timestamp

clientToken
HTTPS (14)
El estado de la ejecución del trabajo debe ser QUEUED o IN_PROGRESS.
Solicitud:
GET /things/thingName/jobs/jobId?
executionNumber=executionNumber&includeJobDocument=includeJobDocument
thingName

jobId
510
También puede usar $next para devolver la siguiente ejecución de trabajo pendiente para un
objeto (estado IN_PROGRESS o QUEUED). En este caso, las ejecuciones de trabajo con el
estado IN_PROGRESS se devuelven en primer lugar. Las ejecuciones de trabajo se devuelven en
el orden en el que se crearon.
includeJobDocument
Opcional. Cuando no se establece en false, la respuesta contiene el documento de trabajo. El

valor predeterminado es true.
executionNumber

especifica, se devuelve la ejecución de trabajo más reciente.
Respuesta:
{
"execution" : JobExecution,
}
execution
CLI (14)
El estado de la ejecución del trabajo debe ser QUEUED o IN_PROGRESS.
Sinopsis:
aws iot-jobs-data describe-job-execution \

--job-id <value> \
[--include-job-document | --no-include-job-document] \
{
"jobId": "string",
}

a este trabajo cuando se creó
Patrón: [a-zA-Z0-9_-]+|^$next o $next para devolver la
siguiente ejecución de trabajo
pendiente para un objeto
(estado IN_PROGRESS o
QUEUED). En este caso, las
511

ejecuciones de trabajo con
el estado IN_PROGRESS se
devuelven en primer lugar.
Las ejecuciones de trabajo se
devuelven en el orden en el que
se crearon.
thingName string El nombre de objeto asociado

con el dispositivo en el que se
Longitud máx.: 128 min.: 1 está ejecutando la ejecución de
trabajo.
includeJobDocument booleano Opcional. Cuando no se

establece en false, la respuesta
Clase de Java: contiene el documento de
java.lang.Boolean trabajo. El valor predeterminado
es true.
executionNumber long Opcional. Un número que

identifica la ejecución de un
Clase de Java: java.lang.Long trabajo en un dispositivo. Si
no se especifica, se devuelve
la ejecución de trabajo más
reciente.
Salida:
{
"execution": {
"jobId": "string",
"status": "string",
"statusDetails": {
"string": "string"
},
"queuedAt": long,
"startedAt": long,
}
}
ejecución JobExecution Contiene datos acerca de la


512


CANCELED

Valor: DetailsValue
DetailsKey string
DetailsValue string

trabajo.


por última vez.

actualiza.
513

Clase de Java: java.lang.Long dispositivo. Se puede utilizar
después en comandos que
devuelven o actualizan la
información de ejecución de
trabajo.
jobDocument string El contenido del documento de

trabajo.
UpdateJobExecution
UpdateJobExecution command
Actualiza el estado de una ejecución de trabajo. Si lo prefiere, puede crear un temporizador de pasos
estableciendo un valor para la propiedad stepTimeoutInMinutes. Si no actualiza el valor de esta
propiedad ejecutando UpdateJobExecution otra vez, la ejecución del trabajo agotará el tiempo de
espera cuando venza el temporizador de pasos.
MQTT (15)
Para invocar esta API, publique un mensaje en $aws/things/thingName/jobs/jobId/update.
Carga de solicitud:
{
"status": "job-execution-state",
"statusDetails": {
"string": "string"
...
},
"expectedVersion": "number",
"includeJobExecutionState": boolean,
}
status
El nuevo estado de ejecución de trabajo (IN_PROGRESS, FAILED, SUCCEEDED o REJECTED).

Debe especificarse en cada actualización.
statusDetails

expectedVersion
La versión actual esperada de la ejecución de trabajos. Cada vez que actualiza la ejecución de
trabajos, aumenta su versión. Si la versión de la ejecución del trabajo almacenada en el servicio
Jobs de AWS IoT no coincide, la actualización se rechaza con un error VersionMismatch y se
devuelve un código ErrorResponse (p. 499) con los datos de estado de la ejecución del trabajo
actual. (Esto hace que no sea necesario realizar una solicitud DescribeJobExecution aparte
para obtener los datos de estado de ejecución del trabajo).
514
executionNumber

especifica, se utiliza la ejecución de trabajo más reciente.
includeJobExecutionState
Opcional. Cuando se incluye y establece en true, la respuesta contiene el campo

JobExecutionState. El valor predeterminado es false.
includeJobDocument
Opcional. Cuando se incluye y establece en true, la respuesta contiene el JobDocument. El

valor predeterminado es false.
stepTimeoutInMinutes
trabajo. Si el estado de ejecución del trabajo no se ha establecido en un estado terminal antes de
que este temporizador venza o antes de que se restablezca el temporizador (llamando otra vez
a UpdateJobExecution, estableciendo el estado en IN_PROGRESS y especificando un valor
de tiempo de espera nuevo en este campo), el estado de ejecución del trabajo se establece en
TIMED_OUT. Configurar o restablecer este tiempo de espera no tiene ningún efecto en el tiempo
de espera de la ejecución del trabajo que se pueda haber especificado cuando se creó el trabajo
(utilizando CreateJob con el campo timeoutConfig).
clientToken

• $aws/things/thingName/jobs/jobId/update/accepted y
• $aws/things/thingName/jobs/jobId/update/rejected o
• $aws/things/thingName/jobs/jobId/update/# para ambos.
Carga de respuesta:
{
"executionState": JobExecutionState,
"jobDocument": "string",
}
executionState
Un objeto JobExecutionState (p. 497).

jobDocument
Un objeto documento de trabajo (p. 413).

timestamp

clientToken
515
HTTPS (15)
Solicitud:
POST /things/thingName/jobs/jobId
{
"status": "job-execution-state",
"statusDetails": {
"string": "string"
...
},
"expectedVersion": "number",
}
thingName

jobId

status
El nuevo estado de ejecución de trabajo (IN_PROGRESS, FAILED, SUCCEEDED o REJECTED).

Debe especificarse en cada actualización.
statusDetails
Opcional. Un conjunto de pares nombre-valor que describen el estado de ejecución del trabajo. Si
no se especifica, statusDetails no se modifica.
expectedVersion
Opcional. La versión actual esperada de la ejecución de trabajos. Cada vez que actualiza
la ejecución de trabajos, aumenta su versión. Si la versión de la ejecución del trabajo
almacenada en el servicio Jobs de AWS IoT no coincide, la actualización se rechaza con un
error VersionMismatch y se devuelve un código ErrorResponse (p. 499) con los datos de
estado de la ejecución del trabajo actual. (Esto hace que no sea necesario realizar una solicitud
DescribeJobExecution aparte para obtener los datos de estado de ejecución del trabajo).
includeJobExecutionState
Opcional. Cuando se incluye y establece en true, la respuesta contiene los datos de

JobExecutionState. El valor predeterminado es false.
includeJobDocument
Opcional. Cuando se establece en true, el código contiene el documento de trabajo. El valor

trabajo. Si el estado de ejecución del trabajo no se ha establecido en un estado terminal antes de
que este temporizador venza o antes de que se restablezca el temporizador (llamando otra vez
a UpdateJobExecution, estableciendo el estado en IN_PROGRESS y especificando un valor
de tiempo de espera nuevo en este campo), el estado de ejecución del trabajo se establece en
TIMED_OUT. Configurar o restablecer este tiempo de espera no tiene ningún efecto en el tiempo
de espera de la ejecución del trabajo que se pueda haber especificado cuando se creó el trabajo
(utilizando CreateJob con el campo timeoutConfig).
516
executionNumber
Opcional. Un número que identifica la ejecución de un trabajo en un dispositivo.
Respuesta:
{
"executionState": JobExecutionState,
}
executionState
Un objeto JobExecutionState (p. 497).

jobDocument
El contenido del documento de trabajo (p. 413).
CLI (15)
Sinopsis:
aws iot-jobs-data update-job-execution \

--job-id <value> \
--status <value> \
[--include-job-execution-state | --no-include-job-execution-state] \
[--include-job-document | --no-include-job-document] \
[--step-timeout-in-minutes <value>] \
{
"jobId": "string",
"status": "string",
"statusDetails": {
"string": "string"
},
"stepTimeoutInMinutes": number,
"expectedVersion": long,
}

517

thingName string El nombre del objeto asociado

con el dispositivo.
status string El nuevo estado de ejecución

de trabajo (IN_PROGRESS,
enum: QUEUED | FAILED, SUCCEEDED
IN_PROGRESS | SUCCEEDED o REJECTED). Debe
| FAILED | TIMED_OUT | especificarse en cada
REJECTED | REMOVED | actualización.
CANCELED
statusDetails map Opcional. Un conjunto de pares

nombre-valor que describen
Clave: DetailsKey el estado de ejecución del
trabajo. Si no se especifica,
Valor: DetailsValue statusDetails no se modifica.
DetailsKey string
DetailsValue string
518
long
Especifica la cantidad
de tiempo que tiene este
dispositivo para finalizar la
ejecución de este trabajo. Si el
no se ha establecido en un
estado terminal antes de que
este temporizador venza o
antes de que se restablezca
el temporizador (llamando otra
vez a UpdateJobExecution,
estableciendo el estado en
IN_PROGRESS y especificando
un valor de tiempo de espera
nuevo en este campo), el
se establece en TIMED_OUT.
Configurar o restablecer este
tiempo de espera no tiene
ningún efecto en el tiempo
de espera de la ejecución
del trabajo que se pueda
haber especificado cuando
se creó el trabajo (utilizando
CreateJob con el campo
timeoutConfig).
expectedVersion long Opcional. La versión actual

esperada de la ejecución
Clase de Java: java.lang.Long de trabajos. Cada vez que
actualiza la ejecución de
trabajos, aumenta su versión.
Si la versión de la ejecución
del trabajo almacenada en
no coincide, la actualización
se rechaza con un error
VersionMismatch y se
devuelve ErrorResponse
con los datos de estado
de la ejecución de trabajo
actuales. (Esto hace que no
sea necesario realizar una
solicitud DescribeJobExecution
aparte para obtener los datos
de estado de ejecución del
trabajo).
519
includeJobExecutionState booleano Opcional. Cuando se incluye

y establece en true, la
Clase de Java: respuesta contiene los datos
java.lang.Boolean de JobExecutionState. El valor
includeJobDocument booleano Opcional. Cuando se establece

en true, el código contiene el
Clase de Java: documento de trabajo. El valor
java.lang.Boolean predeterminado es false.
executionNumber long Opcional. Un número que

identifica la ejecución de un
Clase de Java: java.lang.Long trabajo en un dispositivo.
Salida:
{
"executionState": {
"status": "string",
"statusDetails": {
"string": "string"
},
"versionNumber": long
},
}
executionState JobExecutionState Un objeto JobExecutionState.

CANCELED

Valor: DetailsValue
DetailsKey string
DetailsValue string
520


actualiza.
jobDocument string El contenido de los documentos

de trabajos.
JobExecutionsChanged
JobExecutionsChanged message
Se envía cuando se añade una ejecución de trabajo a la lista de ejecuciones de trabajo pendientes
para un objeto, o cuando se quita de dicha lista.
MQTT (16)
Tema: $aws/things/thingName/jobs/notify
Carga de mensaje:
{
"jobs" : {
"JobExecutionState": [ JobExecutionSummary (p. 444) ... ]
},
}
HTTPS (16)
No disponible.
CLI (16)
No disponible.
NextJobExecutionChanged
NextJobExecutionChanged message
Se envía cuando se produce un cambio en el que la ejecución de trabajo es la siguiente

en la lista de ejecuciones de trabajo pendientes para un objeto, como se define para
DescribeJobExecution (p. 509) con jobId $next. Este mensaje no se envía cuando cambian
los detalles de ejecución del siguiente trabajo, solo cuando el siguiente trabajo que devolvería
DescribeJobExecution con jobId $next ha cambiado. Considere las ejecuciones de trabajo
J1 y J2 con el estado QUEUED. J1 es el siguiente elemento de la lista de ejecuciones de trabajo
pendientes. Si el estado de J2 cambia a IN_PROGRESS mientras el estado de J1 permanece
invariable, se envía esta notificación y contiene los detalles de J2.
MQTT (17)
Tema: $aws/things/thingName/jobs/notify-next
Carga de mensaje:
521
Despliegue de trabajos y configuración de anulaciones
{
"execution" : JobExecution (p. 443),
}
HTTPS (17)
No disponible.
CLI (17)
No disponible.
Despliegue de trabajos y configuración de

anulaciones
Los trabajos de AWS IoT se pueden implementar con tasas de despliegue variables según se cumplan
distintos criterios y umbrales. los despliegues de los trabajos también se pueden anular si el número
de trabajos con error coincide con una serie de criterios. Estas configuraciones de despliegue le
portan un control más detallado sobre el radio de acción de un trabajo. Los criterios de la tasa
de despliegue de un trabajo se establecen en el momento de crear un trabajo a través del objeto
JobExecutionsRolloutConfig. Los criterios de cancelación de un trabajo se establecen en el
momento de crear un trabajo a través del objeto AbortConfig.
Uso de tasas de despliegue de trabajos

Para establecer una tasa de despliegue de un trabajo debe configurar la propiedad
ExponentialRolloutRate del objeto JobExecutionsRolloutConfig al ejecutar la API
CreateJob. En el siguiente ejemplo se establece una tasa de despliegue variable mediante el parámetro
exponentialRate.
{
...
"baseRatePerMinute": 50,
"incrementFactor": 2,
"numberOfNotifiedThings": 1000, // Set one or the other
"numberOfSucceededThings": 1000 // of these two values.
},
"maximumPerMinute": 1000
...
}
El parámetro baseRatePerMinute especifica la tasa según la cual se ejecutan los trabajos hasta llegar al
umbral numberOfNotifiedThings o numberOfSucceededThings.
El parámetro incrementFactor especifica el factor exponencial según el cual aumenta la tasa de

despliegue tras alcanzar el umbral numberOfNotifiedThings o numberOfSucceededThings.
El parámetro rateIncreaseCriteria es un objeto que especifica el umbral

numberOfNotifiedThings o numberOfSucceededThings.
522
Uso de configuraciones de anulaciones
de despliegues de trabajos
El parámetro maximumPerMinute especifica el límite superior de la tasa según la cual pueden producirse
las ejecuciones de los trabajos. Los valores válidos están comprendidos entre 1 y 1000. Este parámetro es
necesario al transferir un objeto ExponentialRate. En un despliegue según una tasa variable, este valor
establece el límite superior de la tasa de despliegue de trabajos.
Un despliegue de trabajos con la configuración anterior se iniciaría según una tasa de 50 ejecuciones de
trabajos por minuto. Continuaría según esa tasa hasta que bien 1000 objetos hayan recibido notificaciones
de ejecución de trabajos (si se ha especificado un valor para numberOfNotifiedThings) o se
hayan producido correctamente 1000 ejecuciones de trabajos (si se ha especificado un valor para
numberOfSucceededThings).
En la siguiente tabla se muestra cómo se produciría el despliegue durante los primeros cuatro incrementos.
Tasa de 50 100 200 400

despliegue por
minuto
Número de 1 000 2000 3 000 4000

dispositivos
notificados o
ejecuciones
correctas
La siguiente configuración establece una tasa de despliegue estática.
{
...
"maximumPerMinute": 1000
...
}
El parámetro maximumPerMinute especifica el límite superior de la tasa según la cual pueden producirse
las ejecuciones de los trabajos. Los valores válidos están comprendidos entre 1 y 1000. Este parámetro es
opcional. Si no especifica un valor, se utiliza el valor predeterminado de 1000.
Uso de configuraciones de anulaciones de

despliegues de trabajos
Puede configurar una condición de anulación de un trabajo configurando el objeto opcional AbortConfig
al ejecutar la API CreateJob. En esta sección se describe el efecto que la siguiente configuración de
muestra tendría sobre el despliegue de un trabajo que ha experimentando varias ejecuciones fallidas.
"abortConfig": {
"criteriaList": [
{
"action": "CANCEL",
"failureType": "FAILED",
"minNumberOfExecutedThings": 100,
"thresholdPercentage": 20
},
{
"action": "CANCEL",
523
Límites de los trabajos
"failureType": "TIMED_OUT",
"minNumberOfExecutedThings": 200,
"thresholdPercentage": 50
}
]
}
El parámetro action especifica la acción que se debe realizar cuando se han cumplido los criterios de
anulación. Este parámetro es necesario, y CANCEL es el único valor válido.
El parámetro failureType especifica qué tipos de error deben activar la anulación de un trabajo. Los
valores válidos son FAILED, REJECTED, TIMED_OUT y ALL.
El parámetro minNumberOfExecutedThings especifica el número de ejecuciones de trabajos

completadas que deben ocurrir antes de que el servicio compruebe si se cumplen los criterios de anulación
del trabajo. En este ejemplo, AWS IoT no comprueba si se debe anular un trabajo hasta que al menos 100
dispositivos hayan completado ejecuciones de trabajos.
El parámetro thresholdPercentage especifica el número total de objetos ejecutados que inician

la anulación de un trabajo. En este ejemplo, AWS IoT inicia la anulación de un trabajo y cancela su
despliegue si al menos el 20 % de todas las ejecuciones completadas han dado algún tipo de error
después de 100 ejecuciones completadas.
Note
Suprimir ejecuciones de trabajos afecta al valor de cálculo del total de ejecuciones realizadas.
Cuando se anula un trabajo, el servicio crea valores comment y reasonCode automáticos para
diferenciar una cancelación promovida por un usuario de una de anulación de un trabajo.
Límites de los trabajos

Para obtener información sobre límite de trabajos, consulte Puntos de enlace y cuotas de AWS IoT en la
AWS General Reference.
524
Conceptos de tunelización segura
Tunelización segura de AWS IoT

Cuando los dispositivos se implementan detrás de firewalls restringidos en sitios remotos, necesita una
forma de obtener acceso a esos dispositivos para solucionar problemas, aplicar actualizaciones de
configuración y otras tareas operativas. La tunelización segura ayuda a los clientes a establecer una
comunicación bidireccional con dispositivos remotos a través de una conexión segura administrada por
AWS IoT. La tunelización segura no requiere actualizaciones de la regla de firewall entrante existente, por
lo que puede mantener el mismo nivel de seguridad proporcionado por las reglas de firewall en un sitio
remoto.
Por ejemplo, un sensor instalado en una fábrica que está a varios kilómetros de distancia está teniendo
problemas para medir la temperatura de la fábrica. Puede utilizar la tunelización segura para abrir e iniciar
rápidamente una sesión en ese sensor. Después de identificar el problema (por ejemplo, un archivo de
configuración incorrecto), puede restablecer el archivo y reiniciar el sensor a través de la misma sesión.
En comparación con una solución de problemas más tradicional (por ejemplo, enviar a un técnico a la
fábrica para que revise el sensor), la tunelización segura reduce la respuesta a incidentes y el tiempo de
recuperación, así como los costos de explotación.
Conceptos de tunelización segura

Token de acceso de cliente (CAT)
Un par de tokens generados por la tunelización segura cuando se crea un nuevo túnel. Los
dispositivos de origen y destino utilizan el CAT para conectarse al servicio Tunelización segura.
Aplicación de destino
La aplicación que se ejecuta en el dispositivo de destino. Por ejemplo, la aplicación de destino puede
ser un daemon SSH para establecer una sesión SSH mediante tunelización segura.
Dispositivo de destino
El dispositivo remoto al que desea obtener acceso.

Agente de dispositivo
Una aplicación de IoT que se conecta al gateway de dispositivos de AWS IoT y está a la escucha de
nuevas notificaciones de túnel a través de MQTT.
Proxy local
Proxy de software que se ejecuta en los dispositivos de origen y destino y retransmite una secuencia
de datos entre el servicio Tunelización segura y la aplicación del dispositivo. El proxy local se puede
ejecutar en modo de origen o modo de destino. Para obtener más información, consulte Proxy
local (p. 531).
Dispositivo de origen
El dispositivo que un operador utiliza para iniciar una sesión en el dispositivo de destino, normalmente
un equipo portátil o de sobremesa.
Túnel
Una ruta lógica a través de AWS IoT que permite la comunicación bidireccional entre un dispositivo de
origen y un dispositivo de destino.
525
Tutorial de tunelización segura
Tutorial de tunelización segura

En este tutorial, abrirá un túnel y lo utilizará para iniciar una sesión SSH en un dispositivo remoto. El
dispositivo remoto está detrás de firewalls que bloquean todo el tráfico entrante, lo que imposibilita una
conexión SSH directa en el dispositivo. Antes de comenzar, asegúrese de que sabe cómo registrar un
dispositivo en el registro de AWS IoT (p. 6) y conectar un dispositivo al gateway de dispositivos de AWS
IoT (p. 78).
Requisitos previos
• Los firewalls detrás del dispositivo remoto deben permitir el tráfico saliente en el puerto 443.
• Ha creado una objeto de IoT denominado RemoteDeviceA en el registro de AWS IoT.
• Tiene un agente de dispositivo de IoT ejecutándose en el dispositivo remoto que se conecta al gateway
de dispositivos de AWS IoT y está configurado con una suscripción a un tema de MQTT. Este tutorial
incluye un fragmento que muestra cómo implementar un agente. Para obtener más información, consulte
Fragmento de agente de IoT (p. 532).
• Debe tener un daemon SSH ejecutándose en el dispositivo remoto.
• Ha descargado el código fuente del proxy local de GitHub y lo ha compilado para la plataforma de su
elección. Nos referiremos al archivo ejecutable del proxy local compilado como localproxy en este
tutorial.
Abrir un túnel
1. Abra la consola de AWS IoT. En el panel de navegación, elija Manage (Administrar) y, a continuación,
Tunnels (Túneles).
2. Elija Open a tunnel (Abrir un túnel).
3. En la página Open a new tunnel (Abrir un nuevo túnel), incluya una descripción del túnel si lo desea.
4. En Choose a thing to open a tunnel for (Elegir un objeto para el que abrir un túnel), elija
RemoteDeviceA.
5. En Service (Servicio), escriba SSH y después elija Open New (Abrir nuevo). Para obtener más
información, consulte Fragmento de agente de IoT (p. 532).
6. En la página New tunnel opened (Nuevo túnel abierto), descargue los tokens de acceso de origen y
destino y guárdelos en su equipo. Esta es la única vez que puede recuperar los tokens.
7. Seleccione Listo.
Si configura el destino al llamar a OpenTunnel, el servicio Tunelización segura entrega el token de

acceso del cliente de destino al dispositivo remoto a través de MQTT y el tema reservado de MQTT
($aws/things/RemoteDeviceA/tunnels/notify). Para obtener más información, consulte Temas
reservados (p. 267). Al recibir el mensaje de MQTT, el agente IoT del dispositivo remoto inicia el proxy
local en modo de destino. Puede omitir la configuración de destino si desea entregar el token de acceso de
cliente de destino al dispositivo remoto a través de otro método. Para obtener más información, consulte
Configuración de un dispositivo remoto (p. 533).
Iniciar el proxy local

Abra un terminal en su portátil, copie el token de acceso de cliente de origen y úselo para iniciar el proxy
local en modo de origen. En el siguiente comando, el proxy local está configurado para atender nuevas
conexiones en el puerto 5555.
./localproxy -r us-east-1 -s 5555 -t <source-client-access-token>
526
Iniciar una sesión SSH
Note
La región de AWS de este comando debe ser la misma región de AWS en la que se creó el túnel.
-r
Especifica la región de AWS donde se crea el túnel.

-s
Especifica el puerto al que debe conectarse el proxy.

-t
Especifica el texto del token del cliente.
Note
Si recibe el siguiente error, configure la ruta de acceso de entidad de certificación. Para obtener
información, consulte GitHub.
Could not perform SSL handshake with proxy server: certificate verify
failed
Iniciar una sesión SSH

Abra otro terminal y utilice el siguiente comando para iniciar una nueva sesión SSH conectándose al proxy
local en el puerto 5555.
ssh <username>@localhost -p 5555
Es posible que le pidan una contraseña para la sesión SSH. Cuando haya terminado con la sesión SSH,
escriba exit para cerrar la sesión.
Cerrar el túnel
1. Abra la consola de AWS IoT.
2. Elija el túnel y, en Actions (Acciones), elija Close (Cerrar). Al cerrar el túnel, se cierran las dos instancias
del proxy local.
Ciclo de vida del túnel seguro

Los túneles pueden tener uno de los siguientes estados:
• OPEN
• CLOSED
Las conexiones pueden tener uno de los siguientes estados:
• CONNECTED
• DISCONNECTED
Cuando se abre un túnel, este tiene el estado OPEN. El estado de conexión de origen y destino del túnel se
establece en DISCONNECTED. Cuando un dispositivo (de origen o destino) se conecta al túnel, el estado
de conexión correspondiente cambia a CONNECTED, mientras que el estado del túnel permanece en OPEN.
527
Control del acceso a los túneles
Cuando un dispositivo se desconecta del túnel, el estado de conexión correspondiente cambia de nuevo
a DISCONNECTED. Un dispositivo puede conectarse y desconectarse de un túnel varias veces mientras el
túnel tenga el estado OPEN.
El estado de un túnel cambia a CLOSED cuando se llama a CloseTunnel o cuando el túnel

permanece en el estado OPEN más tiempo que el valor de MaxLifetimeTimeout. Puede configurar
MaxLifetimeTimeout al llamar a OpenTunnel. MaxLifetimeTimeout está establecido de forma
predeterminada en 12 horas si no se especifica un valor.
Una vez que se haya eliminado un túnel CLOSED, es posible que esté visible en la consola de AWS
IoT durante al menos tres horas después de eliminarlo. Mientras el túnel está visible, puede llamar a
DescribeTunnel y ListTunnels para ver los metadatos del túnel. Un túnel no se puede volver a abrir
cuando tiene el estado CLOSED. El servicio Tunelización segura rechaza los intentos de conectarse a un
túnel en estado CLOSED.
Control del acceso a los túneles

El servicio Tunelización segura proporciona las siguientes acciones, recursos y claves de contexto de
condición específicas del servicio para su uso en las políticas de permisos de IAM.
Requisitos previos de acceso al túnel

• Obtenga información sobre cómo proteger los recursos de AWS mediante políticas de IAM.
• Aprenda a crear y evaluar condiciones de IAM.
• Obtenga información sobre cómo proteger los recursos de AWS mediante etiquetas de recursos.
iot:OpenTunnel
La acción de política iot:OpenTunnel concede un permiso a la entidad principal para llamar a
OpenTunnel. Debe especificar el ARN del túnel comodín arn:aws:iot:<aws-region>:<aws-
account-id>:tunnel/* en el elemento Resource de la instrucción de política de IAM. Puede
especificar el ARN de un objeto (arn:aws:iot:<aws-region>:<aws-account-id>:thing/
<thing-name>) en el elemento Resource de la instrucción de política de IAM para administrar los
permisos de OpenTunnel para objetos de IoT específicos.
Por ejemplo, la siguiente instrucción de política le permite abrir un túnel con el objeto de IoT llamado
TestDevice.
{
"Effect": "Allow",
"Action": "iot:OpenTunnel",
"Resource": [
"arn:aws:iot:<aws-region>:<aws-account-id>:tunnel/*",
"arn:aws:iot:<aws-region>:<aws-account-id>:thing/TestDevice"
]
}
La acción de política iot:OpenTunnel admite las siguientes claves de condición:
• iot:ThingGroupArn
• iot:TunnelDestinationService
• aws:RequestTag/<clave-etiqueta>
• aws:TagKeys
528
iot:DescribeTunnel
La siguiente instrucción de política le permite abrir un túnel con el objeto si el objeto pertenece a un grupo
de objetos con un nombre que comienza por TestGroup y el servicio de destino configurado en el túnel es
SSH.
{
"Effect": "Allow",
"Resource": [
"arn:aws:iot:<aws-region>:<aws-account-id>:tunnel/*"
],
"Condition": {
"ForAnyValue:StringLike": {
"iot:ThingGroupArn": [
"arn:aws:iot:<aws-region>:<aws-account-id>:thinggroup/TestGroup*"
]
},
"ForAllValues:StringEquals": {
"iot:TunnelDestinationService": [
"SSH"
]
}
}
}
También puede utilizar etiquetas de recursos para controlar los permisos para abrir túneles. Por ejemplo,
la siguiente instrucción de política permite abrir un túnel si la clave de etiqueta Owner está presente con un
valor de Admin y no se especifica ninguna otra etiqueta.
{
"Effect": "Allow",
"Resource": [
],
"Condition": {
"StringEquals": {
"aws:RequestTag/Owner": "Admin"
},
"ForAllValues:StringEquals": {
"aws:TagKeys": "Owner"
}
}
}
iot:DescribeTunnel
La acción de política iot:DescribeTunnel concede un permiso a la entidad principal para llamar
a DescribeTunnel. Puede especificar un ARN de túnel completo (por ejemplo, arn:aws:iot:<aws-
region>: <aws-account-id>:tunnel/<tunnel-id>) o utilizar el ARN del túnel comodín
(arn:aws:iot:<aws-region>:<aws-account-id>:tunnel/*) en el elemento Resource de la
instrucción de política de IAM.
La acción de política iot:DescribeTunnel admite la siguiente clave de condición:
• aws:ResourceTag/<tag-key>
La siguiente instrucción de política le permite llamar a DescribeTunnel si el túnel solicitado está

etiquetado con la clave Owner con un valor de Admin.
529
iot:ListTunnels
"Effect": "Allow",
"Action": "iot:DescribeTunnel",
"Resource": [
],
"Condition": {
"StringEquals": {
"aws:ResourceTag/Owner": "Admin"
}
}
}
iot:ListTunnels
La acción de política iot:ListTunnels concede un permiso a la entidad principal para llamar a
ListTunnels. Debe especificar el ARN del túnel comodín (arn:aws:iot:<aws-region>:<aws-
account-id>:tunnel/*) en el elemento Resource de la instrucción de política de IAM. Para
administrar los permisos ListTunnels en objetos de IoT específicos, también puede especificar el ARN
de un objeto (arn:aws:iot:<aws-region>:<aws-account-id>:thing/<thing-name>) en el
elemento Resource de la instrucción de política de IAM.
La siguiente instrucción de política le permite mostrar los túneles del objeto denominado TestDevice.
{
"Effect": "Allow",
"Action": "iot:ListTunnels",
"Resource": [
"arn:aws:iot:<aws-region>:<aws-account-id>:tunnel/*",
"arn:aws:iot:<aws-region>:<aws-account-id>:thing/TestDevice"
]
}
iot:ListTagsForResource
La acción de política iot:ListTagsForResource concede un permiso a la entidad principal para llamar
a ListTagsForResource. Puede especificar el ARN completo de un túnel (arn:aws:iot:<aws-
region>: <aws-account-id>:tunnel/<tunnel-id>) o utilizar el ARN del túnel comodín
iot:CloseTunnel
La acción de política iot:CloseTunnel concede un permiso a la entidad principal para llamar a
CloseTunnel. Puede especificar el ARN completo de un túnel (arn:aws:iot:<aws-region>: <aws-
account-id>:tunnel/<tunnel-id>) o utilizar el ARN del túnel comodín (arn:aws:iot:<aws-
region>:<aws-account-id>:tunnel/*) en el elemento Resource de la instrucción de política de
IAM.
La acción de política iot:CloseTunnel admite las siguientes claves de condición:
• iot:Delete
• aws:ResourceTag/<tag-key>
La siguiente instrucción de política le permite llamar a CloseTunnel si el parámetro Delete de la

solicitud es false y el túnel solicitado está etiquetado con la clave Owner y el valor QATeam.
530
iot:TagResource
"Effect": "Allow",
"Action": "iot:CloseTunnel",
"Resource": [
],
"Condition": {
"Bool": {
"iot:Delete": "false"
},
"StringEquals": {
"aws:ResourceTag/Owner": "QATeam"
}
}
}
iot:TagResource
La acción de política iot:TagResource concede un permiso a la entidad principal para llamar a
TagResource. Puede especificar el ARN completo de un túnel (arn:aws:iot:<aws-region>: <aws-
account-id>:tunnel/<tunnel-id>) o utilizar el ARN del túnel comodín (arn:aws:iot:<aws-
region>:<aws-account-id>:tunnel/*) en el elemento Resource de la instrucción de política de
IAM.
iot:UntagResource
La acción de política iot:UntagResource concede un permiso a la entidad principal para llamar
a UntagResource. Puede especificar el ARN completo de un túnel (arn:aws:iot:<aws-
region>:<aws-account-id>:tunnel/<tunnel-id>) o utilizar el ARN del túnel comodín
Para obtener más información acerca de la seguridad de AWS IoT, consulte Administración de identidad y
acceso en AWS IoT (p. 189).
Proxy local
El proxy local es un proceso que actúa como destinatario o remitente de las conexiones TCP entrantes.
Transmite los datos enviados por la aplicación del dispositivo a través del servicio Tunelización segura
mediante una conexión segura WebSocket. Puede descargar el proxy local de origen en GitHub. El proxy
local puede ejecutarse en dos modos: source o destination. En el modo de origen, el proxy local se
ejecuta en el mismo dispositivo o red que la aplicación cliente que inicia la conexión TCP. En el modo de
destino, el proxy local se ejecuta en el dispositivo remoto, junto con la aplicación de destino. Actualmente,
un único túnel puede admitir solo una conexión TCP a la vez.
El proxy local establece primero una conexión con el servicio Tunelización segura. Cuando inicie el proxy
local, utilice el argumento -r para especificar la región de AWS en la que se abre el túnel. Utilice el
argumento -t para pasar el token de acceso de cliente de origen o de destino devuelto por OpenTunnel.
Dos proxies locales que utilicen el mismo valor de token de acceso de cliente no se pueden conectar al
mismo tiempo.
Después de establecer la conexión WebSocket, el proxy local actúa en modo de origen o en modo de
destino, en función de su configuración.
De forma predeterminada, el proxy local intenta volver a conectarse al servicio Tunelización segura si
se producen errores de E/S o si la conexión WebSocket se cierra inesperadamente. Esto hace que la
conexión TCP se cierre. Si se produce algún error de socket TCP, el proxy local envía un mensaje a través
531
Prácticas de seguridad recomendadas del proxy local
del túnel para notificar al otro extremo que cierre su conexión TCP. De forma predeterminada, el proxy
local siempre usa la comunicación SSL.
Después de utilizar el túnel, puede terminar el proceso del proxy local sin problemas. Le recomendamos
que cierre explícitamente el túnel llamando a CloseTunnel. Es posible que los clientes del túnel activos
no se cierren inmediatamente después de llamar a CloseTunnel.
Prácticas de seguridad recomendadas del proxy local

Al ejecutar el proxy local, siga estas prácticas de seguridad recomendadas:
• Evite el uso del argumento -t del proxy local para pasar un token de acceso. Se recomienda utilizar la
variable de entorno AWSIOT_TUNNEL_ACCESS_TOKEN para establecer el token de acceso del proxy
local.
• Ejecute el ejecutable del proxy local con privilegios mínimos en el sistema operativo o en el entorno.
• Evite ejecutar el proxy local como administrador en Windows.
• Evite ejecutar el proxy local como raíz en Linux y macOS.
• Considere la posibilidad de ejecutar el proxy local en hosts distintos, contenedores, entornos de pruebas,
chroot jail o en un entorno virtualizado.
• Cree el proxy local con indicadores de seguridad relevantes, en función de su cadena de herramientas.
• En dispositivos con varias interfaces de red, utilice el argumento -b para enlazar el socket TCP a la
interfaz de red utilizada para comunicarse con la aplicación de destino.
Fragmento de agente de IoT

El agente IoT se utiliza para recibir el mensaje MQTT que incluye el token de acceso de cliente e iniciar
un proxy local en el dispositivo remoto. Debe instalar y ejecutar el agente IoT en el dispositivo remoto si
desea que el servicio Tunelización segura entregue el token de acceso de cliente. El agente de IoT debe
suscribirse al siguiente tema reservado de MQTT de IoT:
$aws/things/<thing-name>/tunnels/notify
donde thing-name es el nombre del objeto de IoT asociado con el dispositivo remoto.
A continuación, se muestra un ejemplo de una carga útil de mensaje MQTT:
{
"clientAccessToken": "<destination-client-access-token>",
"clientMode": "destination",
"region": "<aws-region",
"services": ["destination-service"]
}
Después de recibir un mensaje MQTT, el agente IoT debe iniciar un proxy local en el dispositivo remoto
con los parámetros apropiados.
El siguiente código Java muestra cómo utilizar el SDK de dispositivo de AWS IoT y ProcessBuilder de la
biblioteca Java para crear un agente de IoT sencillo que funcione con el servicio Tunelización segura.
// Find the IoT device endpoint for your AWS account

final String endpoint = iotClient.describeEndpoint(new
DescribeEndpointRequest().withEndpointType("iot:Data-ATS")).getEndpointAddress();
// Instantiate the IoT Agent with your AWS credentials

final String thingName = "RemoteDeviceA";
final String tunnelNotificationTopic = String.format("$aws/things/%s/tunnels/notify",
thingName);
532
Configuración de un dispositivo remoto
final AWSIotMqttClient mqttClient = new AWSIotMqttClient(endpoint, thingName,

"your_aws_access_key", "your_aws_secret_key");
try {
mqttClient.connect();
final TunnelNotificationListener listener = new
TunnelNotificationListener(tunnelNotificationTopic);
mqttClient.subscribe(listener, true);
}
finally {
mqttClient.disconnect();
}
private static class TunnelNotificationListener extends AWSIotTopic {

public TunnelNotificationListener(String topic) {
super(topic);
}
@Override
public void onMessage(AWSIotMessage message) {
try {
// Deserialize the MQTT message
final JSONObject json = new JSONObject(message.getStringPayload());
final String accessToken = json.getString("clientAccessToken");

final String region = json.getString("region");
final String clientMode = json.getString("clientMode");

if (!clientMode.equals("destination")) {
throw new RuntimeException("Client mode " + clientMode + " in the MQTT
message is not expected");
}
final JSONArray servicesArray = json.getJSONArray("services");

if (servicesArray.length() > 1) {
throw new RuntimeException("Services in the MQTT message has more than 1
service");
}
final String service = servicesArray.get(0).toString();
if (!service.equals("SSH")) {
throw new RuntimeException("Service " + service + " is not supported");
}
// Start the destination local proxy in a separate process to connect to the

SSH Daemon listening port 22
final ProcessBuilder pb = new ProcessBuilder("localproxy",
"-t", accessToken,
"-r", region,
"-d", "localhost:22");
pb.start();
}
catch (Exception e) {
log.error("Failed to start the local proxy", e);
}
}
}

Si desea entregar el token de acceso de cliente de destino al dispositivo remoto a través de otros métodos,
en lugar de suscribirse al tema reservado de MQTT de IoT, puede que necesite dos componentes en el
dispositivo remoto:
533
• Un agente de escucha de token de acceso de cliente de destino.

• Un proxy local.
El agente de escucha de token de acceso de cliente de destino debe funcionar con el mecanismo de
entrega de token de acceso de cliente de su elección. Debe poder iniciar un proxy local en modo de
destino.
534
Aprovisionamiento de dispositivos que no tienen certificados
de dispositivo mediante el aprovisionamiento de flotas
Aprovisionamiento de dispositivos
Cuando aprovisione un dispositivo con AWS IoT, debe crear recursos para que AWS IoT y los dispositivos
puedan comunicarse de forma segura. Se pueden crear otros recursos que le ayuden a administrar su flota
de dispositivos. Durante el proceso de aprovisionamiento se pueden crear los siguientes recursos:
• Un objeto de IoT.
Los objetos de IoT son entradas del registro de dispositivos de AWS IoT. Cada objeto tiene un nombre
único y un conjunto de atributos, y está asociado con un dispositivo físico. Los objetos se pueden definir
usando un tipo de objeto o agruparse en grupos de objetos. Para obtener más información, consulte
Administración de dispositivos con AWS IoT (p. 95).
Aunque no es necesario, la creación de objetos permite administrar la flota de dispositivos con mayor
eficacia, ya que los dispositivos pueden buscarse por tipo de objeto, grupo de objetos y atributos de
objeto. Para obtener más información, consulte Servicio de indexación de flota (p. 559).
• Un certificado X.509
Los dispositivos utilizan certificados X.509 para realizar la autenticación mutua con AWS IoT. Puede
registrar un certificado existente o hacer que AWS IoT genere y registre un nuevo certificado por usted.
Un certificado se asocia a un dispositivo asociándolo al objeto que representa el dispositivo. También
debe copiar el certificado y la clave privada asociada en el dispositivo. Los dispositivos presentan el
certificado al conectarse a AWS IoT. Para obtener más información, consulte Autenticación (p. 123).
• Una política de IoT
Las políticas de IoT definen qué operaciones puede realizar un dispositivo en AWS IoT. Las políticas
de IoT se asocian a certificados de dispositivo. Cuando un dispositivo presenta el certificado a AWS
IoT, se conceden los permisos especificados en la política. Para obtener más información, consulte
Autorización (p. 151). Cada dispositivo necesita un certificado para comunicarse con AWS IoT.
AWS IoT permite el aprovisionamiento automatizado de flotas mediante plantillas de aprovisionamiento.

Las plantillas de aprovisionamiento describen los recursos que AWS IoT necesita para aprovisionar el
dispositivo. Las plantillas contienen variables que permiten utilizar una plantilla para aprovisionar varios
dispositivos. Cuando aprovisione un dispositivo, especifique valores para las variables específicas de
este utilizando un diccionario o mapa. Para aprovisionar otro dispositivo, especifique nuevos valores en el
diccionario.
Puede utilizar el aprovisionamiento automatizado tanto si sus dispositivos tienen certificados únicos (y su
clave privada asociada) como si no.
Aprovisionamiento de dispositivos que no

tienen certificados de dispositivo mediante el
aprovisionamiento de flotas
Cuando utiliza el aprovisionamiento de flotas de AWS IoT, AWS IoT puede generar y distribuir de forma
segura certificados de dispositivo y claves privadas a sus dispositivos cuando estos se conectan a AWS
IoT por primera vez.
Existen dos formas de utilizar el aprovisionamiento de flotas:
• Por reclamación
535
Aprovisionar un dispositivo mediante reclamación
• Por usuario de confianza
Aprovisionar un dispositivo mediante reclamación

Los dispositivos se pueden fabricar con un certificado de notificación de aprovisionamiento y una clave
privada (que son credenciales de uso especial) incrustados. Si estos certificados están registrados con
AWS IoT, el servicio puede intercambiarlos por certificados de dispositivo únicos que el dispositivo puede
usar para realizar las operaciones normales. El proceso consta de los pasos siguientes:
Antes de entregar el dispositivo
1. Utilice la API CreateProvisioningTemplate para crear una plantilla de aprovisionamiento. Esta

API devuelve un ARN de plantilla. Para obtener más información, consulte API de aprovisionamiento
de flotas (p. 554).
También puede crear una plantilla de aprovisionamiento de flotas desde la consola de AWS IoT.
a. En el panel de navegación, elija Incorporar y, a continuación, Plantilla de aprovisionamiento de

flotas.
b. Elija Create (Crear) y siga las indicaciones.
2. Cree los certificados y las claves privadas asociadas que se utilizarán como certificados de
reclamación de aprovisionamiento.
3. Registre estos certificados en AWS IoT y asocie una política de IoT que restrinja el uso de los
certificados. El siguiente ejemplo de política de IoT restringe el uso del certificado asociado a esta
política para aprovisionar dispositivos.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": ["iot:Publish","iot:Receive"],
"Resource": [
"arn:aws:iot:aws-region:aws-account-id:topic/$aws/certificates/create/
*",
"arn:aws:iot:aws-region:aws-account-id:topic/$aws/provisioning-
templates/templateName/provision/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:aws-region:aws-account-id:topicfilter/$aws/certificates/
create/*",
"arn:aws:iot:aws-region:aws-account-id:topicfilter/$aws/provisioning-
templates/templateName/provision/*"
]
}
]
}
4. Cuando aprovisiona dispositivos, puede conceder al servicio de AWS IoT permiso para crear o
actualizar recursos de IoT, como objetos y certificados de la cuenta. Para ello, asocie la política
536
Aprovisionamiento por usuario de confianza
administrada AWSIoTThingsRegistration a un rol de IAM (denominado rol de aprovisionamiento)

que confíe en la entidad principal del servicio de AWS IoT.
5. Fabricar el dispositivo con el certificado de reclamación de aprovisionamiento incrustado de forma
segura en él.
El dispositivo ya está listo para ser entregado a donde se instalará para su uso.
Important
Las claves privadas de la notificación de aprovisionamiento deben estar protegidas en todo
momento, también en el dispositivo. Le recomendamos que utilice las métricas y los registros de
CloudWatch de AWS IoT para comprobar si hay indicios de un uso incorrecto. Si detecta un uso
incorrecto, deshabilite el certificado de notificación de aprovisionamiento para que no se pueda
utilizar para el aprovisionamiento de dispositivos.
Para inicializar el dispositivo para su uso
1. El dispositivo utiliza el SDK de AWS IoT para dispositivos y móviles (p. 762) para conectarse y
autenticarse con AWS IoT utilizando el certificado de reclamación de aprovisionamiento que está
instalado en el dispositivo.
2. El dispositivo obtiene un certificado permanente y una clave privada mediante una de estas opciones.
El dispositivo utilizará el certificado y la clave para toda la autenticación futura con AWS IoT.
a. Llame a CreateKeysAndCertificate para crear un nuevo certificado y una clave privada

mediante la entidad de certificación de AWS.
O bien
b. Llame a CreateCertificateFromCsr para generar un certificado desde una solicitud de firma
de certificado que mantiene su clave privada segura.
3. Desde el dispositivo, llame a RegisterThing para registrar el dispositivo con AWS IoT y crear
recursos en la nube.
El servicio de aprovisionamiento de flotas crea recursos en la nube como objetos de IoT, grupos de
objetos y atributos, tal como se definen en la plantilla de aprovisionamiento.
4. Después de guardar el certificado permanente en el dispositivo, este debe desconectarse de la
sesión que inició con el certificado de reclamación de aprovisionamiento y volver a conectarse con el
certificado permanente.
El dispositivo ya está listo para comunicarse normalmente con AWS IoT.

En muchos casos, un dispositivo se conecta a AWS IoT por primera vez cuando un usuario de confianza,
como un usuario final o un técnico de la instalación, utiliza una aplicación móvil para configurar el
dispositivo en su ubicación implementada.
Important
Debe administrar el acceso y el permiso del usuario de confianza para realizar este
procedimiento. Una forma de hacerlo es proporcionar y mantener una cuenta para el usuario
de confianza que lo autentica y le otorga acceso a las características y las API de AWS IoT
necesarias para realizar este procedimiento.
Antes de entregar el dispositivo
1. Llame a CreateProvisioningTemplate para crear una plantilla de aprovisionamiento y devolver

su templateArn y templateName.
537
2. Cree un rol de IAM que utilice un usuario de confianza para iniciar el proceso de aprovisionamiento. La
plantilla de aprovisionamiento solo permite a ese usuario aprovisionar un dispositivo. Por ejemplo:
{
"Effect": "Allow",
"Action": [
"iot:CreateProvisioningClaim",
],
"Resource": [
"arn:aws:aws-region:aws-account-id:provisioningtemplate/templateName"
]
}
3. Cuando aprovisiona dispositivos, puede conceder al servicio de AWS IoT permiso para crear o
actualizar recursos de IoT, como objetos y certificados de la cuenta. Para ello, asocie la política
administrada AWSIoTThingsRegistration a un rol de IAM (denominado rol de aprovisionamiento)
que confíe en la entidad de seguridad del servicio AWS IoT.
4. Proporcione los medios para identificar a sus usuarios de confianza, por ejemplo proporcionándoles
una cuenta que pueda autenticarlos y autorizar sus interacciones con las API de AWS necesarias para
registrar sus dispositivos
Para inicializar el dispositivo para su uso
1. El usuario de confianza inicia sesión en su aplicación móvil o servicio web de aprovisionamiento.

2. La aplicación móvil o la aplicación web utiliza el rol de IAM y llama a CreateProvisioningClaim
para obtener un certificado de reclamación de aprovisionamiento temporal de AWS IoT.
Note
Por motivos de seguridad, el certificado de reclamación de aprovisionamiento temporal

devuelto por CreateProvisioningClaim solo es válido durante cinco minutos. Los pasos
siguientes deben devolver correctamente un certificado válido antes de que caduque el
certificado de reclamación de aprovisionamiento temporal. Los certificados de reclamación de
aprovisionamiento temporal no aparecen en la lista de certificados de su cuenta.
3. La aplicación móvil o la aplicación web proporciona el certificado de reclamación de aprovisionamiento
temporal al dispositivo junto con cualquier información de configuración necesaria, como credenciales
Wi-Fi.
4. El dispositivo utiliza el certificado de reclamación de aprovisionamiento temporal para conectarse a
AWS IoT mediante el SDK de AWS IoT para dispositivos y móviles (p. 762).
Note
El dispositivo debe realizar los siguientes pasos para que llame a RegisterThing en un
plazo de cinco minutos a partir de la conexión a AWS IoT con el certificado de reclamación de
aprovisionamiento temporal.
5. El dispositivo obtiene un certificado permanente y una clave privada mediante una de estas opciones.
El dispositivo utilizará el certificado y la clave para toda la autenticación futura con AWS IoT.
a. Llame a CreateKeysAndCertificate para crear un nuevo certificado y una clave privada

mediante la entidad de certificación de AWS.
O bien
b. Llame a CreateCertificateFromCsr para generar un certificado desde una solicitud de firma
de certificado que mantiene su clave privada segura.
6. El dispositivo llama a RegisterThing para registrar el dispositivo con AWS IoT y crear recursos en
la nube. Recuerde que esto debe ocurrir dentro de los cinco minutos siguientes a la conexión a AWS
IoT con el certificado de reclamación de aprovisionamiento temporal.
538
Enlaces de preaprovisionamiento
El servicio de aprovisionamiento de flotas crea recursos en la nube como objetos de IoT, grupos de
objetos y atributos, tal como se definen en la plantilla de aprovisionamiento.
7. Después de guardar el certificado permanente en el dispositivo, el dispositivo debe desconectarse
de la sesión que inició con el certificado de reclamación de aprovisionamiento temporal y volver a
conectarse con el certificado permanente.
El dispositivo ya está listo para comunicarse normalmente con AWS IoT.
Al utilizar el aprovisionamiento de flotas de AWS IoT, puede configurar una función de Lambda para validar
los parámetros del dispositivo antes de permitir que se aprovisione el dispositivo. Esta función de Lambda
debe existir en su cuenta antes de aprovisionar un dispositivo porque se llama cada vez que un dispositivo
envía una solicitud a través de RegisterThing. Su función de Lambda debe poder recibir una entrada y
devolver una salida; de lo contrario, su dispositivo no se aprovisionará. El aprovisionamiento continúa solo
si la función de Lambda devuelve el parámetro "allowProvisioning": "SUCCEED".
Important
AWS recomienda utilizar enlaces de preaprovisionamiento al crear plantillas de aprovisionamiento

para permitir un mayor control de qué dispositivos y cuántos dispositivos tiene incorporados su
cuenta.
A continuación, se muestra un ejemplo de carga útil que AWS IoT envía a la función de Lambda.
{
"claimCertificateId" : "string",
"claimId" : "string",
"certificatePem" : "string",
"templateArn" : "arn:aws:iot:us-east-1:1234567890:provisioningtemplate/MyTemplate",
"mqttClientId" : "221a6d10-9c7f-42f1-9153-e52e6fc869c1",
// parameters sent from the device
"incomingParameters" : {
"customKey" : "customValue",
// more parameters incoming from device ....
}
}
"incomingParameters" tienen el contenido presente en «parámetros» de la carga útil de solicitud

RegisterThing.
La función de Lambda debe devolver una respuesta que indique si ha autorizado o no la solicitud de
aprovisionamiento. A continuación se muestra un ejemplo de una respuesta correcta.
{
// determines provisioning IoT resources should continue
"allowProvisioning": "SUCCEED",
// optional template parameters to be added when evaluating the template
"parameterOverrides" : {
"customKeysAndValues": "sentToDevice",
// more parameters that will be returned to device ....
}
}
"parameterOverrides" se agregará al parámetro "deviceConfiguration" en la carga útil de

respuesta de RegisterThing .
539
Note
• Si la función de Lambda falla o no devuelve el parámetro "allowProvisioning" en la

respuesta, la solicitud de aprovisionamiento fallará y se devolverá un error en la respuesta.
• La función de Lambda debe terminar de ejecutarse y volver en 5 segundos; de lo contrario, la
solicitud de aprovisionamiento falla.
Cómo utilizar los enlaces de preaprovisionamiento en la CLI de

AWS
El siguiente procedimiento crea una plantilla de aprovisionamiento con enlaces de preaprovisionamiento.
La función de Lambda utilizada aquí es un ejemplo que se puede modificar.
Para crear y aplicar un enlace de preaprovisionamiento a una plantilla de aprovisionamiento
1. Cree una función de Lambda que tenga una entrada y salida definidas. Las funciones de Lambda
son altamente personalizables allowProvisioning y parameterOverrides son necesarias
para crear enlaces de preaprovisionamiento. Para obtener más información acerca de la creación de
funciones de Lambda, consulte Uso de AWS Lambda con la interfaz de línea de comandos de AWS.
El siguiente es un ejemplo de una salida de función de Lambda:
{
"allowProvisioning": "True",
"parameterOverrides": {
"incomingKey0": "incomingValue0",
"incomingKey1": "incomingValue1"
}
}
2. AWS IoT utiliza políticas basadas en recursos para llamar a Lambda, por lo que tendrá que conceder
permiso a AWS IoT para llamar a su función de Lambda.
El siguiente ejemplo utiliza add-permission para dar permiso de IoT a su Lambda.
aws lambda add-permission /

--function-name myLambdaFunction /
--statement-id iot-permission /
--action lambda:InvokeFunction /
--principal iot.amazonaws.com
3. Agregue un enlace de preaprovisionamiento a una plantilla mediante el comando create-provisioning-

template o update-provisioning-template .
En el siguiente ejemplo de CLI se utiliza la create-provisioning-template para crear una plantilla de

aprovisionamiento que tenga enlaces de preaprovisionamiento:
aws iot create-provisioning template /

--template-name myTemplate /
--provisioning-role-arn arn:aws:iam:us-east-1:1234564789012:role/myRole /
--template-body file://template.json /
--pre-provisioning-hook file://hooks.json
540
"templateArn": "arn:aws:iot:us-east-1:1234564789012:provisioningtemplate/
myTemplate",
"defaultVersionId": 1,
"templateName": myTemplate
}
También puede cargar un parámetro desde un archivo en lugar de escribirlo todo como un valor
de parámetro de línea de comandos para ahorrar tiempo. Para obtener más información, consulte
Carga de parámetros de la CLI de AWS desde un archivo. A continuación se muestra el parámetro
template en formato JSON expandido:
{
"Parameters" : {
"DeviceLocation": {
"Type": "String"
}
},
"Mappings": {
"LocationTable": {
"Seattle": {
"LocationUrl": "https://example.aws"
}
}
},
"Resources" : {
"thing" : {
"Type" : "AWS::IoT::Thing",
"Properties" : {
"AttributePayload" : {
"version" : "v1",
"serialNumber" : "serialNumber"
},
"ThingName" : {"Fn::Join":["",["ThingPrefix_",
{"Ref":"SerialNumber"}]]},
"ThingTypeName" : {"Fn::Join":["",["ThingTypePrefix_",
"ThingGroups" : ["widgets", "WA"],
"BillingGroup": "BillingGroup"
},
"OverrideSettings" : {
"AttributePayload" : "MERGE",
"ThingTypeName" : "REPLACE",
"ThingGroups" : "DO_NOTHING"
}
},
"certificate" : {
"Type" : "AWS::IoT::Certificate",
"Properties" : {
"CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
"Status" : "Active"
}
},
"policy" : {
"Type" : "AWS::IoT::Policy",
"Properties" : {
"PolicyDocument" : {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Resource": ["arn:aws:iot:us-east-1:504350838278:topic/foo/
bar"]
}]
}
541
Aprovisionamiento de dispositivos
que tienen certificados de dispositivo
}
}
},
"DeviceConfiguration": {
"FallbackUrl": "https://www.example.com/test-site",
"LocationUrl": {
"Fn::FindInMap": ["LocationTable",{"Ref": "DeviceLocation"},
"LocationUrl"]}
}
}
A continuación se muestra el parámetro pre-provisioning-hook en formato JSON expandido:
{
"targetArn" : "arn:aws:lambda:us-
east-1:765219403047:function:pre_provisioning_test",
"payloadVersion" : "2020-04-01"
}
Aprovisionamiento de dispositivos que tienen

certificados de dispositivo
AWS IoT proporciona tres formas de aprovisionar dispositivos cuando ya tienen un certificado de
dispositivo (y una clave privada asociada):
• Aprovisionamiento de un solo objeto con una plantilla de aprovisionamiento. Esta es una buena opción si
solo necesita aprovisionar los dispositivos de uno en uno.
• Aprovisionamiento "just-in-time" (JITP) con una plantilla que aprovisiona un dispositivo cuando se
conecta por primera vez a AWS IoT. Esta es una buena opción si necesita registrar un gran número
de dispositivos, pero no dispone de información sobre ellos que se pueda incluir en una lista de
aprovisionamiento por lotes.
• Registro masivo Esta opción le permite especificar una lista de valores de aprovisionamiento de un solo
objeto que se almacenan en un archivo en un bucket de S3. Este enfoque funciona bien si tiene un gran
número de dispositivos conocidos cuyas características puede incluir en una lista.
Aprovisionamiento de un solo objeto

Para aprovisionar un objeto, use la API de RegisterThing o el comando de la CLI register-thing. El
comando de la CLI register-thing adopta los argumentos siguientes:
--template-body
La plantilla de aprovisionamiento.
--parameters
Una lista de pares de nombre-valor para los parámetros utilizados en la plantilla de aprovisionamiento,
en formato JSON (por ejemplo, {"ThingName" : "MyProvisionedThing", "CSR" : "<csr-
text>"}).
Consulte Aprovisionamiento de plantillas (p. 546).
RegisterThing o register-thing devuelve los ARN para los recursos y el texto del certificado que ha
creado:
542
Aprovisionamiento justo a tiempo
{
"certificatePem": "<certificate-text>",
"resourceArns": {
"PolicyLogicalName": "arn:aws:iot:us-
west-2:123456789012:policy/2A6577675B7CD1823E271C7AAD8184F44630FFD7",
"certificate": "arn:aws:iot:us-west-2:123456789012:cert/
cd82bb924d4c6ccbb14986dcb4f40f30d892cc6b3ce7ad5008ed6542eea2b049",
"thing": "arn:aws:iot:us-west-2:123456789012:thing/MyProvisionedThing"
}
}
Si se omite el parámetro en el diccionario, se utilizará el valor predeterminado. Si no se especifica el valor

predeterminado, el parámetro no se reemplazará por un valor.

Puede tener sus dispositivos aprovisionados cuando intentan conectarse a AWS IoT por primera vez. La
configuración justo a tiempo (JITP) está disponible en certificados de CA. Para aprovisionar el dispositivo,
debe habilitar el registro automático y asociar una plantilla de aprovisionamiento al certificado de CA
utilizado para firmar el certificado de dispositivo.
Puede realizar estas configuraciones cuando registre un nuevo certificado de CA con la API
RegisterCACertificate o el comando de la CLI register-ca-certificate:
aws iot register-ca-certificate --ca-certificate file://<your-ca-cert> --verification-cert

file://<your-verification-cert> --set-as-active --allow-auto-registration
--registration-config file://<your-template>
Para obtener más información, consulte Registro de su certificado de CA.
También puede utilizar la API UpdateCACertificate o el comando de la CLI update-ca-certificate

para actualizar la configuración para un certificado de CA:
$ aws iot update-ca-certificate --cert-id <caCertificateId> --new-auto-registration-status

ENABLE --registration-config file://<your-template>
Cuando un dispositivo intenta conectarse a AWS IoT mediante un certificado firmado por un certificado
de CA registrado, AWS IoT carga la plantilla desde el certificado de CA y la utiliza para llamar a
RegisterThing. El flujo de trabajo de JITP registra primero un certificado con un valor de estado de
PENDING_ACTIVATION. Cuando se completa el flujo de aprovisionamiento del dispositivo, el estado del
certificado cambia a ACTIVE.
AWS IoT define los siguientes parámetros que puede declarar y a los que puede hacer referencia en las
plantillas de aprovisionamiento:
• AWS::IoT::Certificate::Country
• AWS::IoT::Certificate::Organization
• AWS::IoT::Certificate::OrganizationalUnit
• AWS::IoT::Certificate::DistinguishedNameQualifier
• AWS::IoT::Certificate::StateName
• AWS::IoT::Certificate::CommonName
• AWS::IoT::Certificate::SerialNumber
• AWS::IoT::Certificate::Id
Los valores de estos parámetros de plantilla de aprovisionamiento se limitan a lo que JITP puede
extraer del campo de asunto del certificado del dispositivo que se va a aprovisionar. El certificado
543
debe contener valores para todos los parámetros en el cuerpo de la plantilla. El parámetro
AWS::IoT::Certificate::Id se refiere a un ID generado internamente, no un ID que se encuentra en
el certificado. Puede obtener el valor de este ID utilizando la función principal() dentro de una regla de
AWS IoT.
El siguiente archivo JSON es un ejemplo de una plantilla de JITP completa. El valor del campo
templateBody debe ser un objeto JSON especificado como una cadena de escape y solo puede utilizar
los valores de la lista anterior. Puede utilizar distintas herramientas para crear la salida JSON necesaria,
como json.dumps (Python) o JSON.stringify (Node). El valor del campo roleARN debe ser el ARN
de un rol que tenga AWSIoTThingsRegistration asociado. Además, la plantilla puede utilizar un
PolicyName existente en lugar del PolicyDocument insertado en el ejemplo. (En el primer ejemplo se
han añadido saltos de línea para facilitar su lectura, pero puede copiar y pegar la plantilla que aparece
justo debajo).
{
"templateBody" : "{
\r\n \"Parameters\" : {\r\n
\"AWS::IoT::Certificate::CommonName\": {\r\n \"Type\":
\"String\"\r\n },\r\n
\"AWS::IoT::Certificate::SerialNumber\": {\r\n \"Type\":
\"String\"\r\n },\r\n
\"AWS::IoT::Certificate::Country\": {\r\n \"Type\": \"String
\"\r\n },\r\n
\"AWS::IoT::Certificate::Id\": {\r\n \"Type\": \"String\"\r
\n }\r\n },\r\n
\"Resources\": {\r\n
\"thing\": {\r\n
\"Type\": \"AWS::IoT::Thing\",\r\n
\"Properties\": {\r\n
\"ThingName\": {\r\n \"Ref\":
\"AWS::IoT::Certificate::CommonName\"\r\n },\r\n
\"AttributePayload\": {\r\n
\"version\": \"v1\",\r\n
\"serialNumber\": {\r\n
\"Ref\": \"AWS::IoT::Certificate::SerialNumber
\"\r\n }\r\n },\r\n
\"ThingTypeName\": \"lightBulb-versionA\",\r\n
\"ThingGroups\": [\r\n
\"v1-lightbulbs\",\r\n {\r\n
\"Ref\": \"AWS::IoT::Certificate::Country\"\r
\n }\r\n ]\r\n },\r\n
\"OverrideSettings\": {\r\n
\"AttributePayload\": \"MERGE\",\r\n
\"ThingTypeName\": \"REPLACE\",\r\n
\"ThingGroups\": \"DO_NOTHING\"\r\n }\r\n },\r\n
\"certificate\": {\r\n
\"Type\": \"AWS::IoT::Certificate\",\r\n
\"CertificateId\": {\r\n \"Ref\":
\"AWS::IoT::Certificate::Id\"\r\n },\r\n
\"Status\": \"ACTIVE\"\r\n },\r\n
\"OverrideSettings\": {\r\n
\"Status\": \"DO_NOTHING\"\r\n }\r\n },\r\n
\"policy\": {\r\n
\"Type\": \"AWS::IoT::Policy\",\r\n
\"PolicyDocument\": \"{
\\\"Version\\\": \\\"2012-10-17\\\",
\\\"Statement\\\": [{
\\\"Effect\\\": \\\"Allow\\\",
\\\"Action\\\":[\\\"iot:Publish\\\"],
544
\\\"Resource\\\": [\\\"arn:aws:iot:us-
east-1:123456789012:topic\/sample\/topic\\\"] }] }\"\r\n }\r\n }\r\n
}\r\n}",
"roleArn" : "arn:aws:iam::123456789012:role/Provisioning-JITP"
}
Esta es una version que puede copiar y pegar:
{
"templateBody" : "{\r\n \"Parameters\" : {\r\n
\"AWS::IoT::Certificate::CommonName\": {\r\n \"Type\": \"String\"\r\n },
\r\n \"AWS::IoT::Certificate::SerialNumber\": {\r\n \"Type\": \"String
\"\r\n },\r\n \"AWS::IoT::Certificate::Country\": {\r\n \"Type\":
\"String\"\r\n },\r\n \"AWS::IoT::Certificate::Id\": {\r\n \"Type
\": \"String\"\r\n }\r\n },\r\n \"Resources\": {\r\n \"thing\": {\r\n
\"Type\": \"AWS::IoT::Thing\",\r\n \"Properties\": {\r\n
\"ThingName\": {\r\n \"Ref\": \"AWS::IoT::Certificate::CommonName
\"\r\n },\r\n \"AttributePayload\": {\r\n
\"version\": \"v1\",\r\n \"serialNumber\": {\r\n
\"Ref\": \"AWS::IoT::Certificate::SerialNumber\"\r\n }\r\n
},\r\n \"ThingTypeName\": \"lightBulb-versionA\",\r\n
\"ThingGroups\": [\r\n \"v1-lightbulbs\",\r\n
{\r\n \"Ref\": \"AWS::IoT::Certificate::Country\"\r\n
}\r\n ]\r\n },\r\n \"OverrideSettings\": {\r
\n \"AttributePayload\": \"MERGE\",\r\n \"ThingTypeName\":
\"REPLACE\",\r\n \"ThingGroups\": \"DO_NOTHING\"\r\n }\r\n
},\r\n \"certificate\": {\r\n \"Type\": \"AWS::IoT::Certificate\",\r\n
\"Properties\": {\r\n \"CertificateId\": {\r\n
\"Ref\": \"AWS::IoT::Certificate::Id\"\r\n },\r\n \"Status
\": \"ACTIVE\"\r\n },\r\n \"OverrideSettings\": {\r\n
\"Status\": \"DO_NOTHING\"\r\n }\r\n },\r\n \"policy\": {\r\n
\"Type\": \"AWS::IoT::Policy\",\r\n \"Properties\": {\r\n
\"PolicyDocument\": \"{ \\\"Version\\\": \\\"2012-10-17\\\", \\\"Statement\\\": [{ \
\\"Effect\\\": \\\"Allow\\\", \\\"Action\\\":[\\\"iot:Publish\\\"], \\\"Resource\\\": [\\
\"arn:aws:iot:us-east-1:123456789012:topic\/foo\/bar\\\"] }] }\"\r\n }\r\n
}\r\n }\r\n}",
"roleArn" : "arn:aws:iam::123456789012:role/JITPRole"
}
Esta plantilla de ejemplo declara valores para los parámetros de aprovisionamiento

AWS::IoT::Certificate::CommonName, AWS::IoT::Certificate::SerialNumber,
AWS::IoT::Certificate::Country y AWS::IoT::Certificate::Id que se extraen del certificado
y se usan en la sección Resources. El flujo de trabajo de JITP utiliza después esta plantilla para llevar a
cabo las siguientes acciones:
• Registrar un certificado y establecer su estado en PENDING_ACTIVE

• Crear un recurso de objeto
• Crear un recurso de política
• Asociar la política al certificado
• Asociar el certificado al objeto
• Actualizar el estado del certificado a ACTIVE
Debería poder ver el registro del certificado como un evento registrado (RegisterCACertificate) en
AWS CloudTrail. También puede usar CloudTrail para solucionar los problemas con su plantilla JITP.
545
Registro masivo
Note
JITP llama a otras API de plano de control de AWS IoT durante el proceso de aprovisionamiento.
Estas llamadas pueden superar las cuotas de limitación de AWS IoT establecidas en su cuenta
y provocar una limitación controlada de las llamadas. Póngase en contacto con el servicio de
atención al cliente de AWS para aumentar las cuotas de limitación controlada, si es necesario.
Registro masivo
Puede usar el comando start-thing-registration-task para registrar varios objetos a la vez. Este
comando toma una plantilla de registro, un nombre de bucket de S3, un nombre de clave y un ARN de rol
que permite el acceso al archivo en el bucket de S3. El archivo en el bucket de S3 contiene los valores
utilizados para reemplazar los parámetros de la plantilla. El archivo debe ser un archivo JSON delimitado
por nueva línea. Cada línea contiene todos los valores de los parámetros para el registro de un único
dispositivo. Por ejemplo:
{"ThingName": "foo", "SerialNumber": "123", "CSR": "csr1"}

{"ThingName": "bar", "SerialNumber": "456", "CSR": "csr2"}
Las siguientes API relacionadas con el registro masivo pueden ser útiles:
• ListThingRegistrationTasks: enumera las tareas de aprovisionamiento de objetos por lotes actuales.

• DescribeThingRegistrationTask: proporciona información acerca de una tarea de aprovisionamiento
masivo de objetos específica.
• StopThingRegistrationTask: detiene una tarea de registro masivo de objetos.
• ListThingRegistrationTaskReports: se utiliza para comprobar los resultados o errores de una tarea de
registro masivo de objetos.
Note
• Solo puede ejecutarse una tarea de operación de registro masivo a la vez (por cuenta).
• Las operaciones de registro masivo llaman a otras API del plano de control de AWS IoT. Estas
llamadas pueden superar las cuotas de limitación controlada de AWS IoT establecidas en la
cuenta y provocar errores de limitación. Póngase en contacto con el servicio de atención al
cliente de AWS para aumentar las cuotas de limitación controlada de AWS IoT, si es necesario.
Aprovisionamiento de plantillas
Una plantilla de aprovisionamiento es un documento JSON que utiliza parámetros para describir los
recursos que el dispositivo debe usar para interactuar con AWS IoT. Una plantilla contiene dos secciones:
Parameters y Resources. Hay dos tipos de plantillas de aprovisionamiento en AWS IoT. Uno se utiliza
para el aprovisionamiento just-in-time (JITP) y el registro masivo, y otro para el aprovisionamiento de flotas.
Sección de parámetros
La sección Parameters declara los parámetros utilizados en la sección Resources. Cada parámetro
declara un nombre, un tipo y un valor predeterminado opcional. El valor predeterminado se usa cuando el
diccionario trasladado con la plantilla no contiene un valor para el parámetro. La sección Parameters de
un documento de plantilla tiene el siguiente aspecto:
{
"Parameters" : {
546
Sección de recursos
"ThingName" : {
"Type" : "String"
},
"SerialNumber" : {
"Type" : "String"
},
"Location" : {
"Type" : "String",
"Default" : "WA"
},
"CSR" : {
"Type" : "String"
}
}
}
Este snippet de plantilla declara cuatro parámetros: ThingName, SerialNumber, Location y CSR.
Todos esos parámetros son de tipo String. El parámetro Location declara un valor predeterminado de
"WA".
La sección Resources de la plantilla declara los recursos necesarios para que su dispositivo se
comunique con AWS IoT: un objeto, un certificado y una o más políticas de IoT. Cada recurso especifica
un nombre lógico, un tipo y un conjunto de propiedades.
Un nombre lógico le permite hacer referencia a un recurso en cualquier lugar de la plantilla.
El tipo especifica la clase de recurso que está declarando. Los tipos válidos son:
• AWS::IoT::Thing
• AWS::IoT::Certificate
• AWS::IoT::Policy
Las propiedades que especifique dependen del tipo de recurso que está declarando.
Recursos de objetos
Los recursos de objetos se declaran mediante las siguientes propiedades:
• ThingName: Cadena.
• AttributePayload: opcional. Una lista de pares de nombre-valor.
• ThingTypeName: opcional. Cadena para un tipo de objeto asociado para el objeto.
• ThingGroups: opcional. Una lista de grupos a los que pertenece el objeto.
Recursos de certificados
Puede especificar certificados de una de las siguientes maneras:
• Una solicitud de firma de certificado (CSR).

• Un ID de certificado de un certificado de dispositivo existente. (Los ID de certificado solo se pueden
utilizar con una plantilla de aprovisionamiento de flotas).
• Un certificado de dispositivo creado con un certificado de CA registrado con AWS IoT. Si tiene más de
un certificado de CA registrado con el mismo campo de asunto, también debe trasladar el certificado de
CA utilizado para firmar el certificado de dispositivo.
547
Note
Cuando declare un certificado en una plantilla, use solo uno de estos métodos. Por ejemplo, si
utiliza un CSR, no puede especificar también un ID de certificado o un certificado de dispositivo.
Para obtener más información, consulte Certificados de cliente X.509 (p. 127).
Para obtener más información, consulte Información general del certificado X.509 (p. 123).
Los recursos de certificados se declaran mediante las siguientes propiedades:
• CertificateSigningRequest: Cadena.
• CertificateID: Cadena.
• CertificatePem: Cadena.
• CACertificatePem: Cadena.
• Status: opcional. Cadena, que puede ser ACTIVE o INACTIVE. El valor predeterminado es ACTIVE.
Ejemplos:
• Certificado especificado con un CSR:
{
"certificate" : {
"Properties" : {
"CertificateSigningRequest": {"Ref" : "CSR"},
"Status" : "ACTIVE"
}
}
}
• Certificado especificado con un ID de certificado existente:
{
"certificate" : {
"Properties" : {
"CertificateId": {"Ref" : "CertificateId"}
}
}
}
• Certificado especificado con un archivo .pem de certificado existente y un archivo .pem de certificado de
CA:
{
"certificate" : {
"Type" : "AWS::IoT::Certificate"
"Properties" : {
"CACertificatePem": {"Ref" : "CACertificatePem"},
"CertificatePem": {"Ref" : "CertificatePem"}
}
}
}
Recursos de políticas
Los recursos de políticas se declaran mediante una de las siguientes propiedades:
548
• PolicyName: opcional. Cadena. Hash es el valor predeterminado del documento de políticas. Si utiliza
una política de AWS IoT existente, escriba el nombre de la política para la propiedad PolicyName. No
incluya la propiedad PolicyDocument.
• PolicyDocument: opcional. Un objeto JSON especificado como una cadena de escape. Si
PolicyDocument no se proporciona, la política debe haberse creado ya.
Note
Si una sección Policy está presente, PolicyName o PolicyDocument, pero no ambas, debe
especificarse.
Configuración de invalidación
Si una plantilla especifica un recurso que ya existe, la sección OverrideSettings le permite especificar
la acción que se debe realizar:
DO_NOTHING
Dejar el recurso como está.

REPLACE
Sustituir el recurso por el recurso especificado en la plantilla.

FAIL
Provocar un error en la solicitud con ResourceConflictsException.

MERGE
Solo es válida para las propiedades ThingGroups y AttributePayload de un objeto (thing).

Combinar los atributos o las pertenencias a grupos existentes del objeto con los especificados en la
plantilla.
Cuando declara un recurso de objeto, puede especificar OverrideSettings para las siguientes
propiedades:
• ATTRIBUTE_PAYLOAD
• THING_TYPE_NAME
• THING_GROUPS
Cuando declara un recurso de certificado, puede especificar OverrideSettings para la propiedad

Status.
OverrideSettings no están disponibles para recursos de políticas.
Ejemplo de recursos
El siguiente fragmento de plantilla declara un objeto, un certificado y una política:
{
"Resources" : {
"thing" : {
"Properties" : {
"AttributePayload" : { "version" : "v1", "serialNumber" : {"Ref" :
"SerialNumber"}},
"ThingTypeName" : "lightBulb-versionA",
"ThingGroups" : ["v1-lightbulbs", {"Ref" : "Location"}]
549
Ejemplo de plantilla para el registro JITP y masivo
},
}
},
"certificate" : {
"Properties" : {
"Status" : "ACTIVE"
}
},
"policy" : {
"Properties" : {
"PolicyDocument" : "{ \"Version\": \"2012-10-17\", \"Statement\":
[{ \"Effect\": \"Allow\", \"Action\":[\"iot:Publish\"], \"Resource\": [\"arn:aws:iot:us-
east-1:123456789012:topic/foo/bar\"] }] }"
}
}
}
}
El objeto se declara con:
• El nombre lógico "thing".

• El tipo AWS::IoT::Thing.
• Un conjunto de propiedades de objeto.
Las propiedades de objeto incluyen el nombre de objeto, un conjunto de atributos, un nombre de tipo de
objeto opcional y una lista opcional de grupos de objetos a los que pertenece el objeto.
Se hace referencia a los parámetros mediante {"Ref":"<parameter-name>"}. Cuando se evalúa la

plantilla, los parámetros se reemplazan por el valor de los parámetros desde el diccionario trasladado con
la plantilla.
El certificado se declara con:
• El nombre lógico "certificate".

• El tipo AWS::IoT::Certificate.
• Un conjunto de propiedades.
Las propiedades incluyen el CSR para el certificado y el establecimiento del estado en ACTIVE. El texto
CSR se transfiere como parámetro en el diccionario transferido con la plantilla.
La política se declara con:
• El nombre lógico "policy".

• El tipo AWS::IoT::Policy.
• O el nombre de una política existente o un documento de políticas.

El siguiente archivo JSON es un ejemplo de una plantilla de aprovisionamiento completa que especifica el
certificado con un CSR:
550
(El valor del campo PolicyDocument debe ser un objeto JSON especificado como una cadena de
escape).
{
"Parameters" : {
"SerialNumber" : {
"Type" : "String"
},
"Location" : {
"Type" : "String",
"Default" : "WA"
},
"CSR" : {
"Type" : "String"
}
},
"Resources" : {
"thing" : {
"Properties" : {
"SerialNumber"}},
}
},
"certificate" : {
"Properties" : {
"Status" : "ACTIVE"
}
},
"policy" : {
"Properties" : {
}
}
}
}
El siguiente archivo JSON es un ejemplo de una plantilla de aprovisionamiento completa que especifica un
certificado existente con un ID de certificado:
{
"Parameters" : {
"SerialNumber" : {
"Type" : "String"
},
"Location" : {
"Type" : "String",
"Default" : "WA"
},
"CertificateId" : {
"Type" : "String"
}
},
"Resources" : {
"thing" : {
"Properties" : {
551
Aprovisionamiento de flotas

"SerialNumber"}},
}
},
"certificate" : {
"Properties" : {
"CertificateId": {"Ref" : "CertificateId"}
}
},
"policy" : {
"Properties" : {
}
}
}
}
Las plantillas de aprovisionamiento de flotas las utiliza AWS IoT para definir la configuración de la nube
y del dispositivo. Estas plantillas utilizan los mismos parámetros y recursos que las plantillas de registro
masivo y JITP. Para obtener más información, consulte Aprovisionamiento de plantillas (p. 546).
Las plantillas de aprovisionamiento de flotas pueden contener una sección Mapping y una sección
DeviceConfiguration. Puede utilizar funciones intrínsecas dentro de una plantilla de aprovisionamiento
de flotas para generar una configuración específica del dispositivo. Las plantillas de aprovisionamiento
de flotas son recursos con nombre y se identifican mediante el ARN (por ejemplo, arn:aws:iot:us-
west-2:1234568788:provisioningtemplate/templateName).
Mapeos
La sección Mappings opcional hace coincidir una clave con el conjunto correspondiente de valores
identificados. Por ejemplo, si desea establecer valores en función de una región de AWS, puede crear una
correspondencia en la que se utilice el nombre de una región de AWS como clave y contenga los valores
que desea especificar para cada región específica. Puede utilizar la función intrínseca Fn::FindInMap
para recuperar valores en una asignación.
No puede incluir parámetros, pseudoparámetros ni funciones de llamadas intrínsecas en la sección

Mappings.

La sección de configuración del dispositivo contiene los datos arbitrarios que desea enviar a sus
dispositivos al realizar el aprovisionamiento. Por ejemplo:
{
"Foo":"Bar"
}
}
552
Funciones intrínsecas
Las funciones intrínsecas se utilizan en cualquier sección de la plantilla de aprovisionamiento, excepto en
la sección Mappings.
Fn:Join
Añade un conjunto de valores a un único valor separado por el delimitador especificado. Si un

delimitador es la cadena vacía, el conjunto de valores se concatena sin delimitador.
Fn:Select
Devuelve un único objeto de una lista de objetos por índice.

Important
Fn::Select no comprueba si hay valores null o si el índice queda fuera de los límites de
la matriz. Ambas condiciones dan lugar a un error de aprovisionamiento, por lo que debe
asegurarse de elegir un valor de índice válido y de que la lista contiene valores distintos de
null.
Fn:FindInMap
Devuelve el valor correspondiente a claves en una asignación de dos niveles declarada en la sección
Mappings.
Fn:Split
Divide una cadena en una lista de valores de cadena para que pueda seleccionar un elemento de la
lista de cadenas. Especifique un delimitador que determine dónde se divide la cadena (por ejemplo,
una coma). Después de dividir una cadena, utilice Fn::Select para seleccionar un elemento.
Por ejemplo, si una cadena delimitada por comas de IDs de subred se importa a la plantilla de
pila, puede dividir la cadena en cada coma. En la lista de ID de subred, utilice Fn::Select para
especificar el ID de subred de un recurso.
Fn:Sub
Sustituye variables en una cadena de entrada por los valores que especifique. Puede utilizar esta
función para crear comandos o salidas que incluyan valores que no están disponibles hasta que crea o
actualiza una pila.
Ejemplo de plantilla de aprovisionamiento de flotas

{
"Parameters" : {
"SerialNumber": {
"Type": "String"
},
"DeviceLocation": {
"Type": "String"
}
},
"Mappings": {
"LocationTable": {
"Seattle": {
"LocationUrl": "https://example.aws"
}
}
},
"Resources" : {
"thing" : {
553
API de aprovisionamiento de flotas
"Properties" : {
"AttributePayload" : {
"version" : "v1",
"serialNumber" : "serialNumber"
},
"ThingTypeName" : {"Fn::Join":["",["ThingPrefix_",
"ThingGroups" : ["v1-lightbulbs", "WA"],
"BillingGroup": "LightBulbBillingGroup"
},
}
},
"certificate" : {
"Properties" : {
"CertificateId": {"Ref": "AWS::IoT::Certificate::Id"},
"Status" : "Active"
}
},
"policy" : {
"Properties" : {
"PolicyDocument" : {
"Version": "2012-10-17",
"Statement": [{
"Effect": "Allow",
"Resource": ["arn:aws:iot:us-east-1:123456789012:topic/foo/bar"]
}]
}
}
}
},
"FallbackUrl": "https://www.example.com/test-site",
"LocationUrl": {
"Fn::FindInMap": ["LocationTable",{"Ref": "DeviceLocation"}, "LocationUrl"]}
}
}
}
Note
Se puede actualizar una plantilla de aprovisionamiento existente para agregar un enlace de

preaprovisionamiento (p. 539).
API de aprovisionamiento de flotas

Existen tres tipos de API utilizadas en el aprovisionamiento de flotas:
• API del plano de control, que se utiliza para crear y administrar plantillas de aprovisionamiento de flotas y
para configurar políticas de usuario de confianza.
• CreateProvisioningTemplate
• CreateProvisioningTemplateVersion
• DeleteProvisioningTemplate
• DeleteProvisioningTemplateVersion
554
API de MQTT de aprovisionamiento de dispositivos
• DescribeProvisioningTemplate
• DescribeProvisioningTemplateVersion
• ListProvisioningTemplates
• ListProvisioningTemplateVersions
• UpdateProvisioningTemplate
• API de plano de control utilizada por un usuario de confianza para generar una reclamación de
incorporación temporal. Esta reclamación se pasa al dispositivo durante la configuración de Wi-Fi o un
método similar. Hay una API en esta categoría: CreateProvisioningClaim.
• API utilizada por los dispositivos durante el proceso de aprovisionamiento. Esto significa usar un
certificado de reclamación de aprovisionamiento incrustado en un dispositivo o una transferido al mismo
por un usuario de confianza.

El servicio de aprovisionamiento de flotas admite tres API de MQTT: CreateKeysAndCertificate,
CreateCertificateFromCSR y RegisterThing.
Para crear un certificado a partir de una solicitud de firma de certificado (CSR), publique un mensaje en
$aws/certificates/create-from-csr/cbor o $aws/certificates/create-from-csr/json.
Carga de solicitud:
{
"certificateSigningRequest": "string"
}
certificateSigningRequest
La CSR, en formato PEM.
Para recibir respuestas de error, suscríbase a $aws/certificates/create-from-csr/cbor/

rejected o $aws/certificates/create-from-csr/json/rejected.
Carga útil del error:
{
"statusCode": int,
"errorCode": "string",
"errorMessage": "string"
}
statusCode
El código del estado.

errorCode
El código de error.
errorMessage
Mensaje de error.
Para obtener más información, consulte CreateCertificateFromCsr en Referencia de la API de AWS IoT.
555
En los ejemplos de este documento, se utiliza JSON para facilitar la lectura, pero también se puede utilizar
el formato de representación concisa de objetos binarios (CBOR). El nuevo certificado tendrá el estado
PENDING_ACTIVATION. Cuando se utiliza la API RegisterThing para aprovisionar un objeto, el estado
del certificado cambia a ACTIVE o INACTIVE, en función de la definición de la plantilla.
Para crear un certificado, publique un mensaje en $aws/certificates/create/cbor o $aws/

certificates/create/json.
Carga de solicitud:
{}
Carga de respuesta:
Para recibir la respuesta, suscríbase a $aws/certificates/create/cbor/accepted o $aws/

certificates/create/json/accepted. Para obtener más información acerca de cómo conectarse
al agente de mensajes y el uso de temas reservados de AWS IoT, consulte Eventos del ciclo de
vida (p. 749) y Temas reservados (p. 267).
{
"certificateId": "string",
"certificatePem": "string",
"privateKey": "string",
"certificateOwnershipToken": "string"
}
certificateId
El ID del certificado.
certificatePem
Los datos del certificado, en formato PEM.

privateKey
La clave privada.
certificateOwnershipToken
El token para comprobar la propiedad del certificado durante el aprovisionamiento.
Para recibir respuestas de error, suscríbase a $aws/certificates/create/cbor/rejected o $aws/

certificates/create/json/rejected.
{
"statusCode": int,
}
statusCode

errorCode
556
errorMessage
Mensaje de error.
Para obtener más información, vea CreateKeysAndCertificate en la Referencia de la API de AWS IoT.
RegisterThing
Para aprovisionar un objeto, publique un mensaje en $aws/provisioning-
templates/templateName/provision/cbor o $aws/provisioning-
templates/templateName/provision/json.
Carga de solicitud:
{
"certificateOwnershipToken": "string",
"parameters": {
"string": "string"
},
}
templateName
El nombre de la plantilla de aprovisionamiento.

certificateOwnershipToken
El token para comprobar la propiedad del certificado. El token lo genera AWS IoT cuando se crea un
certificado a través de MQTT.
parameters
Opcional. Pares de nombre-valor que se envían a los dispositivos durante el aprovisionamiento.
Para recibir la respuesta, suscríbase a $aws/provisioning-templates/templateName/

provision/cbor/accepted o $aws/provisioning-templates/templateName/provision/
json/accepted.
Carga de respuesta:
{
"deviceConfiguration": {
"string": "string"
},
"thingName": "string"
}
thingName
El nombre del objeto de IoT creado durante el aprovisionamiento.

deviceConfiguration
La configuración del dispositivo definida en la plantilla.
Para recibir respuestas de error, suscríbase a $aws/provisioning-templates/templateName/

provision/cbor/rejected o $aws/provisioning-templates/templateName/provision/
json/rejected.
557
{
"statusCode": int,
}
statusCode

errorCode
errorMessage
Mensaje de error.
Para obtener más información, consulte RegisterThing en la Referencia de la API de AWS IoT.
558
Administración de la indexación de objetos
Servicio de indexación de flota

La indexación de flotas es un servicio administrado que puede usar para indexar y hacer búsquedas y
agrupar datos de registro, datos de sombras y datos de conectividad de los dispositivos (eventos de ciclo
de vida de los dispositivos) en la nube. Después de configurar el índice de flota, el servicio administrará
la indexación de las actualizaciones de sus grupos de objetos, registros de objetos y sombras de objetos.
Para obtener más información acerca de las consultas de agregación, consulte Consulta de datos
agregados (p. 571). Puede utilizar un lenguaje de consulta simple para buscar estos datos. También
puede crear un grupo de objetos dinámico (p. 111) con una consulta de búsqueda.
Note
El servicio de indexación de flotas puede tardar aproximadamente 30 segundos en actualizar el

índice de flota después de crear, actualizar o eliminar un objeto.
Al habilitar la indexación, AWS IoT crea un índice para sus objetos o grupos de objetos. Después de
activarla, puede realizar consultas en el índice, como buscar todos los dispositivos portátiles que tengan
una duración de la batería de más del 70 %. AWS IoT mantiene el índice permanentemente actualizado
con los datos más recientes.
AWS_Things es el índice creado para todos sus objetos. AWS_ThingGroups es el índice que contiene
todos sus grupos de objetos.
Puede utilizar la consola de AWS IoT para administrar su configuración de indexación y ejecutar las
consultas de búsqueda. Elija los índices que quiera utilizar en la página de configuración de la consola.
Si prefiere el acceso mediante programación, puede utilizar los SDK de AWS o la AWS Command Line
Interface (AWS CLI).
Para obtener información sobre los precios de este y otros servicios, consulte la página Precios de
administración de dispositivos de AWS IoT.
Temas
• Administración de la indexación de objetos (p. 559)
• Administración de la indexación de grupos de objetos (p. 569)
• Consulta de datos agregados (p. 571)
• Sintaxis de la consulta (p. 575)
• Ejemplo de consultas de objetos (p. 576)
• Ejemplo de consultas de grupo de objetos (p. 578)
Administración de la indexación de objetos

AWS_Things es el índice creado para todos los objetos. Puede controlar qué indexar, datos de registro,
datos de sombra y datos de estado de conectividad de los dispositivos (controlados por eventos de ciclo de
vida de los dispositivos).
Habilitación de la indexación de objetos

Utilice el comando update-indexing-configuration de la CLI o la API UpdateIndexingConfiguration
para crear el índice AWS_Things y controlar su configuración. El parámetro --thing-indexing-
559
configuration (thingIndexingConfiguration) le permite controlar qué tipo de datos (por ejemplo,

datos de registro, sombra y conectividad del dispositivo) están indexados.
El parámetro --thing-indexing-configuration toma una cadena con la siguiente estructura:
{
"thingIndexingMode": "OFF"|"REGISTRY"|"REGISTRY_AND_SHADOW",
"thingConnectivityIndexingMode": "OFF"|"STATUS",
"customFields": [
{ name: <field-name>, type: String | Number | Boolean },
...
]
}
El atributo thingIndexingMode controla qué tipo de datos se indexan. Los valores válidos son:
DESACTIVAR
Sin indexación.
REGISTRY
Indexar los datos de registro.

REGISTRY_AND_SHADOW
Indexar los datos de registro y de sombras de objetos.
El atributo thingConnectivityIndexingMode especifica si los datos de conectividad de objetos están

indexados. Los valores válidos son:
DESACTIVAR
Los datos de conectividad de objetos no están indexados.

STATUS
Los datos de conectividad de objetos están indexados.
El atributo customFields es una lista de pares de campos y tipos de datos. Las consultas de
agregación se pueden realizar en estos campos en función del tipo de datos. El modo de indexación
que elija (REGISTRY o REGISTRY_AND_SHADOW) afecta a los campos que se pueden especificar en
customFields. Por ejemplo, si especifica el modo de indexación REGISTRY, no puede especificar un
campo de una sombra de objeto. Los campos personalizados deben especificarse en customFields para
que se puedan indexar.
Si el tipo del campo personalizado de la configuración y el valor que se va indexar no coinciden, el

servicio de indexación de flotas omite el valor no coincidente para las consultas de agregación. Los
registros de CloudWatch sirven para solucionar problemas de consultas de agregación. Para obtener más
información, consulte Solución de problemas de consultas de agregación en el servicio de indexación de
flotas (p. 769).
Los campos administrados contienen datos asociados con objetos de IoT, grupos de objetos y sombras
de dispositivos. AWS IoT define el tipo de datos de los campos administrados. El usuario especifica
los valores de cada campo administrado cuando se crea un objeto de IoT. Por ejemplo, los nombres
de objetos, los grupos de objetos y las descripciones de objetos son todos campos administrados. El
servicio de indexación de flotas indexa los campos administrados en función del modo de indexación que
especifique:
• Campos administrados del registro
560
"managedFields" : [
{name:thingId, type:String},
{name:thingName, type:String},
{name:registry.version, type:Number},
{name:registry.thingType, type:String},
{name:registry.thingGroupNames, type:String},
]
• Campos administrados de sombras de objetos
"managedFields" : [
{name:shadow.version, type:Number},
{name:shadow.delta, type:Boolean}
]
• Campos administrados de conectividad de objetos
"managedFields" : [
{name:connectivity.timestamp, type:Number},
{name:connectivity.version, type:Number},
{name:connectivity.connected, type:Boolean}
]
• Campos administrados de grupos de objetos
"managedFields" : [
{name:description, type:String},
{name:parentGroupNames, type:String},
{name:thingGroupId, type:String},
{name:thingGroupName, type:String},
{name:version, type:Number},
]
Los campos administrados no se pueden cambiar ni pueden aparecer en customFields.
A continuación, se muestra un ejemplo de cómo utilizar update-indexing-configuration para configurar la

indexación:
aws iot update-indexing-configuration --thing-indexing-configuration

'thingIndexingMode=REGISTRY_AND_SHADOW,customFields=[{name=attributes.version,type=Number},
{name=attributes.color, type=String},{name=shadow.desired.power, type=Boolean}}]
Este comando permite la indexación de datos de registro y de sombras. Las consultas de agregación
funcionan con los campos administrados y los customFields proporcionados en función del tipo de
datos.
Puede utilizar el comando get-indexing-configuration de la CLI o la API GetIndexingConfiguration para

recuperar la configuración de indexación actual.
El siguiente comando muestra cómo utilizar el comando get-indexing-configuration de la CLI para

recuperar la configuración de indexación actual, en la que se definen cinco campos personalizados (tres
campos personalizados del registro y dos campos personalizados de sombras).
aws iot get-indexing-configuration
{
"thingGroupIndexingConfiguration": {
561
"thingGroupIndexingMode": "OFF"
},
"thingIndexingConfiguration": {
"thingConnectivityIndexingMode": "STATUS",
"customFields": [
{
"name": "attributes.customField_NUM",
"type": "Number"
},
{
"name": "shadow.desired.customField_STR",
"type": "String"
},
{
"name": "shadow.desired.customField_NUM",
"type": "Number"
},
{
"name": "attributes.customField_STR",
"type": "String"
},
{
"name": "attributes.customField_BOOL",
"type": "Boolean"
}
],
"thingIndexingMode": "REGISTRY_AND_SHADOW",
"managedFields": [
{
"name": "shadow.hasDelta",
"type": "Boolean"
},
{
"name": "registry.thingGroupNames",
"type": "String"
},
{
"name": "connectivity.version",
"type": "Number"
},
{
"name": "registry.thingTypeName",
"type": "String"
},
{
"name": "connectivity.connected",
"type": "Boolean"
},
{
"name": "registry.version",
"type": "Number"
},
{
"name": "thingId",
"type": "String"
},
{
"name": "connectivity.timestamp",
"type": "Number"
},
{
"name": "thingName",
"type": "String"
},
{
"name": "shadow.version",
562
"type": "Number"
}
]
}
}
En la tabla siguiente se indican las combinaciones permitidas de thingIndexingMode y

thingConnectivityIndexingMode, y los efectos asociados. El parámetro AWS_Things obligatorio
especifica si el índice thingIndexingMode contendrá solo datos del registro o datos del registro y
de las sombras. El parámetro opcional thingConnectivityIndexingMode especifica si el índice
también contendrá datos de estado de la conectividad (es decir, cuándo se han conectado y desconectado
dispositivos de AWS IoT).
thingIndexingMode Resultado
thingConnectivityIndexingMode
OFF No especificado. Ni indexar ni eliminar un índice.
OFF OFF Equivalente a la entrada anterior.
REGISTRY No especificado. Crea o configura el índice

AWS_Things para indexar solo
los datos del registro.
REGISTRY OFF Equivalente a la entrada anterior.

(Solo se indexan los datos del
registro).
REGISTRY_AND_SHADOW No especificado. Crear o configurar el índice

AWS_Things para indexar los
datos de las sombras y del
registro.
REGISTRY_AND_SHADOW OFF Equivalente a la entrada anterior.

(Se indexan los datos del registro
y los datos de las sombras).
REGISTRY STATUS Crear o configurar el índice

AWS_Things para indexar datos
del registro y datos de estado
de la conectividad del objeto
(REGISTRY_AND_CONNECTIVITY_STATUS).
REGISTRY_AND_SHADOW STATUS Crear o configurar el índice

AWS_Things para indexar
datos del registro, datos de
sombras y datos de estado
de la conectividad del objeto
(REGISTRY_AND_SHADOW_AND_CONNECTI
Puede utilizar el comando update-indexing-configuration de la CLI de AWS IoT para actualizar la

configuración de indexación. Los siguientes ejemplos muestran cómo utilizar el comando update-indexing-
configuration de la CLI.
Sintaxis corta:

"thingIndexingMode=REGISTRY_AND_SHADOW,thingConnectivityIndexingMode=STATUS,customFields=[{name=attribu
{name=attributes.color,type=String},{name=shadow.desired.power,type=Boolean}]"
563
Sintaxis de JSON:
aws iot update-indexing-configuration --cli-input-json \ '{ "thingIndexingConfiguration":

{ "thingIndexingMode": "REGISTRY_AND_SHADOW", "thingConnectivityIndexingMode": "STATUS",
"customFields": [ { "name": "shadow.desired.power", "type": "Boolean" }, { "name": "attributes.color", "type":
"String" }, { "name": "attributes.version", "type": "Number" } ] } }'
El resultado de estos comandos es:
{
"thingIndexingConfiguration": {
"thingConnectivityIndexingMode": "STATUS",
"customFields": [
{
"type": "String",
"name": "attributes.color"
},
{
"type": "Number",
"name": "attributes.version"
},
{
"type": "Boolean",
"name": "shadow.desired.power"
}
],
"thingIndexingMode": "REGISTRY_AND_SHADOW",
"managedFields": [
{
"type": "Boolean",
"name": "connectivity.connected"
},
{
"type": "String",
"name": "registry.thingTypeName"
},
{
"type": "String",
"name": "thingName"
},
{
"type": "Number",
"name": "shadow.version"
},
{
"type": "String",
"name": "thingId"
},
{
"type": "Boolean",
"name": "shadow.hasDelta"
},
{
"type": "Number",
"name": "connectivity.timestamp"
},
{
"type": "String",
"name": "registry.thingGroupNames"
},
{
"type": "Number",
"name": "connectivity.version"
},
{
564
Descripción de un índice de objeto
"type": "Number",
"name": "registry.version"
}
]
},
"thingGroupIndexingMode": "OFF"
}
}
En el ejemplo siguiente, se añade un nuevo campo personalizado a la configuración:

'thingIndexingMode=REGISTRY_AND_SHADOW,customFields=[{name=attributes.version,type=Number},
{name=attributes.color,type=String},{name=shadow.desired.power,type=Boolean},
{name=shadow.desired.intensity,type=Number}]'
Este comando se añadió shadow.desired.intensity a la configuración de indexación.

Note
La actualización de los campos personalizados en la configuración de indexación sobrescribe

todos los campos personalizados existentes. Asegúrese de especificar todos los campos
personalizados cuando llame a update-indexing-configuration.
Después de reconstruir el índice, puede utilizar la consulta de agregación en los campos recién añadidos,
los datos de registro de búsqueda, los datos de sombras y los datos de estado de conectividad de objetos.
Al cambiar el modo de indexación, asegúrese de que todos los campos personalizados son válidos en
el nuevo modo de indexación. Por ejemplo, si utiliza el modo REGISTRY_AND_SHADOW con un campo
personalizado llamado shadow.desired.temperature, debe eliminar el campo personalizado
shadow.desired.temperature antes de cambiar el modo de indexación a REGISTRY. Si la
configuración de indexación contiene campos personalizados que no están indexados por el modo de
indexación, se producirá un error en la actualización.
Descripción de un índice de objeto

El comando siguiente muestra cómo utilizar el comando describe-index de la CLI para recuperar el estado
actual del índice del objeto:
aws iot describe-index --index-name "AWS_Things"

{
"indexStatus": "BUILDING",
"schema": "REGISTRY_AND_SHADOW_AND_CONNECTIVITY_STATUS"
}
La primera vez que habilite la indexación, AWS IoT crea el índice. No puede consultar el índice si
indexStatus se encuentra en estado BUILDING. El valor schema del índice de objetos indica qué tipo
de datos (REGISTRY_AND_SHADOW_AND_CONNECTIVITY_STATUS) se indexan.
Si se cambia la configuración del índice, el índice se vuelve a compilar. Durante este proceso,
indexStatus es REBUILDING. Puede ejecutar consultas en los datos del índice de objetos
mientras se está generando. Por ejemplo, si cambia la configuración del índice de REGISTRY a
REGISTRY_AND_SHADOW, cuando el índice se vuelve a generar, puede consultar los datos del registro,
incluidas las últimas actualizaciones. Sin embargo, no puede consultar los datos de sombra hasta que se
complete la recompilación. El tiempo que tarda en compilar o recompilar el índice depende de la cantidad
de datos.
565
Consulta de un índice de objeto
Consulta de un índice de objeto

Puede utilizar el comando search-index de la CLI para consultar los datos del índice.
aws iot search-index --index-name "AWS_Things" --query-string "thingName:mything*"
{
"things":[{
"thingName":"mything1",
"thingGroupNames":[
"mygroup1"
],
"thingId":"a4b9f759-b0f2-4857-8a4b-967745ed9f4e",
"attributes":{
"attribute1":"abc"
},
"connectivity": {
"connected":false,
"timestamp":1556649874716
}
},
{
"thingName":"mything2",
"thingTypeName":"MyThingType",
"thingGroupNames":[
"mygroup1",
"mygroup2"
],
"thingId":"01014ef9-e97e-44c6-985a-d0b06924f2af",
"attributes":{
"model":"1.2",
"country":"usa"
},
"shadow":{
"desired":{
"location":"new york",
"myvalues":[3, 4, 5]
},
"reported":{
"location":"new york",
"myvalues":[1, 2, 3],
"stats":{
"battery":78
}
},
"metadata":{
"desired":{
"location":{
},
"myvalues":{
}
},
"reported":{
"location":{
},
"myvalues":{
},
"stats":{
"battery":{
566
Restricciones y limitaciones
}
}
}
},
"version":10,
},
"connectivity": {
"connected":true,
"timestamp":1556649855046
}
}],
"nextToken":"AQFCuvk7zZ3D9pOYMbFCeHbdZ+h=G"
}
En la respuesta JSON, "connectivity" (que se habilita mediante la opción

thingConnectivityIndexingMode=STATUS) proporciona un valor booleano y una marca temporal que
indica si el dispositivo está conectado a AWS IoT Core. El dispositivo "mything1" desconectado (false)
en tiempo POSIX 1556649874716:
"connectivity": {
"connected":false,
"timestamp":1556649874716
}
El dispositivo "mything2" conectado (true) en tiempo POSIX 1556649855046:
"connectivity": {
"connected":true,
"timestamp":1556649855046
}
Las marcas temporales se indican en milisegundos desde la fecha de inicio, por lo que 1556649855046
representa 6:44:15.046 p. m. el martes 30 de abril de 2019 (GMT).
Important
Si un dispositivo se ha desconectado durante aproximadamente una hora, el valor "timestamp"

del estado de conectividad podría no aparecer.
Estas son las restricciones y limitaciones de AWS_Things.
Campos de sombra con tipos complejos
Un campo de sombra se indexa solo si el valor del campo es un tipo sencillo, un objeto JSON que no
incluya una matriz o una matriz que conste completamente de tipos sencillos. Un tipo sencillo es una
cadena, un número o uno de los literales true o false. Por ejemplo, dado el siguiente estado de
sombra, el valor del campo "palette" no se indexa porque es una matriz que incluye elementos de
tipos complejos. El valor del campo "colors" sí se indexará porque cada valor de la matriz es una
cadena.
{
"state": {
"reported": {
"switched": "ON",
"colors": [ "RED", "GREEN", "BLUE" ],
"palette": [
567
{
"name": "RED",
"intensity": 124
},
{
"name": "GREEN",
"intensity": 68
},
{
"name": "BLUE",
"intensity": 201
}
]
}
}
}
Nombres de campos de sombra anidados
Los nombres de los campos de sombra anidados se almacenan como una cadena delimitada por
punto (.). Por ejemplo, dado un documento de sombra:
{
"state": {
"desired": {
"one": {
"two": {
"three": "v2"
}
}
}
}
}
el nombre del campo three se almacena como desired.one.two.three. Si también tiene un

documento de sombra como este:
{
"state": {
"desired": {
"one.two.three": "v2"
}
}
}
coinciden con una consulta para shadow.desired.one.two.three:v2. La práctica recomendada

es no utilizar puntos en los nombres de campos de sombra.
Metadatos de sombra
Un campo en una sección de metadatos de sombra se indexa, pero solo si se indexa el campo
correspondiente en la sección "state" de la sombra. (En el ejemplo anterior, el campo "palette"
de la sección de metadatos de la sombra tampoco se indexa).
Sombras no registradas
Si utiliza UpdateThingShadow para crear una sombra mediante un nombre de objeto que no se ha
registrado en su cuenta de AWS IoT, los campos de esta sombra no se indexan.
Valores numéricos
Si el servicio reconoce como valor numérico algún dato de sombra o de registro, se indexa como tal.
Puede formar consultas que impliquen rangos y operadores de comparación en valores numéricos
(por ejemplo "attribute.foo<5" o "shadow.reported.foo:[75 TO 80]"). Para que se
568
Autorización
reconozca como numérico, el valor de los datos debe ser un literal de tipo número JSON válido (un
entero en el intervalo -2^53...2^53-1 o un punto flotante de doble precisión con notación exponencial
opcional) o parte de una matriz que solo contenga dichos valores.
Valores nulos
Los valores nulos no se indexan.

Número máximo de campos personalizados para consultas de agregación
5
Número máximo de percentiles solicitados para consultas de agregación.
100
Autorización
Puede especificar el índice de objetos como un ARN del recurso en una acción de política de AWS IoT,
como en el siguiente ejemplo.
Acción Recurso
iot:SearchIndex El ARN de un índice (por ejemplo,

arn:aws:iot:<your-aws-region><your-
aws-account>:index/AWS_Things).
iot:DescribeIndex Un ARN de un índice (por ejemplo,

arn:aws:iot:<your-aws-region>:index/
AWS_Things).
Note
Si tiene los permisos para consultar el índice de la flota, podrá obtener acceso a los datos de los
objetos en toda la flota.
Administración de la indexación de grupos de

objetos
AWS_ThingGroups es el índice que contiene todos sus grupos de objetos. Puede usar este índice para
buscar grupos en función de su nombre, descripción, atributos y todos los nombres de grupos principales.
Habilitación de la indexación de grupos de objetos

Puede utilizar el valor thing-group-indexing-configuration en la API
UpdateIndexingConfiguration para crear el índice AWS_ThingGroups y controlar su configuración. Puede
utilizar la API GetIndexingConfiguration para recuperar la configuración de indexación actual.
Puede utilizar el comando get-indexing-configuration de la CLI para recuperar las configuraciones de

indexación actuales del objeto y grupo de objetos.
aws iot get-indexing-configuration
{
569
Descripción de índices de grupos
"thingGroupIndexingMode": "ON"
}
}
Puede utilizar el comando update-indexing-configuration de la CLI para actualizar las configuraciones de

indexación de grupos de objetos.
aws iot update-indexing-configuration --thing-group-indexing-configuration

thingGroupIndexingMode=ON
Note
También puede actualizar las configuraciones de la indexación de objetos y grupos de objetos en

un único comando, como en el siguiente ejemplo.

thingIndexingMode=REGISTRY --thing-group-indexing-configuration
thingGroupIndexingMode=ON
Los siguientes valores son válidos para thingGroupIndexingMode.
OFF
Sin indexación/eliminación del índice.

ACTIVAR
Cree o configure el índice AWS_ThingGroups.
Descripción de índices de grupos

Puede utilizar el comando describe-index de la CLI para recuperar el estado actual del índice
AWS_ThingGroups.
aws iot describe-index --index-name "AWS_ThingGroups"

{
"indexStatus": "ACTIVE",
"indexName": "AWS_ThingGroups",
"schema": "THING_GROUPS"
}
AWS IoT crea el índice cuando se habilita la indexación por primera vez. No se puede consultar el índice si
indexStatus es BUILDING.
Consulta de un índice de grupo de objetos

Puede utilizar el comando search-index de la CLI para consultar los datos del índice:
aws iot search-index --index-name "AWS_ThingGroups" --query-string

"thingGroupName:mythinggroup*"
Autorización
Puede especificar el índice de grupos de objetos como un ARN del recurso en una acción de política de
AWS IoT, como en el siguiente ejemplo.
570
Consulta de datos agregados
Acción Recurso
iot:SearchIndex El ARN de un índice (por ejemplo,

AWS_ThingGroups).
iot:DescribeIndex El ARN de un índice (por ejemplo,

AWS_ThingGroups).
Consulta de datos agregados

AWS IoT proporciona tres API (GetStatistics, GetCardinality y GetPercentiles) que le
permiten buscar datos agregados en su flota de dispositivos.
GetStatistics
La API GetStatistics y el comando get-statistics de la CLI devuelven el recuento, la media, la suma, el
mínimo, el máximo, la suma de los cuadrados, la varianza y la desviación estándar del campo agregado
especificado.
El comando get-statistics de la CLI usa los siguientes parámetros:
index-name
El nombre del índice que se buscará. El valor predeterminado es AWS_Things.

query-string
La consulta utilizada para buscar el índice. Puede especificar "*" para obtener el recuento de todos
los objetos indexados en su cuenta de AWS.
aggregationField
Opcional. El campo que se va a agregar. Este campo debe ser un campo administrado o
personalizado definido al llamar a update-indexing-configuration. Si no especifica un campo de
agregación, se utiliza registry.version como campo de agregación.
query-version
La versión de la consulta que se va a utilizar. El valor predeterminado es 2017-09-30.
El tipo de campo de agregación puede afectar a las estadísticas devueltas.
GetStatistics con valores de cadena

Si realiza la agregación en un campo de cadena, la llamada a GetStatistics devuelve el número de
dispositivos que tienen atributos que coinciden con la consulta. Por ejemplo:
aws iot get-statistics --aggregation-field 'attributes.stringAttribute' --query-string '*'
Este comando devuelve el número de dispositivos que contienen un atributo llamado stringAttribute:
{
"statistics": {
571
GetStatistics
"count": 3
}
}
GetStatistics con valores booleanos

Cuando llama a GetStatistics con un campo de agregación booleano:
• AVERAGE es el porcentaje de dispositivos que coinciden con la consulta.

• MINIMUM es 0 o 1 de acuerdo con las siguientes reglas:
• Si todos los valores del campo de agregación son false, MINIMUM es 0.
• Si todos los valores del campo de agregación son true, MINIMUM es 1.
• Si los valores del campo de agregación son una mezcla de false y true, MINIMUM es 0.
• MAXIMUM es 0 o 1 de acuerdo con las siguientes reglas:
• Si todos los valores del campo de agregación son false, MAXIMUM es 0.
• Si todos los valores del campo de agregación son true, MAXIMUM es 1.
• Si los valores del campo de agregación son una mezcla de false y true, MAXIMUM es 1.
• SUM es la suma del entero equivalente de los valores booleanos.
• COUNT es el número de objetos que coinciden con la consulta.
GetStatistics con valores numéricos

Cuando se llama a GetStatistics y se especifica un campo de agregación de tipo Number,
GetStatistics devuelve los siguientes valores:
count
El número de dispositivos que tienen un campo que coincide con la consulta.

average
El promedio de los valores numéricos que coinciden con la consulta.

sum
La suma de los valores numéricos que coinciden con la consulta.

minimum
El menor de los valores numéricos que coinciden con la consulta.

maximum
El mayor de los valores numéricos que coinciden con la consulta.

sumOfSquares
La suma de los cuadrados de los valores numéricos que coinciden con la consulta.
variance
La varianza de los valores numéricos que coinciden con la consulta. La varianza de un conjunto de
valores es la media de los cuadrados de las diferencias de cada valor con respecto al valor medio del
conjunto.
stdDeviation
La desviación estándar de los valores numéricos que coinciden con la consulta. La desviación
estándar de un conjunto de valores es una medida de la distribución de los valores.
572
GetCardinality
El siguiente ejemplo muestra cómo llamar a get-statistics con un campo numérico personalizado.
aws iot get-statistics --aggregation-field 'attributes.numericAttribute2' --query-string '*'
{
"statistics": {
"count": 3,
"average": 33.333333333333336,
"sum": 100.0,
"minimum": -125.0,
"maximum": 150.0,
"sumOfSquares": 43750.0,
"variance": 13472.22222222222,
"stdDeviation": 116.06990230986766
}
}
Para los campos de agregación numérica, si los valores del campo superan el valor "double" máximo, los
valores de las estadísticas están vacíos
GetCardinality
La API GetCardinality y el comando get-cardinality de la CLI devuelven el recuento aproximado de
valores únicos que coinciden con la consulta. Por ejemplo, es posible que desee encontrar el número de
dispositivos con niveles de batería inferiores al 50 por ciento:
aws iot get-cardinality --index-name AWS_Things --query-string "batterylevel > 50" --aggregation-field
"shadow.reported.batterylevel".
Este comando devuelve el número de objetos con niveles de batería de más del 50 por ciento:
{
"cardinality": 100
}
get-cardinality siempre devuelve cardinality, aunque no haya campos coincidentes. Por ejemplo:
aws iot get-cardinality --query-string "thingName:Non-existent*" --aggregation-field

"attributes.customField_STR"
{
"cardinality": 0
}
El comando get-cardinality de la CLI usa los siguientes parámetros:
index-name

query-string
aggregationField
El campo que se va a agregar.
573
GetPercentiles
query-version
GetPercentiles
La API GetPercentiles y el comando get-percentiles de la CLI agrupa los valores agregados que
coinciden con la consulta en grupos de percentiles. Los grupos de percentiles predeterminados son:
1,5,25,50,75,95,99, aunque puede especificar los suyos propios cuando llame a GetPercentiles.
Esta función devuelve un valor para cada grupo de percentiles especificado (o para los grupos de
percentiles predeterminados). El grupo de percentiles "1" contiene el valor agregado del campo que
se obtiene aproximadamente en el uno por ciento de los valores que coinciden con la consulta. El
grupo de percentiles "5" contiene el valor agregado del campo que se obtiene en aproximadamente el
cinco por ciento de los valores que coinciden con la consulta, y así sucesivamente. El resultado es una
aproximación: cuantos más valores coincidan con la consulta, más precisos serán los valores de percentil.
El siguiente ejemplo muestra cómo llamar al comando get-percentiles de la CLI.
aws iot get-percentiles --query-string "thingName:*" --aggregation-field "attributes.customField_NUM" --

percents 10 20 30 40 50 60 70 80 90 99
{
"percentiles": [
{
"value": 3.0,
"percent": 80.0
},
{
"value": 2.5999999999999996,
"percent": 70.0
},
{
"value": 3.0,
"percent": 90.0
},
{
"value": 2.0,
"percent": 50.0
},
{
"value": 2.0,
"percent": 60.0
},
{
"value": 1.0,
"percent": 10.0
},
{
"value": 2.0,
"percent": 40.0
},
{
"value": 1.0,
"percent": 20.0
},
{
"value": 1.4,
"percent": 30.0
},
{
"value": 3.0,
"percent": 99.0
574
Autorización
}
]
}
El siguiente comando muestra la salida devuelta get-percentiles cuando no hay documentos coincidentes.
aws iot get-percentiles --query-string "thingName:Non-existent*" --aggregation-field

"attributes.customField_NUM"
{
"percentiles": []
}
El comando get-percentile de la CLI usa los siguientes parámetros:
index-name

query-string
aggregationField
El campo que se va a agregar, que debe ser del tipo Number.

query-version

percents
Opcional. Puede utilizar este parámetro para especificar grupos de percentiles personalizados.
Autorización
Puede especificar el índice de grupos de objetos como un ARN del recurso en una acción de política de
AWS IoT, como en el siguiente ejemplo.
Acción Recurso
iot:GetStatistics El ARN de un índice (por ejemplo,

AWS_Things o arn:aws:iot:<your-aws-
region>:index/AWS_ThingGroups).
Sintaxis de la consulta
Las consultas se especifican mediante una sintaxis de consulta.
La sintaxis de consulta es compatible con las siguientes características.
• Términos y frases
• Búsqueda de campos
• Búsqueda de prefijos
• Búsqueda de intervalos
575
Ejemplo de consultas de objetos
• Operadores booleanos AND, OR, NOT y –. El guion se utiliza para excluir algo de los resultados de la
búsqueda (por ejemplo, thingName:(tv* AND -plasma)).
• Agrupación
• Agrupación de campos
• Utilizar secuencias de escape con caracteres especiales (por ejemplo, con \)
La sintaxis de consulta no es compatible con las siguientes características:
• Uso de caracteres comodín al principio de la búsqueda (como "*xyz"), pero si se utiliza "*" en la
búsqueda se devolverán todos los objetos
• Expresiones regulares
• Impulso
• Clasificación
• Búsquedas confusas
• Búsqueda de proximidad
• Ordenar
• Agregación
Algunas cosas que tener en cuenta acerca del idioma de consulta:
• El operador predeterminado es AND. La consulta "thingName:abc thingType:xyz" es igual que

"thingName:abc AND thingType:xyz".
• Si no se especifica un campo, AWS IoT busca el término en todos los campos.
• Todos los nombres de campo distinguen entre mayúsculas y minúsculas.
• La búsqueda distingue entre mayúsculas y minúsculas. Las palabras están separadas por caracteres de
espacio en blanco, tal como define la especificación Character.isWhitespace(int) de Java.
• La indexación de datos de dispositivo incluye secciones para los estados reported, desired y delta, y
para los metadatos.
• Las versiones de sombra y registro del dispositivo no permiten búsquedas, pero están presentes en la
respuesta.
• El número máximo de términos en una consulta es 5.

Las consultas se especifican en una cadena de consulta mediante una sintaxis de consulta y se trasladan
a la API de SearchIndex. En la siguiente tabla se enumeran algunas cadenas de consulta de ejemplo.
Cadena de consulta Resultado
abc Consulta "abc" en cualquier campo de sombras o

del registro.
thingName:myThingName Consulta un objeto con el nombre "myThingName".
thingName:my* Consulta los objetos cuyos nombres que

comienzan por "my".
thingName:ab? Consulta los objetos cuyos nombres tienen "ab"

además de un carácter adicional (por ejemplo:
"aba", "abb", "abc", etc.)
576
thingTypeName:aa Las consultas de objetos que están asociados con

el tipo aa.
attributes.myAttribute:75 Consulta los objetos con un atributo denominado

"myAttribute" que tiene el valor 75.
attributes.myAttribute:[75 TO 80] Consulta los objetos con un atributo denominado

"myAttribute", cuyo valor se encuentra dentro de un
rango numérico (entre 75 – 80, ambos incluidos).
attributes.myAttribute:{75 TO 80] Consulta los objetos con un atributo denominado

"myAttribute", cuyo valor se encuentra dentro del
rango numérico (>75 y <=80).
attributes.serialNumber:["abcd" TO "abcf"] Consulta los objetos con un atributo llamado

"serialNumber", cuyo valor se encuentra dentro del
rango de cadenas alfanuméricas. Esta consulta
devuelve objetos con un atributo "serialNumber"
con valores "abcd", "abce" o "abcf".
attributes.myAttribute:i*t Consulta los objetos con un atributo llamado

"MyAttribute" cuyo valor es 'i', seguido de un
número de caracteres, seguido por 't'.
attributes.attr1:abc AND attributes.attr2<5 NOT Consultas de objetos que combinan términos

attributes.attr3>10 mediante expresiones booleanas. Esta consulta
devuelve objetos que tengan un atributo llamado
"attr1" con un valor "abc", un atributo denominado
"attr2" inferior a 5 y un atributo llamado "attr3" que
no sea superior a 10.
shadow.hasDelta:true Consultas para objetos cuya sombra tenga un

elemento delta.
NOT attributes.model:legacy Consultas de objetos donde el atributo llamado

"model" no es "legacy".
shadow.reported.stats.battery:{70 TO 100} (v2 OR Consulta los objetos que cumplen lo siguiente:

v3) NOT attributes.model:legacy
• El atributo stats.battery de sombra del
objeto tiene un valor entre 70 y 100.
• El texto "v2" o "v3" aparece en los valores del
atributo, el nombre del tipo o el nombre del
objeto.
• El atributo model del objeto no está establecido
en "legacy".
shadow.reported.myvalues:2 Consulta los objetos cuya matriz myvalues de la

sección reported de la sombra contiene el valor 2.
shadow.reported.location:* NOT Consulta los objetos que cumplen lo siguiente:

shadow.desired.stats.battery:*
• El atributo location existe en la sección
reported de la sombra.
• El atributo stats.battery no existe en la
sección desired de la sombra.
577
Ejemplo de consultas de grupo de objetos
connectivity.connected:true Consulta sobre todos los dispositivos conectados.
connectivity.connected:false Consulta de todos los dispositivos desconectados.
connectivity.connected:true AND Consulta de todos los dispositivos conectados

connectivity.timestamp : [1557651600000 TO con una marca temporal de conexión >=
1557867600000] 1557651600000 y <= 1557867600000. Las marcas
temporales se indican en milisegundos desde la
fecha de inicio.
connectivity.connected:false AND Consulta de todos los dispositivos desconectados

connectivity.timestamp : [1557651600000 TO con una marca temporal de desconexión >=
1557867600000] 1557651600000 y <= 1557867600000. Las marcas
temporales se indican en milisegundos desde la
fecha de inicio.
connectivity.connected:true AND Consulta de todos los dispositivos conectados

connectivity.timestamp > 1557651600000 con una marca temporal de conexión >
1557651600000. Las marcas temporales se
indican en milisegundos desde la fecha de inicio.
connectivity.connected:* Consulta todos los dispositivos para los que hay

información de conectividad.

Las consultas se especifican en una cadena de consulta mediante una sintaxis de consulta y se trasladan
a la API de SearchIndex. En la siguiente tabla se enumeran algunas cadenas de consulta de ejemplo.
abc Consulta "abc" en cualquier campo.
thingGroupName:myGroupThingName Consulta un grupo de objetos con el nombre

"myGroupThingName".
thingGroupName:my* Consulta los grupos de objetos cuyos nombres que

comienzan por "my".
thingGroupName:ab? Consulta los grupos de objetos cuyos nombres

tienen "ab" además de un carácter adicional (por
ejemplo: "aba", "abb", "abc", etc.)
attributes.myAttribute:75 Consulta los grupos de con un atributo llamado

"MyAttribute" que tiene el valor de 75.
attributes.myAttribute:[75 TO 80] Consulta los grupos de con un atributo llamado

"MyAttribute", cuyo valor se encuentra dentro de un
rango numérico (entre 75 y 80, ambos incluidos).–
attributes.myAttribute:[75 TO 80] Consulta los grupos de objetos con un atributo

llamado "MyAttribute", cuyo valor se encuentra
dentro del rango numérico (>75 y <=80).
578
attributes.myAttribute:["abcd" TO "abcf"] Consulta los grupos de con un atributo llamado

"myAttribute", cuyo valor se encuentra dentro del
rango de cadenas alfanuméricas. Esta consulta
devuelve grupos de objetos con un atributo
"serialNumber" con valores "abcd", "abce" o "abcf".
attributes.myAttribute:i*t Consulta los grupos de objetos con un atributo

llamado "MyAttribute" cuyo valor es 'i', seguido de
un número de caracteres, seguido por 't'.
attributes.attr1:abc AND attributes.attr2<5 NOT Consultas de grupos de objetos que combinan

attributes.attr3>10 términos mediante expresiones booleanas. Esta
consulta devuelve grupos de objetos que tengan
un atributo denominado "attr1" con un valor "abc",
un atributo denominado "attr2" inferior a 5 y un
atributo denominado "attr3" que no sea superior a
10.
NOT attributes.myAttribute:cde Consulta los grupos de objetos donde el atributo

llamado "MyAttribute" no es "cde".
parentGroupNames:(myParentThingGroupName) Consulta los grupos de objetos cuyo

nombre de grupo principal coincide con
"myParentThingGroupName".
parentGroupNames:(myParentThingGroupName Consulta los grupos de objetos cuyo

OR myRootThingGroupName) nombre de grupo principal coincide
con "myParentThingGroupName" o
"myRootThingGroupName".
parentGroupNames:(myParentThingGroupNa*) Consulta los grupos de objetos cuyo

nombre de grupo principal empieza por
"myParentThingGroupNa".
579
AWS IoT Device Defender

AWS IoT Device Defender es un servicio de seguridad que permite auditar la configuración de los
dispositivos, monitorizar los dispositivos conectados para detectar un comportamiento anormal y mitigar los
riesgos de seguridad. Le brinda la posibilidad de aplicar políticas de seguridad coherentes en toda su flota
de dispositivos AWS IoT y responder rápidamente cuando los dispositivos sufren ataques.
Las flotas de IoT pueden constar de un gran número de dispositivos que tienen diversas funcionalidades,
son de larga duración y están distribuidos geográficamente. Estas características hacen que la
configuración de la flota sea compleja y propensa a errores. Y dado que los dispositivos a menudo están
limitados en potencia informática, memoria y capacidades de almacenamiento, esto limita el uso del cifrado
y otras formas de seguridad en los propios dispositivos. Además, los dispositivos a menudo usan software
con vulnerabilidades conocidas. Estos factores hacen que las flotas de IoT sean un objetivo atractivo para
los piratas informáticos y dificultan la protección continuada de la flota de dispositivos.
AWS IoT Device Defender afronta estos desafíos proporcionando herramientas para identificar los
problemas de seguridad y las desviaciones de las prácticas recomendadas. AWS IoT Device Defender
puede auditar las flotas de dispositivos para asegurarse de que cumplan con las prácticas recomendadas
de seguridad y detectar un comportamiento anómalo en los dispositivos.

Realice el siguiente curso para empezar a usar AWS IoT Device Defender: AWS IoT Device Defender
Primer.
Auditar
Una auditoría de AWS IoT Device Defender examina la configuración y las políticas relacionadas con una
cuenta y dispositivo para garantizar que existen medidas de seguridad. Las auditorías pueden ayudarle
a detectar cualquier desviación con respecto a las prácticas recomendadas de seguridad o a las políticas
de acceso adecuadas (por ejemplo, cuando varios dispositivos usan la misma identidad o cuando existen
políticas excesivamente permisivas que permiten a un dispositivo leer y actualizar datos de muchos otros
dispositivos). Puede ejecutar auditorías según sean necesarias (auditorías bajo demanda) o programarlas
para que se ejecuten periódicamente (auditorías programadas).
Una auditoría de AWS IoT Device Defender realiza una serie de comprobaciones predefinidas
relacionadas con las prácticas recomendadas de seguridad de IoT comunes y las vulnerabilidades de
los dispositivos. Entre las comprobaciones se incluyen las políticas que conceden permiso para leer o
actualizar datos en varios dispositivos, los dispositivos que comparten una identidad (certificado X.509), o
los certificados que van a caducar o que se han revocado pero siguen activos.
Gravedad del problema

La gravedad del problema indica el nivel de gravedad asociado con cada caso identificado de
incumplimiento y el tiempo recomendado para remediarlo.
580
Pasos siguientes
Critical
Las comprobaciones de auditoría no conformes con esta gravedad identifican los problemas
que requieren atención inmediata. Los problemas críticos permiten a menudo a los agentes
malintencionados obtener fácilmente acceso a sus recursos o controlarlos sin demasiada sofisticación
y sin disponer de información privilegiada o credenciales especiales.
Alta
Las comprobaciones de auditoría no conformes con esta gravedad requieren una investigación
urgente y una planificación de remediación después de que se resuelvan los problemas críticos. Al
igual que los problemas críticos, los problemas con gravedad alta suelen proporcionar los usuarios
malintencionados acceso o control de sus recursos. Sin embargo, los problemas con gravedad alta
suelen ser más difíciles de aprovechar. Es posible que requieran herramientas especiales, información
privilegiada o configuraciones específicas.
Medio
Las comprobaciones de auditoría no conformes con esta gravedad presentan problemas que
requieren atención como parte del mantenimiento continuo del estado de seguridad. Los problemas de
gravedad media pueden causar un impacto operativo negativo, como interrupciones no planificadas
debido a un mal funcionamiento de los controles de seguridad. Estos problemas también pueden
proporcionar a los usuarios malintencionados acceso o control limitado a sus recursos, o pueden
facilitar algunos pasos de sus acciones maliciosas.
Baja
Las comprobaciones de auditoría no conformes con esta gravedad suelen indicar que las prácticas
recomendadas de seguridad se descuidaron o se pasaron por alto. Aunque pueden no causar un
impacto inmediato en la seguridad, estos descuidos pueden ser aprovechados por usuarios con malas
intenciones. Al igual que los problemas de gravedad media, los problemas de gravedad baja requieren
atención como parte del mantenimiento continuo del estado de seguridad.
Pasos siguientes
Para conocer los tipos de comprobaciones de auditoría que se pueden realizar, consulte
Comprobaciones de auditoría (p. 581). Para saber cómo realizar una auditoría, consulte Cómo realizar
auditorías (p. 607). Para obtener información sobre las cuotas de servicio que se aplican a las auditorías,
consulte la sección Cuotas de servicio.
Comprobaciones de auditoría
Note
Cuando habilita una comprobación, la recopilación de datos comienza inmediatamente. Si

tiene que recopilar una gran cantidad de datos en la cuenta, es posible que los resultados de la
comprobación no estén disponibles durante cierto tiempo después de habilitarlos.
Es posible realizar las siguientes comprobaciones de auditoría:
• REVOKED_CA_CERT_CHECK (p. 582)

• DEVICE_CERTIFICATE_SHARED_CHECK (p. 582)
• DEVICE_CERTIFICATE_KEY_QUALITY_CHECK (p. 583)
• CA_CERTIFICATE_KEY_QUALITY_CHECK (p. 585)
• UNAUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK (p. 586)
• AUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK (p. 591)
581
• IOT_POLICY_OVERLY_PERMISSIVE_CHECK (p. 598)

• IOT_ROLE_ALIAS_OVERLY_PERMISSIVE_CHECK (p. 602)
• IOT_ROLE_ALIAS_ALLOWS_ACCESS_TO_UNUSED_SERVICES_CHECK (p. 603)
• CA_CERT_APPROACHING_EXPIRATION_CHECK (p. 604)
• CONFLICTING_CLIENT_IDS_CHECK (p. 604)
• DEVICE_CERT_APPROACHING_EXPIRATION_CHECK (p. 605)
• REVOKED_DEVICE_CERT_CHECK (p. 606)
• LOGGING_DISABLED_CHECK (p. 607)
REVOKED_CA_CERT_CHECK
Se revocó un certificado de CA pero sigue activo en AWS IoT.
Gravedad: crítica
Detalles
Un certificado de CA está marcado como revocado en la lista de revocación de certificados mantenida por
la entidad emisora, pero sigue marcado como "ACTIVE" o "PENDING_TRANSFER" en AWS IoT.
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra un certificado de CA
no conforme:
• CERTIFICATE_REVOKED_BY_ISSUER
¿Por qué importa?

Un certificado de CA revocado no debe utilizarse nunca más para firmar certificados de dispositivos.
Puede que se haya revocado porque ha sufrido un ataque. Los dispositivos agregados recientemente con
certificados firmados con este certificado de CA pueden constituir una amenaza para la seguridad.
Cómo solucionarlo
1. Utilice UpdateCACertificate para marcar el certificado de CA como INACTIVO en AWS IoT. También
puede utilizar acciones de mitigación para:
• Aplicar la acción de mitigación UPDATE_CA_CERTIFICATE en los resultados de la auditoría para
realizar este cambio.
• Aplique la acción de mitigación PUBLISH_FINDINGS_TO_SNS para implementar una respuesta
personalizada al mensaje de Amazon SNS.
Para obtener más información, consulte Acciones de mitigación (p. 641).

2. Revise la actividad de registro de certificados de dispositivo realizada después de que se revocara
el certificado de CA y considere la posibilidad de revocar los certificados de dispositivo que se hayan
podido emitir durante este período. Puede utilizar ListCertificatesByCA para obtener una lista de
los certificados de dispositivo firmados con el certificado de CA y UpdateCertificate para revocar un
certificado de dispositivo.
DEVICE_CERTIFICATE_SHARED_CHECK
Varias conexiones simultáneas usan el mismo certificado X.509 para autenticarse con AWS IoT.
582
Gravedad: crítica
Detalles
Una vez que se habilita esta comprobación, la recopilación de datos comienza de inmediato, pero los
resultados de la comprobación no están disponibles hasta pasadas al menos dos horas.
Cuando se realiza como parte de una auditoría bajo demanda, esta comprobación analiza los certificados
y los ID de cliente utilizados por los dispositivos para conectarse durante los 31 días anteriores al inicio
de la auditoría. Para las auditorías programadas, esta comprobación analiza los datos desde la última vez
que se realizó la auditoría hasta el momento en que comenzó esta instancia de la auditoría. Si ha tomado
medidas para mitigar esta condición durante el periodo de la comprobación, observe cuándo se realizaron
las conexiones simultáneas para determinar si el problema persiste.
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra un certificado no
conforme:
• CERTIFICATE_SHARED_BY_MULTIPLE_DEVICES
Además, los resultados devueltos con esta comprobación incluyen el ID del certificado compartido, los
ID de los clientes que usan el certificado para conectarse y los tiempos de conexión/desconexión. Se
muestran primero los resultados más recientes.
¿Por qué importa?

Cada dispositivo debe tener un certificado único para autenticarse con AWS IoT. Cuando varios
dispositivos utilizan el mismo certificado, esto podría indicar que un dispositivo ha sufrido un ataque. Puede
que su identidad haya sido clonada para realizar nuevos ataques en el sistema.
Cómo solucionarlo
Compruebe que el certificado del dispositivo no ha sufrido un ataque. Si ha sido atacado, siga las prácticas
recomendadas de seguridad para mitigar la situación.
Si utiliza el mismo certificado en varios dispositivos, es posible que desee:
1. Aprovisionar nuevo certificados únicos y asociarlos a cada dispositivo.

2. Verificar que los nuevos certificados sean válidos y que los dispositivos puedan usarlos para conectarse.
3. Utilice UpdateCertificate para marcar el certificado antiguo como REVOCADO en AWS IoT. También
puede utilizar acciones de mitigación para realizar las siguientes acciones:
• Aplicar la acción de mitigación UPDATE_DEVICE_CERTIFICATE en los resultados de la auditoría
para realizar este cambio.
• Aplicar la acción de mitigación ADD_THINGS_TO_THING_GROUP para añadir el dispositivo a un grupo
en el que puede tomar medidas.
• Aplicar la acción de mitigación PUBLISH_FINDINGS_TO_SNS si desea implementar una respuesta
personalizada en respuesta al mensaje de Amazon SNS.

4. Desvincular el certificado antiguo de cada uno de los dispositivos.
DEVICE_CERTIFICATE_KEY_QUALITY_CHECK
Los clientes de AWS IoT suelen confiar en la autenticación mutua de TLS mediante certificados X.509
para autenticarse en el agente de mensajes de AWS IoT. Estos certificados y los certificados de la entidad
583
de certificación se deben registrar en la cuenta de AWS IoT para poder utilizarlos. AWS IoT realiza
comprobaciones de verificación básicas en estos certificados cuando se registran. Estas comprobaciones
incluyen:
• Deben tener un formato válido.

• Deben estar firmados por una autoridad de certificación registrada.
• Deben estar dentro del periodo de validez (es decir, no han caducado).
• Los tamaños de la clave criptográfica deben cumplir con un tamaño mínimo requerido (para las claves
RSA deben ser de 2048 bits o más).
Esta comprobación de auditoría proporciona las siguientes pruebas adicionales de la calidad de la clave
criptográfica:
• CVE-2008-0166: comprueba si la clave se ha generado mediante OpenSSL 0.9.8c-1 hasta versiones

anteriores a 0.9.8g-9 en un sistema operativo basado en Debian. Esas versiones de OpenSSL utilizan
un generador de números aleatorios que genera números predecibles, lo que permite a los atacantes
remotos realizar ataques de adivinación de fuerza bruta contra claves criptográficas.
• CVE-2017-15361: comprueba si la clave se ha generado mediante la biblioteca Infineon RSA
1.02.013 en el firmware Infineon Trusted Platform Module (TPM), como las versiones anteriores a
0000000000000422 - 4.34, anteriores a 000000000000062b - 6.43 y anteriores a 0000000000008521
- 133.33. Esa biblioteca trata de forma inadecuada la generación de claves RSA, lo que permite a
los atacantes frustrar algunos mecanismos de protección criptográfica a través de ataques dirigidos.
Algunos ejemplos de tecnologías afectadas son BitLocker con TPM 1.2, generación de claves PGP de
YubiKey 4 (anterior a 4.3.5) y la función de cifrado de datos de usuario en caché en el sistema operativo
Chrome.
AWS IoT Device Defender registra los certificados como no conformes si no superan estas
comprobaciones.
Gravedad: crítica
Detalles
Esta comprobación se aplica a los certificados de dispositivo ACTIVE o PENDING_TRANSFER.
conforme:
• CERTIFICATE_KEY_VULNERABILITY_CVE-2017-15361
¿Por qué importa?

Cuando un dispositivo utiliza un certificado vulnerable, los atacantes pueden atacar más fácilmente ese
dispositivo.
Cómo solucionarlo
Actualice los certificados de su dispositivo para reemplazar aquellos con vulnerabilidades conocidas.
Si está utilizando el mismo certificado en varios dispositivos, es posible que desee:
1. Aprovisionar nuevo certificados únicos y asociarlos a cada dispositivo.

2. Verificar que los nuevos certificados sean válidos y que los dispositivos puedan usarlos para conectarse.
584

4. Desvincular el certificado antiguo de cada uno de los dispositivos.
CA_CERTIFICATE_KEY_QUALITY_CHECK
Los clientes de AWS IoT suelen confiar en la autenticación mutua de TLS mediante certificados X.509
para autenticarse en el agente de mensajes de AWS IoT. Estos certificados y los certificados de la
entidad de certificación deben registrarse en la cuenta de AWS IoT para poder utilizarlos. AWS IoT realiza
comprobaciones de verificación básicas en estos certificados cuando se registran, incluidas las siguientes:
• Los certificados tienen un formato válido.

• Los certificados están dentro de su período de validez (es decir, no han caducado).
• Los tamaños de la clave criptográfica cumplen con un tamaño mínimo requerido (para las claves RSA
deben ser de 2048 bits o más).
Esta comprobación de auditoría proporciona las siguientes pruebas adicionales de la calidad de la clave
criptográfica:
• CVE-2008-0166: comprueba si la clave se ha generado mediante OpenSSL 0.9.8c-1 hasta versiones

anteriores a 0.9.8g-9 en un sistema operativo basado en Debian. Esas versiones de OpenSSL utilizan
un generador de números aleatorios que genera números predecibles, lo que permite a los atacantes
remotos realizar ataques de adivinación de fuerza bruta contra claves criptográficas.
• CVE-2017-15361: comprueba si la clave se ha generado mediante la biblioteca Infineon RSA
1.02.013 en el firmware Infineon Trusted Platform Module (TPM), como las versiones anteriores a
0000000000000422 - 4.34, anteriores a 000000000000062b - 6.43 y anteriores a 0000000000008521
- 133.33. Esa biblioteca trata de forma inadecuada la generación de claves RSA, lo que permite a
los atacantes frustrar algunos mecanismos de protección criptográfica a través de ataques dirigidos.
Algunos ejemplos de tecnologías afectadas son BitLocker con TPM 1.2, generación de claves PGP de
YubiKey 4 (anterior a 4.3.5) y la función de cifrado de datos de usuario en caché en el sistema operativo
Chrome.
AWS IoT Device Defender registra los certificados como no conformes si no superan estas
comprobaciones.
Gravedad: crítica
Detalles
Esta comprobación se aplica a los certificados de CA ACTIVE o PENDING_TRANSFER.
conforme:
585
¿Por qué importa?

Los dispositivos agregados recientemente firmados con este certificado de CA pueden constituir una
amenaza para la seguridad.
Cómo solucionarlo
1. Utilice UpdateCACertificate para marcar el certificado de CA como INACTIVO en AWS IoT. También

2. Revise la actividad de registro de certificados de dispositivo realizada después de que se revocara
el certificado de CA y considere la posibilidad de revocar los certificados de dispositivo que se
hayan podido emitir durante este período. (Utilice ListCertificatesByCA para obtener una lista de los
certificados de dispositivos firmados con el certificado de CA y UpdateCertificate para revocar un
certificado de dispositivos).
UNAUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK
Una política asociada a un rol de grupo de identidades de Amazon Cognito no autenticado se considera
excesivamente permisivo porque otorga permiso para realizar cualquiera de las siguientes acciones de
AWS IoT:
• Administrar o modificar objetos

• Leer datos administrativos de objetos
• Administrar datos o recursos relacionados con elementos que no sean objetos
O bien porque otorga permiso para realizar las siguientes acciones de AWS IoT en un amplio conjunto de
dispositivos:
• Utilizar MQTT para conectar, publicar o suscribirse a temas reservados (incluidos los datos de ejecución
de sombras o de trabajos)
• Utilizar comandos de la API para leer o modificar los datos de ejecución de sombras o de trabajos
En general, los dispositivos que se conectan usando un rol de grupo de identidades de Amazon Cognito no
autenticado deben tener solo permisos limitados para publicar y suscribirse a temas de MQTT específicos
o usar los comandos de la API para leer y modificar datos específicos de objetos relacionados con los
datos de ejecución de sombras o de trabajos.
Gravedad: crítica
Detalles
Para esta comprobación, AWS IoT Device Defender audita todos los grupos de identidades de Amazon
Cognito que se han utilizado para conectarse al agente de mensajes de AWS IoT durante los últimos 31
días previos a la ejecución de la auditoría. En la auditoría se incluyen todos los grupos de identidades de
586
Amazon Cognito a partir de los cuales se ha conectado una identidad de Amazon Cognito autenticada o no
autenticada.
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra un rol de grupo de
identidades de Amazon Cognito no autenticado no conforme:
• ALLOWS_ACCESS_TO_IOT_ADMIN_ACTIONS
• ALLOWS_BROAD_ACCESS_TO_IOT_DATA_PLANE_ACTIONS
¿Por qué importa?

Debido a que las identidades no autenticadas nunca las autentica el usuario, suponen un riesgo mucho
mayor que las identidades de Amazon Cognito autenticadas. Si se ha puesto en riesgo una identidad no
autenticada, se podrían usar acciones administrativas para modificar la configuración de la cuenta, eliminar
recursos u obtener acceso a información confidencial. O bien, con un amplio acceso a la configuración
del dispositivo, se podría obtener acceso a sombras y trabajos de todos los dispositivos de su cuenta o
modificarlos. Un usuario invitado podría usar los permisos para poner en riesgo toda su flota o lanzar un
ataque DDOS con mensajes.
Cómo solucionarlo
Una política asociada a un rol de grupo de identidades de Amazon Cognito no autenticado debería otorgar
solo los permisos necesarios para que un dispositivo haga su trabajo. Recomendamos los siguientes
pasos:
1. Crear un nuevo rol conforme.

2. Crear un nuevo grupo de identidades de Amazon Cognito y asociarlo al rol conforme.
3. Verificar que sus identidades puedan obtener acceso a AWS IoT con el nuevo grupo.
4. Una vez que se complete la verificación, asociar el nuevo rol conforme al grupo de identidades de
Amazon Cognito marcado como no conforme.
También puede utilizar acciones de mitigación para:

Administrar o modificar objetos

Las siguientes acciones de la API de AWS IoT se utilizan para administrar o modificar objetos. No se debe
conceder permiso para realizar estas acciones a los dispositivos que se conectan a través de un grupo de
identidades de Amazon Cognito no autenticado.
• AddThingToThingGroup
• AttachThingPrincipal
• CreateThing
• DeleteThing
• DetachThingPrincipal
• ListThings
• ListThingsInThingGroup
• RegisterThing
587
• RemoveThingFromThingGroup
• UpdateThing
• UpdateThingGroupsForThing
Cualquier rol que otorgue permiso para realizar estas acciones, incluso en un solo recurso, se considera no
conforme.
Leer datos administrativos de objetos

Las siguientes acciones de la API de AWS IoT se utilizan para leer o modificar datos de objetos. Los
dispositivos que se conectan a través de un grupo de identidades de Amazon Cognito no autenticado no
deben recibir permiso para realizar estas acciones.
• DescribeThing
• ListJobExecutionsForThing
• ListThingGroupsForThing
• ListThingPrincipals
Example
• no conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:DescribeThing",
"iot:ListJobExecutionsForThing",
"iot:ListThingGroupsForThing",
"iot:ListThingPrincipals"
],
"Resource": [
"arn:aws:iot:region:account-id:/thing/MyThing"
]
}
]
}
Esto permite que el dispositivo realice las acciones especificadas incluso aunque se otorgue solo para
un objeto.
Administrar elementos que no sean objetos

A los dispositivos que se conectan a través de un grupo de identidades de Amazon Cognito no autenticado
no se les debe conceder permiso para realizar acciones de la API de AWS IoT distintas de las que se
indican en estas secciones. Puede administrar la cuenta con una aplicación que se conecta a través de un
grupo de identidades de Amazon Cognito no autenticado mediante la creación de un grupo de entidades
independiente que no utilizan los dispositivos.
Suscribirse/publicar en temas de MQTT

Los mensajes MQTT se envían a través del agente de mensajes de AWS IoT y los dispositivos los usan
para realizar muchas acciones, incluido el acceso y la modificación del estado de la sombra y el estado
588
de ejecución del trabajo. Una política que otorga permiso a un dispositivo para conectarse, publicar o
suscribirse a mensajes de MQTT debe restringir estas acciones a recursos específicos de la siguiente
manera:
Conectar
• no conforme:
arn:aws:iot:region:account-id:client/*
El carácter comodín * permite que cualquier dispositivo se conecte a AWS IoT.
arn:aws:iot:region:account-id:client/${iot:ClientId}
A menos que iot:Connection.Thing.IsAttached se establezca en true en la claves de

condición, es equivalente al carácter comodín * del ejemplo anterior.
• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "iot:Connect" ],
"Resource": [
"arn:aws:iot:region:account-id:client/${iot:Connection.Thing.ThingName}"
],
"Condition": {
"Bool": { "iot:Connection.Thing.IsAttached": "true" }
}
}
]
}
La especificación de recursos contiene una variable que coincide con el nombre del dispositivo que
se utiliza para conectarse. La instrucción de condición restringe aún más el permiso al comprobar
que el certificado utilizado por el cliente de MQTT coincida con el que está asociado al objeto con el
nombre utilizado.
Publicar
• no conforme:
arn:aws:iot:region:account-id:topic/$aws/things/*/shadow/update
Esto permite que el dispositivo actualice la sombra de cualquier dispositivo (* = todos los
dispositivos).
arn:aws:iot:region:account-id:topic/$aws/things/*
Esto permite que el dispositivo lea, actualice o elimine la sombra de cualquier dispositivo.
• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
589
"Resource": [
"arn:aws:iot:region:account-id:topic/$aws/things/
${iot:Connection.Thing.ThingName}/shadow/*"
],
}
]
}
La especificación del recurso contiene un comodín, pero solo coincide con cualquier tema
relacionado con la sombra para el dispositivo cuyo nombre de objeto se utilice para conectarse.
Suscribirse
• no conforme:
arn:aws:iot:region:account-id:topicfilter/$aws/things/*
Esto permite que el dispositivo se suscriba a temas de sombra o de trabajo reservados para todos
los dispositivos.
Lo mismo que el ejemplo anterior, pero usando el comodín #.
arn:aws:iot:region:account-id:topic/$aws/things/+/shadow/update
Esto permite que el dispositivo vea las actualizaciones de la sombra en cualquier dispositivo (+ =
todos los dispositivos).
• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [ "iot:Subscribe" ],
"Resource": [
"arn:aws:iot:region:account-id:topicfilter/$aws/things/
${iot:Connection.Thing.ThingName}/jobs/*"
],
}
]
}
Las especificaciones de recursos contienen caracteres comodín pero solo coinciden con cualquier
tema relacionado con la sombra y cualquier tema relacionado con el trabajo para el dispositivo cuyo
nombre de objeto se use para conectarse.
Recibir
• conforme:
Esto se permite porque el dispositivo solo puede recibir mensajes de temas en los que tiene permiso
para suscribirse.
590
Leer/modificar los datos de trabajo o sombras

Una política que concede permiso a un dispositivo para realizar una acción de la API para obtener acceso
a datos de ejecución de sombras o trabajos o modificarlos debe restringir estas acciones a recursos
específicos. Las acciones de la API son las siguientes:
• DeleteThingShadow
• GetThingShadow
• UpdateThingShadow
Example
• no conforme:
arn:aws:iot:region:account-id:thing/*
Esto permite al dispositivo realizar la acción especificada en cualquier objeto.

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:DeleteThingShadow",
"iot:DescribeJobExecution",
"iot:GetPendingJobExecutions",
"iot:StartNextPendingJobExecution",
"iot:UpdateJobExecution"
],
"Resource": [
"arn:aws:iot:region:account-id:/thing/MyThing1",
"arn:aws:iot:region:account-id:/thing/MyThing2"
]
}
]
}
Esto permite que el dispositivo realice las acciones especificadas en solo dos objetos.
AUTHENTICATED_COGNITO_ROLE_OVERLY_PERMISSIVE_CHECK
Una política asociada a un rol de grupo de identidades de Amazon Cognito autenticado se considera
excesivamente permisivo porque otorga permiso para realizar las siguientes acciones de AWS IoT:
• Administrar o modificar objetos

• Administrar datos o recursos relacionados con elementos que no sean objetos
591
O bien porque otorga permiso para realizar las siguientes acciones de AWS IoT en un amplio conjunto de
dispositivos:
• Leer datos administrativos de objetos

• Utilizar MQTT para conectar/publicar/suscribirse a temas reservados (incluidos los datos de ejecución de
sombras o de trabajos)
• Utilizar comandos de la API para leer o modificar los datos de ejecución de sombras o de trabajos
En general, los dispositivos que se conectan usando un rol de grupo de identidades de Amazon Cognito
autenticado solo deben tener permisos limitados para leer datos administrativos específicos de los objetos,
publicar y suscribirse a temas de MQTT específicos o usar los comandos de la API para leer y modificar
datos específicos de los objetos relacionados con los datos de ejecución de sombras o de trabajos.
Gravedad: crítica
Detalles
Para esta comprobación, AWS IoT Device Defender audita todos los grupos de identidades de Amazon
Cognito que se han utilizado para conectarse al agente de mensajes de AWS IoT durante los últimos 31
días previos a la ejecución de la auditoría. En la auditoría se incluyen todos los grupos de identidades de
Amazon Cognito a partir de los cuales se ha conectado una identidad de Amazon Cognito autenticada o no
autenticada.
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra un rol de grupo de
identidades de Amazon Cognito autenticado no conforme:
• ALLOWS_BROAD_ACCESS_TO_IOT_THING_ADMIN_READ_ACTIONS
• ALLOWS_ACCESS_TO_IOT_NON_THING_ADMIN_ACTIONS
• ALLOWS_ACCESS_TO_IOT_THING_ADMIN_WRITE_ACTIONS
¿Por qué importa?

Si se ha puesto en riesgo una identidad autenticada, se podrían usar acciones administrativas para
modificar la configuración de la cuenta, eliminar recursos u obtener acceso a información confidencial.
Cómo solucionarlo
Una política asociada a un rol de grupo de identidades de Amazon Cognito autenticado debería otorgar
solo los permisos necesarios para que un dispositivo haga su trabajo. Recomendamos los siguientes
pasos:
1. Crear un nuevo rol conforme.

2. Crear un nuevo grupo de identidades de Amazon Cognito y asociarlo al rol conforme.
3. Verificar que sus identidades puedan obtener acceso a AWS IoT con el nuevo grupo.
4. Una vez que se haya completado la verificación, asocie el rol al grupo de identidades de Amazon
Cognito que se marcó como no conforme.
También puede utilizar acciones de mitigación para:

592
Administrar o modificar objetos

Las siguientes acciones de la API de AWS IoT se usan para administrar o modificar objetos, por lo que
no se debe otorgar permiso para realizarlas a los dispositivos que se conectan a través de un grupo de
identidades de Amazon Cognito autenticado:
• AddThingToThingGroup
• AttachThingPrincipal
• CreateThing
• DeleteThing
• DetachThingPrincipal
• ListThings
• ListThingsInThingGroup
• RegisterThing
• RemoveThingFromThingGroup
• UpdateThing
• UpdateThingGroupsForThing
Cualquier rol que otorgue permiso para realizar estas acciones, incluso en un solo recurso, se considera no
conforme.
Administrar elementos que no sean objetos

A los dispositivos que se conectan a través de un grupo de identidades de Amazon Cognito autenticado no
se les debe conceder permiso para realizar acciones de la API de AWS IoT distintas de las que se indican
en estas secciones. Para administrar su cuenta con una aplicación que se conecta a través de un grupo de
identidades de Amazon Cognito autenticado, cree un grupo de identidades independiente no utilizado por
los dispositivos.
Leer datos administrativos de objetos

Las siguientes acciones de la API de AWS IoT se utilizan para leer datos de objetos, por lo que a los
dispositivos que se conectan a través de un grupo de identidades de Amazon Cognito autenticado se les
debe dar permiso para realizarlas solamente en un conjunto limitado de objetos:
• DescribeThing
• ListJobExecutionsForThing
• ListThingGroupsForThing
• ListThingPrincipals
• no conforme:

• conforme:
{
"Version": "2012-10-17",
"Statement": [
593
{
"Effect": "Allow",
"Action": [
],
"Resource": [
]
}
]
}
Esto permite al dispositivo realizar las acciones especificadas solo en un objeto.

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
],
"Resource": [
"arn:aws:iot:region:account-id:/thing/MyThing*"
]
}
]
}
Esto es conforme porque, aunque el recurso se especifica con un carácter comodín (*), va precedido de
una cadena específica y esta limita el acceso al conjunto de objetos que tienen el prefijo concreto.
• no conforme:

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
],
"Resource": [
]
594
}
]
}
Esto permite al dispositivo realizar las acciones especificadas solo en un objeto.

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
],
"Resource": [
"arn:aws:iot:region:account-id:/thing/MyThing*"
]
}
]
}
Esto es conforme porque, aunque el recurso se especifica con un carácter comodín (*), va precedido de
una cadena específica y esta limita el acceso al conjunto de objetos que tienen el prefijo concreto.
Suscribirse/publicar en temas de MQTT

Los mensajes de MQTT se envían a través del agente de mensajes de AWS IoT y los dispositivos los usan
para realizar muchas acciones diferentes, incluido el acceso y la modificación del estado de la sombra y el
estado de ejecución del trabajo. Una política que otorga permiso a un dispositivo para conectarse, publicar
o suscribirse a mensajes de MQTT debe restringir estas acciones a recursos específicos de la siguiente
manera:
Conectar
• no conforme:

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
595
],
"Condition": {
}
}
]
}
La especificación del recurso contiene una variable que coincide con el nombre del dispositivo
utilizado para conectarse, y la instrucción de condición restringe aún más el permiso verificando que
el certificado utilizado por el cliente MQTT coincida con el que está asociado al objeto con el nombre
utilizado.
Publicar
• no conforme:
dispositivos).
Esto permite que el dispositivo lea/actualice/elimine la sombra de cualquier dispositivo.

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
],
}
]
}
Suscribirse
• no conforme:
los dispositivos.
arn:aws:iot:region:account-id:topicfilter/$aws/things/#
596
• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
],
}
]
}
Recibir
• conforme:
Esto es conforme porque el dispositivo solo puede recibir mensajes de temas en los que tiene
permiso para suscribirse.
Leer o modificar datos de trabajo o sombras

• GetThingShadow
Ejemplos
• no conforme:

• conforme:
597
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
],
"Resource": [
]
}
]
}
Esto permite al dispositivo realizar las acciones especificadas solo en dos objetos.
IOT_POLICY_OVERLY_PERMISSIVE_CHECK
Una política de AWS IoT otorga permisos que son demasiado amplios o no están sujetos a restricciones.
Otorga permiso para enviar o recibir mensajes de MQTT para un amplio conjunto de dispositivos, u otorga
permiso para obtener acceso a los datos de ejecución de sombras y de trabajos o modificarlos para un
amplio conjunto de dispositivos.
En general, una política para un dispositivo debería otorgar acceso a recursos asociados con ese
dispositivo y sin otros dispositivos o con muy pocos. Con algunas excepciones, el uso de un carácter
comodín (por ejemplo, "*") para especificar recursos en dicha política se considera demasiado amplio o sin
restricciones.
Gravedad: crítica
Detalles
Se devuelve el siguiente código de motivo cuando esta comprobación encuentra una política de AWS IoT
no conforme:
¿Por qué importa?

Un certificado, una identidad de Amazon Cognito o un grupo de objetos con una política excesivamente
permisiva puede, en caso de ser atacado, afectar a la seguridad de toda su cuenta. Un atacante podría
usar un acceso tan amplio para leer o modificar sombras, trabajos o ejecuciones de trabajos para todos
sus dispositivos. O un atacante podría usar un certificado atacado para conectar dispositivos maliciosos o
lanzar un ataque DDOS en su red.
Cómo solucionarlo
Siga estos pasos para corregir las políticas no conformes asociadas a objetos, grupos de objetos u otras
entidades:
598
1. Utilice CreatePolicyVersion para crear une nueva versión conforme de la política. Establezca la marca
setAsDefault en true. (Esto hace que esta nueva versión funcione para todas las entidades que
utilizan la política).
2. Utilice ListTargetsForPolicy para obtener una lista de destinos (certificados o grupos de objetos) a los
que la política está asociada y determinar qué dispositivos están incluidos en los grupos o cuáles utilizan
los certificados para conectarse.
3. Verifique que todos los dispositivos asociados puedan conectarse a AWS IoT. Si un dispositivo no
puede conectarse, utilice SetPolicyVersion para devolver la política predeterminada a la versión
anterior, revisar la política e intentarlo de nuevo.
Puede utilizar acciones de mitigación para:
• Aplicar la acción de mitigación REPLACE_DEFAULT_POLICY_VERSION en los resultados de la auditoría

Utilice las variables de política de AWS IoT (p. 155) para hacer referencia de forma dinámica a los recursos
de AWS IoT en las políticas.
Permisos de MQTT
Los mensajes MQTT se envían a través del agente de mensajes de AWS IoT y los dispositivos los usan
para realizar muchas acciones, incluido el acceso y la modificación del estado de la sombra y el estado
de ejecución del trabajo. Una política que otorga permiso a un dispositivo para conectarse, publicar o
suscribirse a mensajes de MQTT debe restringir estas acciones a recursos específicos de la siguiente
manera:
Conectar
• no conforme:

• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
],
"Condition": {
599
}
}
]
}
La especificación de recursos contiene una variable que coincide con el nombre del dispositivo que
se utiliza para conectarse. La instrucción de condición restringe aún más el permiso al comprobar
que el certificado utilizado por el cliente de MQTT coincida con el que está asociado al objeto con el
nombre utilizado.
Publicar
• no conforme:
dispositivos).
Esto permite que el dispositivo lea, actualice o elimine la sombra de cualquier dispositivo.
• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
],
}
]
}
Suscribirse
• no conforme:
los dispositivos.
600
• conforme:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Resource": [
],
}
]
}
Recibir
• conforme:
Esto es conforme porque el dispositivo solo puede recibir mensajes de temas en los que tiene
permiso para suscribirse.
Permisos de trabajo y sombras

• GetThingShadow
Ejemplos
• no conforme:

• conforme:
601
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
],
"Resource": [
]
}
]
}
Esto permite al dispositivo realizar las acciones especificadas solo en dos objetos.
IOT_ROLE_ALIAS_OVERLY_PERMISSIVE_CHECK
El alias de rol de AWS IoT proporciona un mecanismo para que los dispositivos conectados se autentiquen
en AWS IoT mediante certificados X.509 y obtengan credenciales de AWS de corta duración de un
rol de IAM asociado a un alias de rol de AWS IoT. Los permisos para estas credenciales se deben
reducir mediante políticas de acceso con variables de contexto de autenticación. Si las políticas no están
configuradas correctamente, podría quedar expuesto a una escalada de ataque de privilegios. Esta
comprobación de auditoría garantiza que las credenciales temporales proporcionadas por los alias de rol
de AWS IoT no sean excesivamente permisivas.
Esta comprobación se activa si se encuentra una de las siguientes condiciones:
• La política proporciona permisos administrativos a todos los servicios utilizados en el último año por este
alias de rol (por ejemplo, "iot:*", "dynamodb:*", "iam:*", etc.).
• La política proporciona un amplio acceso a acciones de metadatos de objetos, acceso a acciones de
AWS IoT restringidas o un amplio acceso a acciones del plano de datos de AWS IoT.
• La política proporciona acceso a servicios de auditoría de seguridad como "iam", "cloudtrail",
"guardduty", "inspector" o "trustedadvisor".
Gravedad: crítica
Detalles
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra una política de IoT
no conforme:
• ALLOWS_BROAD_ACCESS_TO_USED_SERVICES
• ALLOWS_ACCESS_TO_SECURITY_AUDITING_SERVICES
• ALLOWS_BROAD_ACCESS_TO_IOT_THING_ADMIN_READ_ACTIONS
• ALLOWS_ACCESS_TO_IOT_NON_THING_ADMIN_ACTIONS
• ALLOWS_ACCESS_TO_IOT_THING_ADMIN_WRITE_ACTIONS
602
¿Por qué importa?

Al limitar los permisos a aquellos que se requieren para que un dispositivo realice sus operaciones
normales, se reducen los riesgos de su cuenta si un dispositivo es víctima de un ataque.
Cómo solucionarlo
entidades:
1. Siga los pasos descritos en Autorización de llamadas directas a los servicios de AWS (p. 181) para
aplicar una política más restrictiva al alias de rol.
• Aplicar la acción de mitigación PUBLISH_FINDINGS_TO_SNS si desea implementar una acción

IOT_ROLE_ALIAS_ALLOWS_ACCESS_TO_UNUSED_SERVICES_CHEC
El alias de rol de AWS IoT proporciona un mecanismo para que los dispositivos conectados se autentiquen
en AWS IoT mediante certificados X.509 y obtengan credenciales de AWS de corta duración de un
rol de IAM asociado a un alias de rol de AWS IoT. Los permisos para estas credenciales se deben
reducir mediante políticas de acceso con variables de contexto de autenticación. Si las políticas no están
configuradas correctamente, podría quedar expuesto a una escalada de ataque de privilegios. Esta
comprobación de auditoría garantiza que las credenciales temporales proporcionadas por los alias de rol
de AWS IoT no sean excesivamente permisivas.
Esta comprobación se activa si el alias de rol tiene acceso a servicios que no se han utilizado para
el dispositivo de AWS IoT en el último año. Por ejemplo, la auditoría le informa si tiene un rol de IAM
vinculado al alias de rol que solo ha utilizado AWS IoT en el último año, pero la política asociada al rol
también concede permiso a "iam:getRole" y "dynamodb:PutItem".
Gravedad: media
Detalles
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra una política de AWS
IoT no conforme:
• ALLOWS_ACCESS_TO_UNUSED_SERVICES
¿Por qué importa?

Al limitar los permisos a los servicios que se requieren para que un dispositivo realice sus operaciones
normales, se reducen los riesgos de su cuenta si un dispositivo es víctima de un ataque.
Cómo solucionarlo
entidades:
1. Siga los pasos descritos en Autorización de llamadas directas a los servicios de AWS (p. 181) para
aplicar una política más restrictiva al alias de rol.
603
• Aplicar la acción de mitigación PUBLISH_FINDINGS_TO_SNS si desea implementar una acción

CA_CERT_APPROACHING_EXPIRATION_CHECK
Un certificado de CA va a caducar dentro de 30 días o ha caducado.
Gravedad: media
Detalles
Esta comprobación se aplica a los certificados de CA ACTIVE o PENDING_TRANSFER.
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra un certificado de CA
no conforme:
• CERTIFICATE_APPROACHING_EXPIRATION
• CERTIFICATE_PAST_EXPIRATION
¿Por qué importa?

Un certificado de CA caducado no debe utilizarse para firmar nuevos certificados de dispositivos.
Cómo solucionarlo
Consulte las prácticas recomendadas de seguridad para saber cómo proceder. Es posible que desee:
1. Registrar un nuevo certificado de CA en AWS IoT.

2. Verificar que puede firmar certificados de dispositivo con el nuevo certificado de CA.
3. Utilice UpdateCACertificate para marcar el antiguo certificado de CA como INACTIVO en AWS IoT.
También puede utilizar acciones de mitigación para realizar las siguientes acciones:
CONFLICTING_CLIENT_IDS_CHECK
Varios dispositivos se conectan con el mismo ID de cliente.
Gravedad: alta
Detalles
Se han realizado varias conexiones con el mismo ID de cliente, lo que ha provocado la desconexión de un
dispositivo ya conectado. La especificación de MQTT solo permite una conexión activa por ID de cliente,
con lo cual, cuando otro dispositivo se conecta con el mismo ID de cliente, se bloquea la conexión del
dispositivo anterior.
604
Cuando se realiza como parte de una auditoría bajo demanda, esta comprobación analiza cómo se usaban
los ID de cliente utilizados por los dispositivos para conectarse durante los 31 días anteriores al inicio de
la auditoría. Para las auditorías programadas, esta comprobación analiza los datos desde la última vez
que se realizó la auditoría hasta el momento en que comenzó esta instancia de la auditoría. Si ha tomado
medidas para mitigar esta condición durante el periodo de la comprobación, observe cuándo se realizaron
las conexiones/desconexiones para determinar si el problema persiste.
Se devuelven los siguientes códigos de motivo cuando esta comprobación encuentra una falta de
conformidad:
• DUPLICATE_CLIENT_ID_ACROSS_CONNECTIONS
Además, los resultados devueltos con esta comprobación incluyen el ID de cliente utilizado para
conectarse, los identificadores de las entidades principales y los tiempos de desconexión. Se muestran
primero los resultados más recientes.
¿Por qué importa?

Los dispositivos con ID en conflicto se ven obligados a volver a conectarse constantemente, lo que puede
provocar la pérdida de mensajes o la imposibilidad de que el dispositivo se conecte.
Esto puede indicar que un dispositivo o las credenciales de un dispositivo se han puesto en riesgo y
podrían ser parte de un ataque DDoS. También es posible que los dispositivos estén mal configurados
en la cuenta o que el dispositivo tenga una mala conexión y se vea obligado a volver a conectarse varias
veces por minuto.
Cómo solucionarlo
Registre cada dispositivo como un objeto único en AWS IoT y use el nombre de objeto como ID de cliente
para la conexión. O use un UUID como ID de cliente al conectar el dispositivo a través de MQTT. También

DEVICE_CERT_APPROACHING_EXPIRATION_CHECK
Un certificado de dispositivo va a caducar dentro de 30 días o ha caducado.
Gravedad: media
Detalles
Cuando esta comprobación encuentra un certificado de dispositivo no conforme se devuelven los

siguientes códigos de motivo:
• CERTIFICATE_APPROACHING_EXPIRATION
• CERTIFICATE_PAST_EXPIRATION
¿Por qué importa?

Un certificado de dispositivo no debe utilizarse una vez que caduque.
605
Cómo solucionarlo
Consulte las prácticas recomendadas de seguridad para saber cómo proceder. Es posible que desee:
1. Aprovisionar un nuevo certificado y asociarlo al dispositivo.

2. Verificar que el nuevo certificado sea válido y que el dispositivo pueda usarlo para conectarse.
3. Utilice UpdateCertificate para marcar el certificado antiguo como INACTIVO en AWS IoT. También

4. Desvincular el certificado antiguo del dispositivo. (Consulte DetachThingPrincipal.)
REVOKED_DEVICE_CERT_CHECK
Un certificado del dispositivo revocado sigue activo.
Gravedad: media
Detalles
Un certificado de dispositivo no está en la lista de revocación de certificados de CA, pero sigue activo en
AWS IoT.
conformidad:
• CERTIFICATE_REVOKED_BY_ISSUER
¿Por qué importa?

Un certificado de dispositivo generalmente se revoca porque ha sufrido un ataque. Es posible que aún no
se haya revocado en AWS IoT debido a un error o un descuido.
Cómo solucionarlo
Compruebe que el certificado del dispositivo no ha sufrido un ataque. Si ha sido atacado, siga las prácticas
recomendadas de seguridad para mitigar la situación. Es posible que desee:
1. Aprovisionar un nuevo certificado para el dispositivo.

2. Verificar que el nuevo certificado sea válido y que el dispositivo pueda usarlo para conectarse.
606
Cómo realizar auditorías


4. Desvincular el certificado antiguo del dispositivo. (Consulte DetachThingPrincipal.)
LOGGING_DISABLED_CHECK
Los registros de AWS IoT no están habilitados en Amazon CloudWatch.
Gravedad: baja
Detalles
conformidad:
• LOGGING_DISABLED
¿Por qué importa?

Los registros de AWS IoT en CloudWatch proporcionan visibilidad sobre los comportamientos de AWS IoT,
incluidos los errores de autenticación y las desconexiones que podrían indicar que un dispositivo ha sufrido
un ataque.
Cómo solucionarlo
Habilite los registros de AWS IoT en CloudWatch. Consulte Herramientas de monitoreo (p. 213). También
• Aplicar la acción de mitigación ENABLE_IOT_LOGGING en los resultados de la auditoría para realizar

este cambio.

1. Configure los ajustes de auditoría para su cuenta Utilice UpdateAccountAuditConfiguration (p. 614)
para habilitar las comprobaciones que desea que estén disponibles para las auditorías, para
configurar notificaciones opcionales y para configurar permisos.
Para algunas comprobaciones, AWS IoT empieza a recopilar datos en cuanto la comprobación está
habilitada.
2. Cree uno o más calendarios de auditoría. Utilice CreateScheduledAudit (p. 619) para especificar las
comprobaciones que desea realizar durante una auditoría y con qué frecuencia deben ejecutarse.
O bien, puede ejecutar una auditoría bajo demanda cuando sea necesario. Utilice
StartOnDemandAuditTask (p. 627) para especificar las comprobaciones que desea realizar y
comenzar una auditoría de inmediato. (Es posible que los resultados no estén listos por algún tiempo
si ha habilitado recientemente una comprobación que se incluye en la auditoría bajo demanda).
3. Puede usar la consola de AWS IoT para ver los resultados de las auditorías.
607
También puede ver los resultados de las auditorías con ListAuditFindings (p. 635). Con este
comando, puede filtrar los resultados por el tipo de verificación, por el recurso específico o por la hora
de la auditoría. Puede utilizar esta información para mitigar cualquier problema que se encuentre.
4. Puede aplicar las acciones de mitigación que definió en su cuenta de AWS para los resultados
no conformes con las reglas. Para obtener más información, consulte Aplicación de acciones de
mitigación (p. 647).
Notificaciones
Cuando se completa una auditoría, se puede enviar una notificación de SNS con un resumen de los
resultados de cada comprobación de auditoría realizada, incluida la información sobre el número de
recursos no conformes encontrados. Utilice el campo auditNotificationTargetConfigurations
en la entrada al comando UpdateAccountAuditConfiguration (p. 614). La notificación de SNS tiene la
siguiente carga:
Ejemplo de carga
{
"accountId": "123456789012",
"taskId": "4e2bcd1ccbc2a5dd15292a82ab80c380",
"taskStatus": "FAILED|CANCELED|COMPLETED",
"taskType": "ON_DEMAND_AUDIT_TASK|SCHEDULED_AUDIT_TASK",
"scheduledAuditName": "myWeeklyAudit",
"failedChecksCount": 0,
"canceledChecksCount": 0,
"nonCompliantChecksCount": 1,
"compliantChecksCount": 0,
"totalChecksCount": 1,
"taskStartTime": 1524740766191,
"auditDetails": [
{
"checkName": "DEVICE_CERT_APPROACHING_EXPIRATION_CHECK |
REVOKED_DEVICE_CERT_CHECK |
CA_CERT_APPROACHING_EXPIRATION_CHECK |
REVOKED_CA_CERT_CHECK |
DEVICE_CERTIFICATE_SHARED_CHECK |
IOT_POLICY_UNRESTRICTED_CHECK |
UNAUTHENTICATED_COGNITO_IDENTITY_UNRESTRICTED_ACCESS_CHECK |
AUTHENTICATED_COGNITO_IDENTITY_UNRESTRICTED_ACCESS_CHECK |
CONFLICTING_CLIENT_IDS_CHECK |
LOGGING_DISABLED_CHECK",
"checkRunStatus": "FAILED |
CANCELED |
COMPLETED_COMPLIANT |
COMPLETED_NON_COMPLIANT",
"nonCompliantResourcesCount": 1,
"totalResourcesCount": 1,
"message": "optional message if an error occurred",

"errorCode": "INSUFFICIENT_PERMISSIONS|AUDIT_CHECK_DISABLED"
}
]
}
Esquema de JSON de carga
608
"$schema": "http://json-schema.org/draft-07/schema#",
"$id": "arn:aws:iot:::schema:auditnotification/1.0",
"type": "object",
"properties": {
"accountId": {
"type": "string"
},
"taskId": {
"type": "string"
},
"taskStatus": {
"type": "string",
"enum": [
"FAILED",
"CANCELED",
"COMPLETED"
]
},
"taskType": {
"type": "string",
"enum": [
"SCHEDULED_AUDIT_TASK",
"ON_DEMAND_AUDIT_TASK"
]
},
"scheduledAuditName": {
"type": "string"
},
"failedChecksCount": {
"type": "integer"
},
"canceledChecksCount": {
"type": "integer"
},
"nonCompliantChecksCount": {
"type": "integer"
},
"compliantChecksCount": {
"type": "integer"
},
"totalChecksCount": {
"type": "integer"
},
"taskStartTime": {
"type": "integer"
},
"auditDetails": {
"type": "array",
"items": [
{
"type": "object",
"properties": {
"checkName": {
"type": "string",
"enum": [
"DEVICE_CERT_APPROACHING_EXPIRATION_CHECK",
"REVOKED_DEVICE_CERT_CHECK",
"CA_CERT_APPROACHING_EXPIRATION_CHECK",
"REVOKED_CA_CERT_CHECK",
"LOGGING_DISABLED_CHECK"
]
},
"checkRunStatus": {
"type": "string",
"enum": [
"FAILED",
609
"CANCELED",
"COMPLETED_COMPLIANT",
"COMPLETED_NON_COMPLIANT"
]
},
"nonCompliantResourcesCount": {
"type": "integer"
},
"totalResourcesCount": {
"type": "integer"
},
"message": {
"type": "string",
},
"errorCode": {
"type": "string",
"enum": [
"INSUFFICIENT_PERMISSIONS",
"AUDIT_CHECK_DISABLED"
]
}
},
"required": [
"checkName",
"checkRunStatus",
"nonCompliantResourcesCount",
"totalResourcesCount"
]
}
]
}
},
"required": [
"accountId",
"taskId",
"taskStatus",
"taskType",
"failedChecksCount",
"canceledChecksCount",
"nonCompliantChecksCount",
"compliantChecksCount",
"totalChecksCount",
"taskStartTime",
"auditDetails"
]
}
También puede ver las notificaciones en la consola de AWS IoT, junto con información sobre el dispositivo,
las estadísticas del dispositivo (por ejemplo, la hora de la última conexión, el número de conexiones
activas, la velocidad de transferencia de datos) y las alertas históricas del dispositivo.
Permisos
Esta sección contiene información sobre cómo configurar los roles y políticas de IAM necesarios para
crear, ejecutar y administrar las auditorías de AWS IoT Device Defender. Para obtener más información,
consulte la Guía del usuario de &AWS; Identity and Access Management.
Para poder ejecutar una auditoría, conceda a AWS IoT Device Defender permiso
para recopilar datos
Cuando llame a UpdateAccountAuditConfiguration (p. 614) debe especificar un rol de IAM con dos
políticas: una política de permisos y una política de confianza. Cuando se ejecuta una auditoría, la política
610
de permisos concede permiso a AWS IoT Device Defender para obtener acceso a los datos de su cuenta,
utilizando las API de AWS IoT. La política de confianza otorga permiso a AWS IoT Device Defender para
asumir el rol requerido.
Política de permisos
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:GetLoggingOptions",
"iot:GetV2LoggingOptions",
"iot:ListCACertificates",
"iot:ListCertificates",
"iot:DescribeCACertificate",
"iot:DescribeCertificate",
"iot:ListPolicies",
"iot:GetPolicy",
"iot:GetEffectivePolicies",
"iot:ListRoleAliases",
"iot:DescribeRoleAlias",
"cognito-identity:GetIdentityPoolRoles",
"iam:ListRolePolicies",
"iam:ListAttachedRolePolicies",
"iam:GetRole",
"iam:GetPolicy",
"iam:GetPolicyVersion",
"iam:GetRolePolicy",
"iam:GenerateServiceLastAccessedDetails",
"iam:GetServiceLastAccessedDetails"
],
"Resource":[
"*"
]
}
]
}
Política de confianza
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
},
}
]
}
Otorgar permiso a AWS IoT Device Defender para publicar notificaciones en un

tema de SNS.
Si utiliza el parámetro auditNotificationTargetConfigurations en
UpdateAccountAuditConfiguration (p. 614), debe especificar un rol de IAM con dos políticas: una política
611
de permisos y una política de confianza. La política de permisos concede permiso a AWS IoT Device
Defender para publicar notificaciones en su tema de SNS. La política de confianza otorga permiso a AWS
IoT Device Defender para asumir el rol requerido.
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"sns:Publish"
],
"Resource":[
"arn:aws:sns:region:account-id:your-topic-name"
]
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
},
}
]
}
Otorgue permiso a los usuarios o grupos de IAM para ejecutar comandos de

auditoría de AWS IoT Device Defender
Para permitir a los usuarios o grupos de IAM administrar, ejecutar o ver los resultados de las auditorías de
AWS IoT Device Defender, debe crear y asignar roles con políticas asociadas que concedan permiso para
ejecutar los comandos apropiados. El contenido de cada política depende de los comandos que desea que
el usuario o grupo ejecute.
• UpdateAccountAuditConfiguration
Auto Scaling
Debe crear el rol de IAM con la política asociada en la misma cuenta desde la que se ejecuta este
comando. No se permite el acceso entre cuentas. La política debe tener permisos iam:PassRole
(permisos para pasar este rol).
En la siguiente plantilla de política audit-permissions-role-arn es el ARN del rol que pasa a AWS
IoT Device Defender en la solicitud UpdateAccountAuditConfiguration utilizando el parámetro
roleArn. audit-notifications-permissions-role-arn es el ARN del rol que pasa a AWS
IoT Device Defender en la solicitud UpdateAccountAuditConfiguration utilizando el parámetro
auditNotificationTargetConfigurations.
612
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:UpdateAccountAuditConfiguration"
],
"Resource": [
"*"
]
},
{
"Effect": "Allow",
"Action": [
"iam:PassRole"
],
"Resource": [
"arn:aws:iam::account-id:role/audit-permissions-role-arn",
"arn:aws:iam::account-id:role/audit-notifications-permissions-role-arn"
]
}
]
}
• DescribeAccountAuditConfiguration
• DeleteAccountAuditConfiguration
• StartOnDemandAuditTask
• CancelAuditTask
• DescribeAuditTask
• ListAuditTasks
• ListScheduledAudits
• ListAuditFindings
Auto Scaling
Todos estos comandos requieren* en el campo Resource de la política.
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:DescribeAccountAuditConfiguration",
"iot:DeleteAccountAuditConfiguration",
"iot:StartOnDemandAuditTask",
"iot:CancelAuditTask",
"iot:DescribeAuditTask",
"iot:ListAuditTasks",
"iot:ListScheduledAudits",
"iot:ListAuditFindings"
],
"Resource": [
"*"
]
}
]
}
613
Comandos de auditoría
• CreateScheduledAudit
• UpdateScheduledAudit
• DeleteScheduledAudit
• DescribeScheduledAudit
Auto Scaling
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:CreateScheduledAudit",
"iot:UpdateScheduledAudit",
"iot:DeleteScheduledAudit",
"iot:DescribeScheduledAudit"
],
"Resource": [
"arn:aws:iot:region:account-id:scheduledaudit/scheduled-audit-name"
]
}
]
}
El formato del ARN de un rol de auditoría programada de AWS IoT Device Defender es:
arn:aws:iot:region:account-id:scheduledaudit/scheduled-audit-name
Comandos de auditoría
Administrar la configuración de auditorías
Utilice UpdateAccountAuditConfiguration para configurar los ajustes de auditoría de su cuenta Este
comando le permite habilitar las comprobaciones que desea que estén disponibles para las auditorías,
configurar notificaciones opcionales y configurar permisos.
Compruebe esta configuración con DescribeAccountAuditConfiguration.
Utilice DeleteAccountAuditConfiguration para eliminar la configuración de auditoría. Esto restaura

todos los valores predeterminados y desactiva de manera efectiva las auditorías, ya que todas las
comprobaciones están deshabilitadas de manera predeterminada.
UpdateAccountAuditConfiguration
Configura o reconfigura los ajustes de auditoría de Device Defender para esta cuenta. La configuración
incluye cómo se envían las notificaciones de auditoría y qué comprobaciones de auditoría se habilitan o
deshabilitan.
Sinopsis
aws iot update-account-audit-configuration \

[--role-arn <value>] \
[--audit-notification-target-configurations <value>] \
614
[--audit-check-configurations <value>] \
Formato cli-input-json
{
"auditNotificationTargetConfigurations": {
"string": {
"targetArn": "string",
"enabled": "boolean"
}
},
"auditCheckConfigurations": {
"string": {
}
}
}
Campos cli-input-json
roleArn cadena El ARN del rol que concede

permiso a AWS IoT para obtener
Longitud máx.: 2048; mín.: 20 acceso a la información sobre
sus dispositivos, políticas,
certificados y otros elementos al
realizar una auditoría.
auditNotificationTargetConfigurations
map Información sobre los destinos
a los que se envían las
notificaciones de auditoría.
targetArn cadena El ARN del destino (tema SNS) al

que se envían las notificaciones
de auditoría.

permiso para enviar
Longitud máx.: 2048; mín.: 20 notificaciones al destino.
enabled booleano True si se habilitan las

notificaciones al destino.
auditCheckConfigurations map Especifica las comporbaciones

de auditoría habilitadas
y deshabilitadas para
esta cuenta. Utilice
DescribeAccountAuditConfiguration
para ver la lista de todas las
comprobaciones, incluidas las
habilitadas actualmente.
Parte de la recopilación de datos

puede comenzar inmediatamente
cuando se habilitan
615

determinadas comprobaciones.
Cuando se deshabilita una
comprobación, se borran todos
los datos recopilados hasta el
momento relacionados con la
comprobación.
No puede deshabilitar una

comprobación si se utiliza en una
auditoría programada. Primero
debe eliminar la comprobación
de la auditoría programada
o eliminar la propia auditoría
programada.
En la primera llamada a
se necesita este parámetro y
debe especificar al menos una
comprobación habilitada.
enabled booleano True si está habilitada la

comprobación de auditoría para
esta cuenta.
Salida
Ninguna
Errores
El contenido de la solicitud no es válido.

ThrottlingException

InternalFailureException
Se ha producido un error inesperado.
Obtiene información sobre la configuración de auditoría de Device Defender para esta cuenta. La
configuración incluye cómo se envían las notificaciones de auditoría y qué comprobaciones de auditoría se
habilitan o deshabilitan.
Sinopsis
aws iot describe-account-audit-configuration \

616
{
}
Salida
{
"auditNotificationTargetConfigurations": {
"string": {
"targetArn": "string",
}
},
"auditCheckConfigurations": {
"string": {
}
}
}
Campos de salida de la CLI

realizar una auditoría.
En la primera llamada a
UpdateAccountAuditConfiguration,
se necesita este parámetro.
auditNotificationTargetConfigurations
map Información sobre los destinos
a los que se envían las
notificaciones de auditoría para
esta cuenta.
targetArn cadena El ARN del destino (tema SNS) al

que se envían las notificaciones
de auditoría.

permiso para enviar
Longitud máx.: 2048; mín.: 20 notificaciones al destino.
enabled booleano True si se habilitan las

notificaciones al destino.
auditCheckConfigurations map Las verificaciones de auditoría

habilitadas y deshabilitadas para
esta cuenta.
enabled booleano True si está habilitada la

comprobación de auditoría para
esta cuenta.
617
Errores
ThrottlingException

DeleteAccountAuditConfiguration
Restaura la configuración predeterminada para las auditorías de Device Defender para esta cuenta. Se
eliminarán todos los datos de configuración que haya introducido y todas las comprobaciones de auditoría
se restablecerán como deshabilitadas.
Sinopsis
aws iot delete-account-audit-configuration \

[--delete-scheduled-audits | --no-delete-scheduled-audits] \
{
"deleteScheduledAudits": "boolean"
}
deleteScheduledAudits booleano Si es true, se eliminan todas las

auditorías programadas.
Salida
Ninguna
Errores


ThrottlingException

618
Programación de auditorías
Utilice CreateScheduledAudit para crear una o varias auditorías programadas. Este comando permite
especificar las comprobaciones que desea realizar durante una auditoría y con qué frecuencia deben
ejecutarse.
Mantenga un registro de sus auditorías programadas con ListScheduledAudits y

DescribeScheduledAudit.
Cambie una auditoría programada existente con UpdateScheduledAudit o elimínela con

DeleteScheduledAudit.
CreateScheduledAudit
Crea una auditoría programada que se ejecuta en un intervalo de tiempo específico.
Sinopsis
aws iot create-scheduled-audit \

--frequency <value> \
[--day-of-month <value>] \
[--day-of-week <value>] \
--target-check-names <value> \
[--tags <value>] \
--scheduled-audit-name <value> \
{
"frequency": "string",
"dayOfMonth": "string",
"dayOfWeek": "string",
"targetCheckNames": [
"string"
],
"tags": [
{
"Key": "string",
"Value": "string"
}
],
"scheduledAuditName": "string"
}
frequency cadena Frecuencia con la que se lleva

a cabo la auditoría. Puede ser
DAILY, WEEKLY, BIWEEKLY o
MONTHLY. El sistema determina
la hora de inicio real de cada
auditoría.
enum: DAILY | WEEKLY |

BIWEEKLY | MONTHLY
619
dayOfMonth cadena El día del mes en que tiene

lugar la auditoría programada.
patrón: ^([1-9]|[12][0-9]|3[01])$| Puede ser de 1 a 31 o LAST.
^LAST$ Este campo es obligatorio si
el parámetro frequency se
establece en MONTHLY. Si se
especifican los días 29-31 y
el mes no tiene tantos días, la
auditoría se realizará el último
(LAST) día del mes.
dayOfWeek cadena El día de la semana en

que tiene lugar la auditoría
programada. Puede ser SUN,
MON, TUE,WED, THU, FRI o
SAT. Este campo es obligatorio
si el parámetro frequency
se establece en WEEKLY o
BIWEEKLY.
enum: SUN | MON | TUE | WED |

THU | FRI | SAT
targetCheckNames lista Controles que se realizan

durante la auditoría programada.
miembro: AuditCheckName Las comprobaciones deben
activarse para su cuenta. (Utilice
para ver la lista de todas
las comprobaciones,
incluidas las habilitadas o
para seleccionar las
comprobaciones habilitadas).
tags lista Los metadatos que se pueden

utilizar para administrar la
member: Tag auditoría programada.
clase de Java: java.util.List
Clave cadena La clave de la etiqueta.
Valor cadena El valor de la etiqueta.
scheduledAuditName cadena El nombre que desea asignar a la

auditoría programada. (Máximo
Longitud máx.: 128; mín.: 1 de 128 caracteres)
Salida
{
"scheduledAuditArn": "string"
}
620
scheduledAuditArn cadena El ARN de la auditoría

programada.
Errores

ThrottlingException


LimitExceededException
Se ha superado un límite.
ListScheduledAudits
Muestra una lista de las auditorías programadas.
Sinopsis
aws iot list-scheduled-audits \

{
"maxResults": "integer"
}
nextToken cadena El token del conjunto siguiente de

resultados.
maxResults entero El número máximo de resultados

que devolver a la vez. El valor
Rango máx.: 250; mín.: 1 predeterminado es 25.
Salida
621
"scheduledAudits": [
{
"scheduledAuditName": "string",
"scheduledAuditArn": "string",
"dayOfWeek": "string"
}
],
}
scheduledAudits lista La lista de auditorías

programadas.
miembro:
ScheduledAuditMetadata
scheduledAuditName cadena El nombre de la auditoría

programada.

programada.
frequency cadena Frecuencia con la que se lleva a

cabo la auditoría.

BIWEEKLY | MONTHLY
dayOfMonth cadena El día del mes en que se ejecuta

la auditoría programada (si
patrón: ^([1-9]|[12][0-9]|3[01])$| frequency es MONTHLY). Si
^LAST$ se especifican los días 29-31 y
dayOfWeek cadena El día de la semana en que se

ejecuta la auditoría programada
(si frequency es WEEKLY o
BIWEEKLY).

THU | FRI | SAT
nextToken string Un token que se puede utilizar

para recuperar el siguiente
conjunto de resultados o null si
Errores
622

ThrottlingException

DescribeScheduledAudit
Obtiene información acerca de la auditoría programada.
Sinopsis
aws iot describe-scheduled-audit \

{
}

programada cuya información
Longitud máx.: 128; mín.: 1 desea obtener.
Salida
{
"string"
],
}

a cabo la auditoría. Uno entre
623

auditoría.

BIWEEKLY | MONTHLY

patrón: ^([1-9]|[12][0-9]|3[01])$| Puede ser de 1 a 31 o LAST. Si
^LAST$ se especifican los días 29-31 y
dayOfWeek cadena El día de la semana en que tiene

Uno entre SUN, MON, TUE,
WED, THU, FRI o SAT.

THU | FRI | SAT

las comprobaciones,

programada.

programada.
Errores


ThrottlingException
624
UpdateScheduledAudit
Actualiza una auditoría programada, que incluye las comprobaciones que se realizan y con qué frecuencia
se lleva a cabo la auditoría.
Sinopsis
aws iot update-scheduled-audit \

[--frequency <value>] \
[--day-of-month <value>] \
[--day-of-week <value>] \
[--target-check-names <value>] \
{
"string"
],
}

a cabo la auditoría. Puede ser
auditoría.

BIWEEKLY | MONTHLY

patrón: ^([1-9]|[12][0-9]|3[01])$| Puede ser de 1 a 31 o LAST.
^LAST$ Este campo es obligatorio si
el parámetro frequency se
establece en MONTHLY. Si se
especifican los días 29-31 y
dayOfWeek cadena El día de la semana en

que tiene lugar la auditoría
625

programada. Puede ser SUN,
MON, TUE,WED, THU, FRI o
SAT. Este campo es obligatorio
si el parámetro frequency
se establece en WEEKLY o
BIWEEKLY.

THU | FRI | SAT

las comprobaciones,

programada. (Máximo de 128
Longitud máx.: 128; mín.: 1 caracteres)
Salida
{
}

programada.
Errores


ThrottlingException

626
Ejecutar una auditoría bajo demanda
DeleteScheduledAudit
Elimina una auditoría programada.
Sinopsis
aws iot delete-scheduled-audit \

{
}

programada que desea borrar.
Salida
Ninguna
Errores


ThrottlingException


Utilice StartOnDemandAuditTask para especificar las comprobaciones que desea realizar y comenzar
una auditoría de inmediato.
StartOnDemandAuditTask
Comienza una auditoría de Device Defender bajo demanda.
Sinopsis
627
aws iot start-on-demand-audit-task \

--target-check-names <value> \
{
"string"
]
}

durante la auditoría. Las
miembro: AuditCheckName comprobaciones que especifique
deben estar habilitadas para
su cuenta o se producirá
una excepción. Utilice
las comprobaciones,
comprobaciones habilitadas.
Salida
{
"taskId": "string"
}
taskId cadena El ID de la auditoría bajo

demanda que comenzó.
Errores

ThrottlingException
628
Administrar instancias de auditoría

Se ha superado un límite.

Utilice DescribeAuditTask para obtener información sobre una instancia de auditoría específica. Si
ya se ha ejecutado, los resultados incluyen las comprobaciones fallidas y las correctas, aquellas que
el sistema no ha podido completar y, si la auditoría aún está en curso, aquellas en las que todavía está
trabajando.
Utilice ListAuditTasks para buscar las auditorías que se ejecutaron durante un intervalo de tiempo
específico.
Utilice CancelAuditTask para parar una auditoría en curso.
DescribeAuditTask
Obtiene información sobre una auditoría de Device Defender.
Sinopsis
aws iot describe-audit-task \

--task-id <value> \
{
"taskId": "string"
}
taskId cadena El ID de la auditoría cuya

información desea obtener.
Salida
{
"taskStatus": "string",
"taskType": "string",
"taskStartTime": "timestamp",
"taskStatistics": {
"totalChecks": "integer",
"inProgressChecks": "integer",
"waitingForDataCollectionChecks": "integer",
"compliantChecks": "integer",
"nonCompliantChecks": "integer",
629
"failedChecks": "integer",
"canceledChecks": "integer"
},
"auditDetails": {
"string": {
"checkRunStatus": "string",
"checkCompliant": "boolean",
"totalResourcesCount": "long",
"nonCompliantResourcesCount": "long",
"message": "string"
}
}
}
taskStatus cadena El estado de la auditoría:

uno entre IN_PROGRESS,
COMPLETED, FAILED o
CANCELED.
enum: IN_PROGRESS |
COMPLETED | FAILED |
CANCELED
taskType cadena El tipo de auditoría:

ON_DEMAND_AUDIT_TASK r
SCHEDULED_AUDIT_TASK.
enum:
ON_DEMAND_AUDIT_TASK |
SCHEDULED_AUDIT_TASK
taskStartTime timestamp La hora a la que se inició la

auditoría.
taskStatistics TaskStatistics Información estadística sobre la

auditoría.
totalChecks entero El número de comprobaciones de

esta auditoría.
inProgressChecks entero El número de comprobaciones en

curso.
waitingForDataCollectionChecks entero El número de comprobaciones en

espera de recopilación de datos.
compliantChecks entero El número de comprobaciones

que encontraron recursos
conformes.
nonCompliantChecks entero El número de comprobaciones

que encontraron recursos no
conformes.
failedChecks entero El número de comprobaciones.
630
canceledChecks entero El número de comprobaciones

no ejecutadas debido a la
cancelación de la auditoría.

programada (solo si la auditoría
Longitud máx.: 128; mín.: 1 era una auditoría programada).
auditDetails map Información detallada sobre cada

comprobación realizada durante
esta auditoría.
checkRunStatus cadena El estado de finalización

de esta comprobación,
una entre IN_PROGRESS,
WAITING_FOR_DATA_COLLECTION,
CANCELED,
COMPLETED_COMPLIANT,
COMPLETED_NON_COMPLIANT
o FAILED.
enum: IN_PROGRESS |
WAITING_FOR_DATA_COLLECTION
| CANCELED |
COMPLETED_COMPLIANT |
COMPLETED_NON_COMPLIANT
| FAILED
checkCompliant booleano True si se ha completado la

comprobación y se ha detectado
que todos los recursos son
conformes.
totalResourcesCount long El número de recursos en los que

se ha realizado la comprobación.
nonCompliantResourcesCount long El número de recursos que la

comprobación ha encontrado que
no son conformes.
errorCode cadena El código de cualquier error

encontrado al realizar esta
comprobación durante
esta auditoría. Uno entre
INSUFFICIENT_PERMISSIONS
o AUDIT_CHECK_DISABLED.
message cadena El mensaje asociado con

cualquier error encontrado al
Longitud máx.: 2048 realizar esta comprobación
durante esta auditoría.
Errores
631


ThrottlingException

ListAuditTasks
Enumera las auditorías de Device Defender que se han realizado durante un periodo de tiempo
determinado.
Sinopsis
aws iot list-audit-tasks \

--start-time <value> \
--end-time <value> \
[--task-type <value>] \
[--task-status <value>] \
{
"startTime": "timestamp",
"endTime": "timestamp",
"taskType": "string",
}
startTime timestamp El comienzo del periodo de

tiempo. La información de
auditoría se conserva durante
un tiempo limitado (180 días).
Si se solicita una hora de inicio
anterior al tiempo de retención,
se produce la excepción
InvalidRequestException.
endTime timestamp El final del periodo de tiempo.
632
taskType cadena Un filtro para limitar el resultado

al tipo de auditoría especificado:
puede ser uno entre
ON_DEMAND_AUDIT_TASK o
SCHEDULED__AUDIT_TASK.
enum:
taskStatus cadena Un filtro para limitar el resultado

a las auditorías con el estado de
finalización especificado: puede
ser uno entre IN_PROGRESS,
COMPLETED, FAILED o
CANCELED.
enum: IN_PROGRESS |
CANCELED

resultados.

Salida
{
"tasks": [
{
"taskId": "string",
"taskType": "string"
}
],
}
tareas lista Las auditorías que se realizaron

durante el periodo de tiempo
miembro: AuditTaskMetadata especificado.
taskId cadena El ID de esta auditoría.
633
taskStatus cadena El estado de esta auditoría:

uno entre IN_PROGRESS,
COMPLETED, FAILED o
CANCELED.
enum: IN_PROGRESS |
CANCELED
taskType cadena El tipo de esta

auditoría: uno entre
ON_DEMAND_AUDIT_TASK o
SCHEDULED_AUDIT_TASK.
enum:
nextToken cadena Un token que se puede utilizar

Errores

ThrottlingException

CancelAuditTask
Cancela una auditoría que está en curso. La auditoría puede ser programada o bajo demanda. Si la
auditoría no está en curso, se produce la excepción InvalidRequestException.
Sinopsis
aws iot cancel-audit-task \

--task-id <value> \
{
"taskId": "string"
}
634
Comprobar resultados de auditoría
taskId cadena ID de la auditoría que desea

cancelar. Solo puede cancelar
Longitud máx.: 40; mín.: 1 una auditoría que esté
IN_PROGRESS.
Salida
Ninguna
Errores


ThrottlingException


Utilice ListAuditFindings para ver los resultados de una auditoría. Puede filtrar los resultados por el
tipo de comporbación, por recurso específico o por la hora de la auditoría. Puede utilizar esta información
para mitigar cualquier problema que se encuentre.
Puede definir acciones de mitigación y aplicarlas a los resultados de su auditoría. Para obtener más
información, consulte Acciones de mitigación (p. 641).
ListAuditFindings
Enumera los hallazgos (resultados) de una auditoría de Device Defender o de las auditorías realizadas
durante un periodo de tiempo especificado. (Los hallazgos se conservan durante 180 días).
Sinopsis
aws iot list-audit-findings \

[--task-id <value>] \
[--check-name <value>] \
[--resource-identifier <value>] \
[--start-time <value>] \
[--end-time <value>] \
635
{
"taskId": "string",
"checkName": "string",
"resourceIdentifier": {
"deviceCertificateId": "string",
"caCertificateId": "string",
"cognitoIdentityPoolId": "string",
"clientId": "string",
"policyVersionIdentifier": {
"policyName": "string",
"policyVersionId": "string"
},
"roleAliasArn": "string",
"account": "string"
},
"endTime": "timestamp"
}
taskId cadena Un filtro para limitar los

resultados a la auditoría que
Longitud máx.: 40; mín.: 1 tiene el ID especificado. Debe
especificar taskId o startTime y
Patrón: [a-zA-Z0-9-]+ endTime, pero no ambos.
checkName cadena Un filtro para limitar los

resultados a los hallazgos de
la verificación de auditoría
especificada.
resourceIdentifier ResourceIdentifier La información que identifica el

recurso no conforme.
deviceCertificateId cadena El ID del certificado asociado al

recurso.
Patrón: (0x)?[a-fA-F0-9]+
caCertificateId cadena El ID del certificado de CA

utilizado para autorizar el
Longitud máx.: 64; mín.: 64 certificado.
cognitoIdentityPoolId cadena El ID del grupo de identidades de

Amazon Cognito.
clientId cadena El ID de cliente.
policyVersionIdentifier PolicyVersionIdentifier La versión de la política asociada

a este recurso.
636
policyName cadena El nombre de la política.
patrón: [w+=,.@-]+
policyVersionId cadena El ID de la versión de la política

asociada a este recurso.
Patrón: [0-9]+
roleAliasArn string El ARN del alias de rol que

tiene acciones excesivamente
permisivas.
Longitud: máx.: 2048; mín.: 1
account cadena La cuenta a la que está asociado

el recurso.
Patrón: [0-9]+


resultados.
startTime timestamp Un filtro para limitar los

resultados a los encontrados
después de la hora especificada.
Debe especificar startTime
y endTime o taskId, pero no
ambos.
endTime timestamp Un filtro para limitar los

resultados a los encontrados
antes de la hora especificada.
Debe especificar startTime
y endTime o taskId, pero no
ambos.
Salida
{
"findings": [
{
"taskId": "string",
"checkName": "string",
"taskStartTime": "timestamp",
"findingTime": "timestamp",
"severity": "string",
"nonCompliantResource": {
"resourceType": "string",
637
},
"account": "string"
},
"additionalInfo": {
"string": "string"
}
},
"relatedResources": [
{
"resourceType": "string",
"iamRoleArn": "string",
},
"account": "string"
},
"roleAliasArn": "string",
"additionalInfo": {
"string": "string"
}
}
],
"reasonForNonCompliance": "string",
"reasonForNonComplianceCode": "string"
}
],
}
findings lista Los hallazgos (resultados) de la

auditoría.
miembro: AuditFinding
taskId cadena El ID de la auditoría que generó

este resultado (hallazgo).
checkName cadena La comprobación de auditoría

que generó este resultado.
taskStartTime timestamp La hora a la que se inició la

auditoría.
638
findingTime timestamp La hora a la que se descubrió el

resultado (hallazgo).
severity cadena La gravedad del resultado

(hallazgo).
enum: CRÍTICA | ALTA | MEDIA

| BAJA
nonCompliantResource NonCompliantResource El recurso que se ha

comprobado que no cumple los
requisitos de una comprobación
de auditoría.
resourceType cadena El tipo del recurso no conforme.
enum: DEVICE_CERTIFICATE
| CA_CERTIFICATE
| IOT_POLICY |
COGNITO_IDENTITY_POOL
| CLIENT_ID |
ACCOUNT_SETTINGS
resourceIdentifier ResourceIdentifier La información que identifica el

recurso no conforme.

recurso.


Amazon Cognito.

a este recurso.
patrón: [w+=,.@-]+

Patrón: [0-9]+
639

el recurso.
Patrón: [0-9]+
additionalInfo map Otra información sobre el recurso

no conforme.
relatedResources lista La lista de recursos relacionados.
miembro: RelatedResource
resourceType cadena El tipo de recurso.
enum: DEVICE_CERTIFICATE
| CA_CERTIFICATE
| IOT_POLICY |
COGNITO_IDENTITY_POOL
| CLIENT_ID |
ACCOUNT_SETTINGS
resourceIdentifier ResourceIdentifier Información que identifica el

recurso.

recurso.


Amazon Cognito.

a este recurso.
iamRoleArn string El ARN del rol de IAM que

Longitud máx.: 2048; mín.: 20 permisivas.
patrón: [w+=,.@-]+

Patrón: [0-9]+
640
Acciones de mitigación
roleAliasArn string El ARN del alias de rol que

Longitud: máx.: 2048; mín.: 1 permisivas.

el recurso.
Patrón: [0-9]+
additionalInfo map Otra información sobre el

recurso.
reasonForNonCompliance cadena El motivo por el que el recurso no

era conforme.
reasonForNonComplianceCode cadena Un código que indica el motivo

por el cual el recurso no era
conforme.
nextToken cadena Un token que se puede utilizar

Errores

ThrottlingException

Puede utilizar AWS IoT Device Defender para emprender acciones para mitigar los problemas que se
encontraron durante una auditoría. AWS IoT Device Defender proporciona acciones predefinidas para
las diferentes comprobaciones de auditoría. Puede configurar esas acciones para su cuenta de AWS y, a
continuación, aplicarlas a un conjunto de resultados. Estos resultados puede ser:
• Todos los resultados de una auditoría. Esta opción está disponible en la consola de AWS IoT y a través
de la AWS CLI.
• Una lista de resultados individuales. Esta opción solo está disponible a través de la AWS CLI
• Un conjunto filtrado de los resultados de una auditoría.
En la siguiente tabla se muestran los tipos de las comprobaciones de auditoría y las acciones de mitigación
compatibles para cada una de ellas:
641
Comprobación de auditoría y acción de mitigación
Comprobación de auditoría Acciones de mitigación admitidas
REVOKED_CA_CERT_CHECK PUBLISH_FINDING_TO_SNS,
UPDATE_CA_CERTIFICATE
DEVICE_CERTIFICATE_SHARED_CHECK PUBLISH_FINDING_TO_SNS,
UPDATE_DEVICE_CERTIFICATE,
ADD_THINGS_TO_THING_GROUP
PUBLISH_FINDING_TO_SNS
IOT_POLICY_OVERLY_PERMISSIVE_CHECK PUBLISH_FINDING_TO_SNS,
REPLACE_DEFAULT_POLICY_VERSION
CA_CERT_APPROACHING_EXPIRATION_CHECK PUBLISH_FINDING_TO_SNS,
CONFLICTING_CLIENT_IDS_CHECK PUBLISH_FINDING_TO_SNS
PUBLISH_FINDING_TO_SNS,
REVOKED_DEVICE_CERT_CHECK PUBLISH_FINDING_TO_SNS,
LOGGING_DISABLED_CHECK PUBLISH_FINDING_TO_SNS,
ENABLE_IOT_LOGGING
DEVICE_CERTIFICATE_KEY_QUALITY_CHECK PUBLISH_FINDING_TO_SNS,
CA_CERTIFICATE_KEY_QUALITY_CHECK PUBLISH_FINDING_TO_SNS,
IOT_ROLE_ALIAS_OVERLY_PERMISSIVE_CHECK PUBLISH_FINDING_TO_SNS
IOT_ROLE_ALIAS_ALLOWS_ACCESS_TO_UNUSED_SERVICES_CHECK
Todas las comprobaciones de auditoría admiten la publicación de los resultados de la auditoría en

Amazon SNS para que pueda tomar acciones personalizadas en respuesta a la notificación. Cada tipo de
comprobación de auditoría puede admitir acciones de mitigación adicionales:
REVOKED_CA_CERT_CHECK
• Cambiar el estado del certificado para marcarlo como inactivo en AWS IoT.
DEVICE_CERTIFICATE_SHARED_CHECK
• Cambiar el estado del certificado del dispositivo para marcarlo como inactivo en AWS IoT.
• Añadir dispositivos que utilizan dicho certificado a un grupo de objetos.
• No se admiten otras acciones.
642
IOT_POLICY_OVERLY_PERMISSIVE_CHECK
• Añadir una versión de política de AWS IoT en blanco para restringir los permisos.
CA_CERT_APPROACHING_EXPIRATION_CHECK
CONFLICTING_CLIENT_IDS_CHECK
DEVICE_CERTIFICATE_KEY_QUALITY_CHECK
CA_CERTIFICATE_KEY_QUALITY_CHECK
REVOKED_DEVICE_CERT_CHECK
LOGGING_DISABLED_CHECK
• Habilitar el registro.
AWS IoT Device Defender admite los siguientes tipos de acciones de mitigación:
Tipo de acción Notas
ADD_THINGS_TO_THING_GROUP Debe especificar el grupo a la que desea añadir

los dispositivos. También debe especificar si la
suscripción a uno o varios grupos dinámicos debe
anularse si se supera el número máximo de grupos
a los que el objeto puede pertenecer.
ENABLE_IOT_LOGGING Debe especificar el nivel de registro y el rol con

permisos para el registro. No puede especificar un
nivel de registro DISABLED.
PUBLISH_FINDING_TO_SNS Debe especificar el tema en el que se debe

publicar la búsqueda.
REPLACE_DEFAULT_POLICY_VERSION Debe especificar el nombre de la plantilla.

Sustituye la versión de la política predeterminada
con una política en blanco. En este momento solo
es compatible un valor de BLANK_POLICY.
UPDATE_CA_CERTIFICATE Debe especificar el nuevo estado para el

certificado de CA. En este momento solo es
compatible un valor de DEACTIVATE.
UPDATE_DEVICE_CERTIFICATE Debe especificar el nuevo estado para el

certificado del dispositivo. En este momento solo
es compatible un valor de DEACTIVATE.
643
Cómo definir y administrar las acciones de mitigación
Al configurar acciones estándar para los problemas encontrados durante una auditoría, puede responder
a estos problemas de forma coherente. Utilizar estas acciones de mitigación definidas también le ayuda a
resolver los problemas con mayor rapidez y con menos posibilidad de que se produzcan errores.
Important
La aplicación de acciones de mitigación que cambian los certificados, añaden objetos a un

nuevo grupo de objetos o sustituyen la política puede tener un impacto en sus dispositivos y
aplicaciones. Por ejemplo, es posible que los dispositivos no puedan conectarse. Tenga en cuenta
las implicaciones de las acciones de mitigación antes de aplicarlas. Es posible que tenga que
adoptar otras medidas para corregir problemas antes de que los dispositivos y las aplicaciones
puedan funcionar con normalidad. Por ejemplo, es posible que tenga que proporcionar certificados
de dispositivo actualizados. Las acciones de mitigación pueden ayudarle a limitar rápidamente los
riesgos pero, aún así, tiene que tomar medidas correctoras para resolver los problemas.
Algunas acciones, como, por ejemplo, reactivar un certificado de dispositivo, solo se pueden realizar
manualmente. AWS IoT Device Defender no proporciona un mecanismo para revertir automáticamente las
acciones de mitigación que se han aplicado.

Puede utilizar la AWS CLI o la consola de AWS IoT para definir y administrar acciones de mitigación para
su cuenta de AWS.
Creación de acciones de mitigación

Cada acción de mitigación que defina es una combinación de un tipo de acción predefinida y los
parámetros específicos de su cuenta.
Para utilizar la consola de AWS IoT para crear acciones de mitigación

2. En el panel de navegación de la izquierda, seleccione Defender y, a continuación, elija Mitigation
Actions (Acciones de mitigación).
3. En la página Mitigation Actions (Acciones de mitigación), elija Create (Crear).
4. En la página Create a Mitigation Action (Crear una acción de mitigación), en Action name (Nombre de
la acción), escriba un nombre único para la acción de mitigación.
5. En Action type (Tipo de acción), especifique el tipo de acción que desea definir.
644
6. Cada tipo de acción solicita un conjunto diferente de parámetros. Escriba los parámetros de la acción.
Por ejemplo, si elige el tipo de acción Añadir objetos al grupo de objetos, debe elegir el grupo de
destino y seleccionar o quitar la marca de verificación de Override dynamic groups (Anular grupos
dinámicos).
7. En Action execution role (Rol de ejecución de la acción), elija el rol bajo cuyos permisos se aplica la
acción.
8. Elija Guardar para guardar la acción de mitigación en su cuenta de AWS.
Para utilizar la AWS CLI para crear acciones de mitigación
• Utilice el comando CreateMitigationAction (p. 656) para crear la acción de mitigación. El nombre
único que dé a la acción se utiliza cuando se aplica dicha acción a los resultados de la auditoría. Elija
un nombre significativo.
Para utilizar la consola de AWS IoT para ver y modificar las acciones de mitigación

La página Mitigation Actions (Acciones de mitigación) muestra una lista de todas las acciones de
mitigación definidas para su cuenta de AWS.
3. Elija el enlace del nombre de la acción de la acción de mitigación que desea cambiar.
4. Realice los cambios que desee en la acción de mitigación. Como el nombre de la acción de mitigación
se utiliza para identificarla, no puede cambiar el nombre.
645
5. Elija Guardar para guardar los cambios en la acción de mitigación en su cuenta de AWS.
Para utilizar la AWS CLI para obtener una lista de acciones de mitigación
• Utilice el comando ListMitigationActions (p. 663) para mostrar las acciones de mitigación. Si desea
cambiar o eliminar una acción de mitigación, anote del nombre.
Para utilizar la AWS CLI para actualizar una acción de mitigación
• Utilice el comando UpdateMitigationAction (p. 660) para cambiar la acción de mitigación.
Para utilizar la consola de AWS IoT para eliminar una acción de mitigación

La página Mitigation Actions (Acciones de mitigación) muestra todas las acciones de mitigación
definidas para su cuenta de AWS.
3. Elija los puntos suspensivos (...) para la acción de mitigación que desea eliminar y, a continuación,
haga clic en Eliminar.
646
Aplicación de acciones de mitigación
Para utilizar la AWS CLI para eliminar acciones de mitigación
• Utilice el comando UpdateMitigationAction (p. 660) para cambiar la acción de mitigación.
Para utilizar la consola de AWS IoT para ver los detalles de una acción de mitigación

La página Mitigation Actions (Acciones de mitigación) muestra todas las acciones de mitigación
definidas para su cuenta de AWS.
3. Elija el enlace del nombre de la acción de la acción de mitigación que desea cambiar.
4. En la ventana Are you sure you want to delete the mitigation action (¿Seguro que desea eliminar la
acción de mitigación?), elija Confirm (Confirmar).
Para utilizar la AWS CLI para ver los detalles de una acción de mitigación
• Utilice el comando DescribeMitigationAction (p. 665) para ver los detalles de su acción de mitigación.

Después de haber definido un conjunto de acciones de mitigación, puede aplicar esas acciones a los
resultados de una auditoría. Cuando se aplican acciones, empieza una tarea de acciones de mitigación de
auditoría. Esta tarea podría tardar un tiempo en completarse, en función del conjunto de resultados y las
647
acciones que se aplican a ellos. Por ejemplo, si tiene un gran grupo de dispositivos cuyos certificados han
caducado, puede tardar algún tiempo en desactivar todos estos certificados o en mover esos dispositivos a
un grupo de cuarentena. Otras acciones, como la habilitación del registro, se pueden realizar con rapidez.
Puede ver la lista de ejecuciones de acciones y cancelar una ejecución que aún no se ha completado.
Las acciones ya realizadas como parte de la ejecución de la acción cancelada no se revierten. Si está
aplicando varias acciones a un conjunto de resultados y una de esas acciones produce un error, se omiten
la acciones posteriores para ese resultado (pero se siguen aplicado a otros resultados). El estado de la
tarea para el el resultado es FAILED. El taskStatus se establece como error (Failed) si una o varias
de las acciones fracasan cuando se aplican a los resultados. Las acciones se aplican en el orden en que
estén especificadas.
Cada ejecución de acción aplica a un conjunto de acciones a un destino. Ese destino puede ser una lista
de resultados o puede ser todos los resultados de una auditoría.
En el siguiente diagrama se muestra cómo puede definir una tarea de mitigación de auditoría para que
tome todos los resultados de una auditoría y les aplique un conjunto de acciones. Una única ejecución
aplica una acción a un resultado. La tarea de acciones de mitigación de auditoría genera un resumen de
ejecución.
648
En el siguiente diagrama se muestra cómo puede definir una tarea de mitigación de auditoría para que
tome una lista de resultados individuales de una o varias auditorías y les aplique un conjunto de acciones.
Una única ejecución aplica una acción a un resultado. La tarea de acciones de mitigación de auditoría
genera un resumen de ejecución.
Puede utilizar la AWS CLI o la consola de AWS IoT para aplicar acciones de mitigación.
Para usar la consola AWS IoT para aplicar acciones de mitigación iniciando la ejecución de una
acción

2. En el panel de navegación de la izquierda, seleccione Defender, elija Auditoría y, a continuación, elija
Resultados.
649
3. Elija el nombre de la auditoría a la que desea aplicar acciones.
4. Selec Start Mitigation Actions (Iniciar acciones de mitigación). Este botón no está disponible si todos
las comprobaciones son correctas.
5. En Are you sure that you want to start mitigation action task (¿Seguro que desea iniciar la tarea de
acción de mitigación?), el nombre de la tarea toma de forma predeterminada el ID de la auditoría, pero
puede cambiarlo a algo más significativo.
6. Para cada tipo de comprobación que tenga uno o varios resultados no conformes en la auditoría,
puede elegir una o más acciones para aplicar. Solo se muestran las acciones que son válidas para el
tipo de comprobación.
Note
Si no ha configurado las acciones para su cuenta de AWS, la lista de acciones está vacía.
Puede elegir el enlace click here (haga clic aquí) para crear una o varias acciones de
mitigación.
7. Cuando haya especificado todas las acciones que se van a aplicar, seleccione Confirm (Confirmar).
650
Para usar la AWS CLI para aplicar acciones de mitigación iniciando la ejecución de una acción de
mitigación de auditoría
1. Si desea aplicar acciones a todos los resultados de la auditoría, utilice el comando

ListAuditTasks (p. 632) para encontrar el ID de la tarea.
2. Si desea aplicar acciones solo a resultados seleccionados, utilice el comando
ListAuditFindings (p. 635) para obtener los ID de los resultados.
3. Utilice el comando ListMitigationActions (p. 663) y anote los nombres de las acciones de mitigación
que se van a aplicar.
4. Utilice el comando StartAuditMitigationActionsTask (p. 670) para aplicar las acciones al destino.
Anote el ID de la tarea. Puede utilizar el ID para comprobar el estado de la ejecución de la acción,
revisar los detalles o cancelarla.
Para utilizar la consola de AWS IoT para ver sus ejecuciones de acciones

2. En el panel de navegación de la izquierda, seleccione Defender y, a continuación, elija Action
Executions (Ejecuciones de acciones).
Una lista de tareas de acción muestra cuando cada se inició cada una y su estado actual.
3. Elija el enlace Name (Nombre) para ver los detalles de la tarea. Los detalles incluyen todas las
acciones que aplica la tarea, su destino y su estado.
Puede utilizar los filtros Show executions for (Mostrar ejecuciones para) en tipo de acciones o estados
de acción.
651
Permisos
4. Para ver los detalles de la tarea, en Executions (Ejecuciones), elija Show (Mostrar).
Para utilizar la AWS CLI para mostrar una lista de tareas iniciadas
1. Use ListAuditMitigationActionsTasks (p. 677) para ver las tareas de acciones de mitigación de
auditoría. Puede proporcionar filtros para limitar los resultados. Si desea ver los detalles de la tarea,
anote el ID de la tarea.
2. Utilice ListAuditMitigationActionsExecutions (p. 674) para ver los detalles de ejecución de una tarea
de acciones de mitigación de auditoría en particular.
3. Use DescribeAuditMitigationActionsTask (p. 680) para ver los detalles de la tarea, como los
parámetros especificados cuando se inició la tarea.
Para utilizar la AWS CLI para cancelar una tarea de acciones de mitigación de auditoría en
ejecución
1. Utilice el comando ListAuditMitigationActionsTasks (p. 677) para encontrar el ID de la tarea cuya

ejecución desea cancelar. Puede proporcionar filtros para limitar los resultados.
2. Utilice el comando CancelAuditMitigationActionsTask (p. 673), utilizando el ID de la tarea, para
cancelar una tarea de acciones de mitigación. No es posible cancelar tareas que se han completado.
Cuando se cancela una tarea, las acciones restantes no se aplican, pero las acciones de mitigación
que ya se han aplicado no se revierten.
Permisos
Para cada acción de mitigación que defina, debe proporcionar el rol utilizado para aplicar dicha acción.
Permisos para acciones de mitigación
Tipo de acción Plantilla de política de permisos
UPDATE_DEVICE_CERTIFICATE
{
652
Permisos

"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:UpdateCertificate"
],
"Resource":[
"*"
]
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:UpdateCACertificate"
],
"Resource":[
"*"
]
}
]
}
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:ListPrincipalThings",
"iot:AddThingToThingGroup"
],
"Resource":[
"*"
]
}
]
}
653
Permisos
REPLACE_DEFAULT_POLICY_VERSION
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:CreatePolicyVersion"
],
"Resource":[
"*"
]
}
]
}
ENABLE_IOT_LOGGING
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"iot:SetV2LoggingOptions"
],
"Resource":[
"*"
]
},
{
"Effect":"Allow",
"Action":[
"iam:PassRole"
],
"Resource":[
"<IAM role
ARN used for setting up
logging>"
]
}
]
}
654
Comandos de las acciones de mitigación
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"sns:Publish"
],
"Resource":[
"<The SNS
topic to which the finding
is published>"
]
}
]
}
Para todos los tipos de acciones de mitigación, utilice la siguiente plantilla de política de confianza:
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
},
}
]
}

Puede utilizar estos comandos de acciones de mitigación para definir un conjunto de acciones para su
cuenta de AWS que más tarde se pueden aplicar a uno o más conjuntos de resultados de auditoría.
Existen dos categorías de comandos:
• Los que se usan para definir y administrar acciones.

• Los que se usan para iniciar y administrar la aplicación de esas acciones a los resultados de auditoría.
Definir y administrar acciones Iniciar y administrar ejecución
CreateMitigationAction (p. 656) CancelAuditMitigationActionsTask (p. 673)
DeleteMitigationAction (p. 670) DescribeAuditMitigationActionsTask (p. 680)
655
CreateMitigationAction
Definir y administrar acciones Iniciar y administrar ejecución
DescribeMitigationAction (p. 665) ListAuditMitigationActionsTasks (p. 677)
ListMitigationActions (p. 663) StartAuditMitigationActionsTask (p. 670)
UpdateMitigationAction (p. 660) ListAuditMitigationActionsExecutions (p. 674)
Define una acción que se pueden aplicar a los resultados de auditoría mediante
StartAuditMitigationActionsTask (p. 670). Cada acción de mitigación solo puede aplicar un tipo de
cambio. Definir una acción no la aplica.
Sinopsis
aws iot create-mitigation-action \

--action-name <value] \
--role-arn <value> \
[--tags <value>] \
--action-params <value>] \
{
"actionParams": {
"addThingsToThingGroupParams": {
"overrideDynamicGroups": boolean,
"thingGroupNames": [ "string" ]
},
"enableIoTLoggingParams": {
"logLevel": "string",
"roleArnForLogging": "string"
},
"publishFindingToSnsParams": {
"topicArn": "string"
},
"replaceDefaultPolicyVersionParams": {
"templateName": "string"
},
"updateCACertificateParams": {
"action": "string"
},
"updateDeviceCertificateParams": {
"action": "string"
}
},
"tags": [
{
"Key": "string",
"Value": "string"
}
]
}
656
roleArn string El ARN del rol que concede

aplicar esta acción.
tags matriz de objetos de etiqueta Los metadatos que se pueden

utilizar para administrar la acción
de mitigación.
actionParams map Define el tipo de acción que se

va a aplicar y los parámetros
de dicha acción de mitigación.
Puede incluir solo un tipo de
parámetro para cada acción de
mitigación.
Debe proporcionar parámetros para el tipo de acción que está definiendo. Puede proporcionar solo un tipo
de acción y sus parámetros. Estos son los tipos de acciones admitidos:
• ADD_THINGS_TO_THING_GROUP
• ENABLE_IOT_LOGGING
• PUBLISH_FINDING_TO_SNS
• REPLACE_DEFAULT_POLICY_VERSION
• UPDATE_CA_CERTIFICATE
• UPDATE_DEVICE_CERTIFICATE
Parámetros para AddThingsToThingGroup
overrideDynamicGroups booleano Opcional. Especifica si esta

acción de mitigación puede
sacar los objetos que activaron
la acción de mitigación de uno
o varios grupos de objetos
dinámicos. Esta configuración
solo se utiliza si el objeto ya está
en el número máximo de grupos.
thingGroupNames matriz de cadenas Obligatorio. La lista de los grupos

a los que desea añadir los
objetos que activaron la acción
de mitigación.
Puede añadir un objeto a un

máximo de 10 grupos, pero no
puede añadir un objeto a más de
un grupo en la misma jerarquía.
657

Debe proporcionar al menos un
nombre de grupo.
Limitaciones de longitud: longitud

mínima de 1. La longitud máxima
es de 128 caracteres.
Parámetros para EnableIoTLogging
logLevel string Obligatorio. Especifica qué tipos

de información se registran.
Los valores válidos, desde el

más detallado al menos, son
DEBUG, INFO, ERROR y WARN.
No puede especificar un nivel de
registro DISABLED.
roleArnForLogging string Obligatorio. El ARN del rol de

IAM usado para el registro.
Longitud mínima de 20. La

longitud máxima es de 2048
caracteres.
Parámetros para PublishingFindingToSns
topicArn string Obligatorio. El ARN del tema

en el que desea publicar los
resultados.

caracteres.
Parámetros para ReplaceDefaultPolicyVersion
templateName string Obligatorio. El nombre de la

plantilla que se va a aplicar.
El único valor admitido es

BLANK_POLICY.
658
Parámetros para UpdateCACertificate
action string Obligatorio. La acción que desea

aplicar al certificado de CA.

DEACTIVATE.
Parámetros para UpdateDeviceCertificate
action string Obligatorio. La acción que

desea aplicar al certificado del
dispositivo.

DEACTIVATE.
actionArn string El ARN de la nueva acción de

mitigación.
actionId string El identificador único de la nueva

acción de mitigación.
Errores

Se ha superado un límite. Para obtener más información acerca de los límites de las acciones de
mitigación, consulte Service Limits.
RequestAlreadyExistsException
Ya existe una acción de mitigación con este nombre. Este error se produce solo si existe otra acción
de mitigación con el mismo nombre, pero parámetros diferentes.
ThrottlingException

An unexpected error has occurred.
Ejemplo
Este ejemplo define una acción de mitigación que, cuando se aplica, desactiva un certificado de
dispositivo.
659
UpdateMitigationAction
$ aws iot create-mitigation-action --action-name "UpdateCACertName" --role-

arn arn:aws:iam::123456789012:role/MitigationActionsValidRole --action-params
"updateDeviceCertificateParams={action=DEACTIVATE}"
La respuesta se asemeja a lo siguiente:
{
"actionArn": "arn:aws:iot:us-east-1:123456789012:mitigationaction/UpdateCACertName",
"actionId": "6a22b98e-0e27-4396-9b25-637d04959429"
}
Actualiza la definición de una acción que se puede aplicar a los resultados de auditoría mediante
StartAuditMitigationActionsTask (p. 670). Cada acción de mitigación solo puede aplicar un tipo de
cambio.
Sinopsis
aws iot update-mitigation-action \

--action-name <value> \
--role-arn <value> \
--action-params <value] \
{
"actionParams": {
},
},
},
},
"action": "string"
},
"action": "string"
}
},
"roleArn": "string"
]
}
660
roleArn string El ARN del rol que concede

aplicar esta acción.

va a aplicar y los parámetros
de dicha acción de mitigación.
Puede especificar solo un tipo de
acción y sus parámetros.
Debe proporcionar parámetros para el tipo de acción que está definiendo. Puede proporcionar solo un tipo
de acción y sus parámetros. Estos son los tipos de acciones admitidos:
• ADD_THINGS_TO_THING_GROUP
• ENABLE_IOT_LOGGING
• PUBLISH_FINDING_TO_SNS
• REPLACE_DEFAULT_POLICY_VERSION
• UPDATE_CA_CERTIFICATE
• UPDATE_DEVICE_CERTIFICATE
Parámetros para AddThingsToThingGroup
overrideDynamicGroups booleano Opcional. Especifica si esta

acción de mitigación puede
sacar los objetos que activaron
la acción de mitigación de uno
o varios grupos de objetos
dinámicos. Esta configuración
solo se utiliza si el objeto ya está
en el número máximo de grupos.
thingGroupNames matriz de cadenas Obligatorio. La lista de los grupos

a los que desea añadir los
de mitigación.


nombre de grupo.
Limitaciones de longitud: longitud

mínima de 1. La longitud máxima
es de 128 caracteres.
661

Parámetros para EnableIoTLogging
logLevel string Obligatorio. Especifica los tipos

de información que se van a
registrar.

DEBUG, INFO, ERROR y WARN.
No puede especificar un nivel de
registro DISABLED.
roleArnForLogging string Obligatorio. El ARN del rol de

IAM usado para el registro.

caracteres.
Parámetros para PublishingFindingToSns
topicArn string Obligatorio. El ARN del tema

en el que desea publicar los
resultados.

caracteres.
Parámetros para ReplaceDefaultPolicyVersion
templateName string Obligatorio. El nombre de la

plantilla que se va a aplicar.

BLANK_POLICY.
Parámetros para UpdateCACertificate
action string Obligatorio. La acción que desea

aplicar al certificado de CA.
662
ListMitigationActions

DEACTIVATE.
Parámetros para UpdateDeviceCertificate
action string Obligatorio. La acción que

desea aplicar al certificado del
dispositivo.

DEACTIVATE.
actionArn string El ARN de la acción de

mitigación.
actionId string El identificador único para la

Errores

No se encontró ninguna acción de mitigación con el nombre especificado.

ThrottlingException

Puede utilizar el comando ListMitigationActions para obtener una lista de todas las acciones de mitigación
de su cuenta de AWS.
Sinopsis
aws iot list-mitigation-actions \

[--action-type <value>] \
[--next-token <value>]
663
Parámetros de entrada
action-type string Especifique un valor para limitar

los resultados a acciones de
mitigación con un tipo de acción
específica.
Los valores admitidos son

UPDATE_CA_CERTIFICATE,
ADD_THINGS_TO_THING_GROUP,
REPLACE_DEFAULT_POLICY_VERSION,
ENABLE_IOT_LOGGING o
PUBLISH_FINDING_TO_SNS.
max-results integer El número máximo de resultados

que devolver a la vez.
El valor predeterminado es 25. El

rango válido es de 1 a 250.
next-token string El token para recuperar el

JSON de salida:
{
"actionIdentifiers": [
{
"actionArn": "string",
"actionName": "string",
"creationDate": number
}
],
}
actionIdentifiers map Información sobre el conjunto

de acciones de mitigación que
coinciden con los parámetros
especificados.

mitigación.
actionName string El identificador único de la nueva

La longitud máxima es 128.
664
DescribeMitigationAction
creationDate timestamp La fecha y la hora en que se creó

la acción de mitigación.

Errores

ThrottlingException

Ejemplo
Este ejemplo muestra todas las acciones de mitigación definidas para su cuenta en la región.
$ aws iot list-mitigation-actions
{
"actionIdentifiers": [
{
"actionName": "UpdateCACertName",
"actionArn": "arn:aws:iot:us-east-1:123456789012:mitigationaction/
UpdateCACertName",
}
]
}
Puede utilizar el comando DescribeMitigationAction para ver detalles de una acción de mitigación en su
cuenta de AWS.
Sinopsis
aws iot describe-mitigation-action --action-name <value>
665
action-name string El nombre fácil de recordar que

identifica de forma exclusiva la
JSON de salida:
{
"actionArn": "string",
"actionId": "string",
"actionParams": {
},
},
},
},
"action": "string"
},
"action": "string"
}
},
"actionType": "string",
"creationDate": number,
"lastModifiedDate": number,
"roleArn": "string"
}
Cada acción de mitigación solo tiene un tipo, por lo que solo aparece uno de los conjuntos de parámetros.


mitigación.
actionId string Un identificador único para la

actionName string El único nombre fácil de recordar

de la nueva acción de mitigación.
666


va a aplicar y los parámetros de
dicha acción de mitigación.
addThingsToThingGroupParamsmap Parámetros para definir una

acción de mitigación que mueve
los dispositivos asociados con
un certificado a uno o varios
grupos de objetos especificados,
por lo general, por motivos de
cuarentena.
overrideDynamicGroups booleano Especifica si esta acción de

mitigación puede sacar los
de mitigación incluso si son
parte de uno o varios grupos de
objetos dinámicos.
thingGroupNames matriz de cadenas La lista de los grupos a los que

desea añadir los objetos que
activaron la acción de mitigación.


nombre de grupo.
caracteres.
enableIoTLoggingParams map Parámetros para definir una

acción de mitigación que permite
a AWS IoT el registro en un nivel
especificado de detalle.
logLevel string Especifica los tipos de

información que se registrarán.

DEBUG, INFO, ERROR, WARN y
DISABLED.
667
roleArnForLogging string El ARN del rol de IAM usado

para el registro.

caracteres.
publishFindingToSnsParams map Parámetros para definir una

acción de mitigación que publica
los resultados en Amazon SNS.
Puede implementar sus propias
acciones personalizadas en
respuesta a los mensajes de
Amazon SNS.
topicArn string El ARN del tema en el que desea

publicar los resultados.

caracteres.
map
replaceDefaultPolicyVersionParams Parámetros para definir una
acción de mitigación que añade
una política en blanco para limitar
los permisos.
templateName string El nombre de la plantilla que se

va a aplicar.

BLANK_POLICY.
updateCACertificateParams map Parámetros para definir una

acción de mitigación que cambia
el estado del certificado de CA a
inactivo.
action string La acción que desea aplicar al

certificado de CA.

DEACTIVATE.
map
updateDeviceCertificateParams Parámetros para definir una
el estado del certificado del
dispositivo a inactivo.

certificado del dispositivo.

DEACTIVATE.
actionType string El tipo de acción que se aplica.
668
creationDate timestamp La fecha y la hora en que se creó

la acción de mitigación.
lastModifiedDate timestamp La fecha y la hora en que la

acción de mitigación se modificó
por última vez.
roleArn string El ARN del rol que se va a utilizar

a la hora de aplicar esta acción
de mitigación.
Errores
No se encontró ninguna acción de mitigación con el nombre especificado.


ThrottlingException

Ejemplo
Este ejemplo obtiene la definición de la acción de mitigación llamada UpdateCACertName.
$ aws iot describe-mitigation-action --action-name UpdateCACertName
{
"actionName": "UpdateCACertName",
"actionType": "UPDATE_DEVICE_CERTIFICATE",
"actionArn": "arn:aws:iot:us-east-1:123456789012:mitigationaction/UpdateCACertName",
"actionId": "6a22b98e-0e27-4396-9b25-637d04959429",
"roleArn": "arn:aws:iam::123456789012:role/MitigationActionsValidRole",
"actionParams": {
"action": "DEACTIVATE"
}
},
"creationDate": 1560173584.521,
"lastModifiedDate": 1560173584.521
}
669
DeleteMitigationAction
DeleteMitigationAction
Puede utilizar el comando DeleteMitigationAction para eliminar una acción de mitigación de su
cuenta de AWS. Para que el comando DeleteMitigationAction sea idempotente, no debe generar una
ResourceNotFoundException si intenta eliminar una acción de mitigación que no existe. En cambio,
DeleteMitigationAction devuelve un resultado correcto cuando el nombre de la acción no existe.
Sinopsis
aws iot delete-mitigation-action --action-name <value>
action-name string El nombre fácil de recordar que

identifica de forma exclusiva la
Errores

ThrottlingException

StartAuditMitigationActionsTask
Puede utilizar el comando StartAuditMitigationActionsTask para aplicar un conjunto de acciones de
mitigación a los resultados de una o varias auditorías.
Sinopsis
aws iot start-audit-mitigation-actions-task \

--task-id <value> \
--audit-task-id <value> \
--audit-checks-to-action-mapping <value> \
{
"auditCheckToActionsMapping": {
"string" : [ "string" ]
},
"clientRequestToken": "string",
"target": {
670
"auditTaskId": "string",
"findingIds": [ "string" ]
}
}
taskId string Un identificador único para

la tarea de mitigaciones de
auditoría.
auditCheckToActionsMapping mapa de cadena a matriz de Especifica la lista de acciones

cadenas que se van a aplicar a una
auditoría concreta.
La matriz debe contener al

menos 1, pero no más de 5
miembros.
clientRequestToken string Cada tarea de mitigación de

auditoría debe tener un token
de solicitud de cliente único. Si
intenta iniciar una nueva tarea
con el mismo ID de tarea que
una tarea existente, pero con otro
token, se produce una excepción.
Si omite este valor, se genera
automáticamente un token de
solicitud de cliente único.
longitud máxima es 64.
Patrón: [a-zA-Z0-9_-]+$
target map Especifica los resultados de

auditoría a los que se aplican
acciones de mitigación. Puede
aplicarlas a los resultados de una
tarea de auditoría o a un conjunto
de resultados.
auditTaskId string Un identificador único

para la auditoría a cuyos
resultados desea aplicar
el conjunto de acciones. El
auditCheckToReasonCodeFilter
puede filtrar aún más los
resultados de la auditoría.
Si desea limitar las acciones
671

a un conjunto específico de
resultados, utilice findingIds
en su lugar.
Patrón: [a-zA-Z0-9\-]+
findingIds matriz de cadenas Si la tarea aplica una acción

de mitigación a uno o más
resultados enumerados, este
valor identifica esos resultados.
Miembros de la matriz: mínimo

de 1 elemento. Máximo de 25
elementos.
La longitud máxima de cada

elemento es de 128.
JSON de salida:
{
"taskId": "string"
}
taskId string El identificador único para la

tarea de acciones de mitigación
de auditoría que se acaba de
crear.
Utilice este identificador si

necesita cancelar la tarea
(CancelAuditMitigationActionsTask)
o si desea ver los
detalles de la tarea con
DesribeAuditMitigationAtionsTask.
Errores
TaskAlreadyExistsException
Esta excepción se produce si intenta iniciar una tarea con el mismo ID de tarea que una tarea
existente pero con otro clientRequestToken.
672
CancelAuditMitigationActionsTask
Esta excepción se produce si intenta iniciar más de 10 tareas de acciones de mitigación.

ThrottlingException

Ejemplo
En este ejemplo, se inicia una tarea para aplicar la UpdateCACertAction que ha definido a los
resultados de la auditoría cuyo ID de tarea es aef320b958891041e0c60c088afac64c y cuya
comprobación de auditoría es CA_CERTIFICATE_EXPIRING_CHECK..
$ aws iot start-audit-mitigation-actions-task --task-id "myActionsTaskId" --target

"auditTaskId=aef320b958891041e0c60c088afac64c" --audit-check-to-actions-mapping
"CA_CERTIFICATE_EXPIRING_CHECK=UpdateCACertAction" --client-request-token "adhadhahda"
La respuesta tiene este aspecto:
{
"taskId": "myActionsTaskId"
}
CancelAuditMitigationActionsTask
Puede utilizar el comando CancelAuditMitigationActionsTask para detener la ejecución de una tarea de
mitigación de auditoría si aún no está completa.
Sinopsis
aws iot cancel-audit-mitigation-actions-task --task-id <value>
task-id string Un identificador único para

auditoría que desea cancelar.
Errores
No se ha encontrado una tarea de acciones de mitigación de auditoría con el ID de tarea especificado.
673
ListAuditMitigationActionsExecutions

ThrottlingException

Puede utilizar el comando ListAuditMitigationActionsExecutions para mostrar información acerca de una
tarea de mitigación de auditoría que se ha iniciado.
Sinopsis
aws iot list-audit-mitigation-actions-executions \

[--action-status <value>] \
--finding-id <value> \
--task-id <value> \
action-status string Especifique este filtro para limitar

los resultados a las ejecuciones
con un estado específico.

IN_PROGRESS, COMPLETED,
FAILED, CANCELED y SKIPPED
y PENDING.
finding-id string Especifique este filtro para limitar

los resultados a lo que se aplicó
a un resultado de auditoría
específico.
max-results número El número máximo de resultados

predeterminado es 25.
Rango válido: mínimo de 1,

máximo de 250.
next-token string El token del conjunto siguiente de

resultados.
674
task-id string Un identificador único para

auditoría cuyos detalles desea
mostrar.
JSON de salida:
{
"actionsExecutions": [
{
"actionId": "string",
"endTime": number,
"findingId": "string",
"message": "string",
"startTime": number,
"status": "string",
"taskId": "string"
}
],
}
actionsExecutions map Una colección de información

acerca de las ejecuciones de la
tarea de mitigación de auditoría
que se han iniciado para su
cuenta de AWS.
actionId string El identificador único para la

acción de mitigación aplicada por
la tarea.
actionName string El nombre descriptivo de la

acción de mitigación aplicada por
la tarea.
endTime timestamp La fecha y la hora cuando se

completó o canceló la tarea.
errorCode string Si se produce un error, el código

que indica el tipo de error.
findingId string El identificador único para el

resultado al que se aplican
675

la tarea y las acciones de
mitigación asociadas.
message string Si se ha producido un error, un

mensaje que describe el error.
startTime timestamp La fecha y la hora en que se

inició la tarea.
status string El estado actual de la tarea

que se está ejecutando.
FAILED, CANCELED, SKIPPED
y PENDING
taskId string El identificador único de la

tarea que aplica la acción de
mitigación.
nextToken string El token del conjunto siguiente de

resultados.
El campo de estado puede tener los siguientes valores:
Estado Qué significa
IN_PROGRESS AWS IoT Device Defender está aplicando la acción

de mitigación al resultado.
COMPLETED La acción de mitigación se aplicó correctamente en

el resultado.
FAILED No se pudo aplicar la acción de mitigación al

resultado. El código de error proporciona más
información.
CANCELED Se ha cancelado la ejecución de la acción porque

el usuario canceló la tarea.
SKIPPED Se ha omitido la ejecución de acción debido a un

error en una de las acciones en la lista.
PENDING La ejecución de la acción aún no ha comenzado.
Se puede devolver los siguientes códigos de error:
INSUFFICIENT_PERMISSIONS
• El ARN del rol que se proporcionó para la acción de mitigación no tiene permisos para aplicar la
acción.
INVALID_STATE_OF_RESOURCE
• El recurso en el resultado no se encuentra en un estado que permita aplicar correctamente la acción
de mitigación. Este error se produce para el tipo de acción ADD_THINGS_TO_THING_GROUP
si el objeto ya está en el máximo número de grupos permitidos. El error se produce para los tipos
676
ListAuditMitigationActionsTasks
de acciones de mitigación UPDATE_DEVICE_CERTIFICATE y UPDATE_CA_CERTIFICATE si el

certificado ya se ha revocado.
Errores

ThrottlingException

Puede utilizar el comando ListAuditMitigationActionsTasks para obtener una lista de tareas de acciones de
mitigación de auditoría que coinciden con los filtros especificados.
Sinopsis
aws iot list-audit-mitigation-actions-tasks

[--audit-task-id <value>] \
[--finding-id <value>] \
[--task-status <value>] \
audit-task-id string Un identificador único para

auditoría que desea mostrar.
La longitud mínima es 1. La
longitud máxima es 40.
end-time timestamp Obligatorio. Especifique este filtro

para obtener una lista de tareas
que finalizaron en esa fecha o
antes. Esta fecha no debe ser
más de 90 días en el pasado.
finding-id string Especifique este filtro para

obtener una lista de tareas que
se aplicaron a un resultado
concreto.
677

max-results número El número máximo de resultados

predeterminado es 25.
Rango válido: el valor mínimo es

1. El valor máximo es 250.
next-token string El token del conjunto siguiente de

resultados.
start-time timestamp Obligatorio. Especifique este filtro

para limitar los resultados a las
tareas que se iniciaron en esa
fecha y hora o con posterioridad.
Esta fecha no debe ser más de
90 días en el pasado.
task-status string Especifique este filtro para limitar

los resultados a las tareas que
se encuentran en un estado
especificado.
Los valores admitidos son:

FAILED y CANCELED.
JSON de salida:
{
"tasks": [
{
"taskId": "string",
"taskStatus": "string"
}
]
}
nextToken string El token del conjunto siguiente de

resultados.
tasks map La colección de tareas de

acciones de mitigación de
auditoría que coincide con los
criterios del filtro.
startTime timestamp Parámetros para definir una

678

cuarentena.
taskId string El identificador único de la tarea.
taskStatus string El estado actual de la tarea.
Errores
El contenido de la solicitud no es válido. Este error puede producirse si especifica fechas más de 90
días en el pasado.
ThrottlingException

Ejemplo
En este ejemplo, se muestran las tareas de mitigación de auditoría que se ejecutaron durante el periodo de
tiempo especificado.
$ aws iot list-audit-mitigation-actions-tasks --start-time 1560001663 --end-time

1560174463
{
"tasks": [
{
"taskId": "actionsTaskId",
"startTime": 1560174232.07,
"taskStatus": "CANCELED"
},
{
"taskId": "4e8acaf8-b7f0-4484-9b0d-01b979e61d8d",
"startTime": 1560060994.965,
"taskStatus": "COMPLETED"
},
{
"taskId": "0e8f5a95-e43f-43fa-9aa4-57ff3efb946d",
"startTime": 1560060860.243,
},
{
"taskId": "92d60009-33a1-45a7-a3c6-b28e938ec68a",
"startTime": 1560060707.653,
679
DescribeAuditMitigationActionsTask
},
{
"taskId": "bdea63c8-58bd-4798-9cb3-e949c7f1969a",
"startTime": 1560060531.123,
},
{
"taskId": "61e146ef-69f4-41bf-9d37-5d667f72ef3d",
"startTime": 1560060388.035,
},
{
"taskId": "2ef289dc-9bbd-422b-95ba-d96b7e626a60",
"startTime": 1560060256.695,
},
{
"taskId": "a6cdc16b-6be3-4800-bafa-2b86d3f5d639",
"startTime": 1560060097.613,
},
{
"taskId": "7ccf351b-e560-4eb2-8796-1dc1bcb25396",
"startTime": 1560059925.477,
},
{
"taskId": "8f69ee5d-3e35-4c91-88e8-3c5f84c96fde",
"startTime": 1560059345.473,
}
]
}
Puede utilizar el comando DescribeAuditMitigationActionsTask para mostrar información acerca de una
tarea de mitigación de auditoría que se ha iniciado.
Sinopsis
aws iot describe-audit-mitigation-actions-task --taskId <value>
taskId string Obligatorio. Un identificador

único para la tarea de
mitigaciones de auditoría cuyos
detalles desea mostrar.
JSON de salida:
680
{
"actionsDefinition": [
{
"actionParams": {
},
},
},
},
"action": "string"
},
"action": "string"
}
},
"id": "string",
"name": "string",
"roleArn": "string"
}
],
"auditCheckToActionsMapping": {
},
"endTime": number,
"target": {
"auditCheckToReasonCodeFilter": {
},
"auditTaskId": "string",
"findingIds": [ "string" ]
},
"taskStatistics": {
"string" : {
"canceledFindingsCount": number,
"failedFindingsCount": number,
"skippedFindingsCount": number,
"succeededFindingsCount": number,
"totalFindingsCount": number
}
},
"taskStatus": "string"
}
actionsDefinition map El conjunto de acciones (y sus

metadatos) aplicado por esta
de auditoría.
681
actionParams map Los parámetros utilizados al

aplicar la acción de mitigación.
addThingsToThingGroupParam map Parámetros para definir una

cuarentena.
overrideDynamicGroups booleano Especifica si esta acción de

mitigación puede sacar los
de mitigación incluso si son
parte de uno o varios grupos de
objetos dinámicos.
thingGroupNames matriz de cadenas La lista de grupos a los que esta

acción de mitigación añade los
objetos en el destino para esta
de auditoría.
enableIoTLoggingParams map Parámetros para definir una

acción de mitigación que permite
a AWS IoT el registro en un nivel
especificado de detalle.
logLevel string Especifica los tipos de

información que se registrarán.
roleArnForLogging string El ARN del rol de IAM usado

para el registro.
publishFindingToSnsParams map Parámetros para definir una

acción de mitigación que publica
los resultados en Amazon SNS.
Puede implementar sus propias
acciones personalizadas en
respuesta a los mensajes de
Amazon SNS.
topicArn string El ARN del tema en el que desea

publicar los resultados.
map
replaceDefaultPolicyVersionParams Parámetros para definir una
acción de mitigación que añade
una política en blanco para limitar
los permisos.
templateName string El nombre de la plantilla que se

va a aplicar.

BLANK_POLICY.
682
updateCACertificateParams map Parámetros para definir una

el estado del certificado de CA a
inactivo.

certificado de CA.

DEACTIVATE.
map
updateDeviceCertificateParams Parámetros para definir una
el estado del certificado del
dispositivo a inactivo.

certificado del dispositivo.

DEACTIVATE.
id string El identificador único para la

acción de mitigación aplicada
como parte de esta tarea de
mitigación de auditoría.
name string El nombre fácil de recordar para

la acción de mitigación aplicada
como parte de esta tarea de
roleArn string El ARN del rol utilizado a la

hora de aplicar esta tarea de
mitigación.
auditCheckToActionsMapping map Para un tipo de comprobación de

auditoría, especifica las acciones
de mitigación que aplica esta
tarea de mitigación de auditoría.
endTime timestamp Si la tarea de acciones de

mitigación de auditoría se ha
completado o se ha cancelado, la
fecha y hora en que se detiene la
ejecución.
startTime timestamp La fecha y la hora cuando

empezó la ejecución de esta
tarea de acción de mitigación de
auditoría.
target map Información sobre los destinos a

los que se aplican las acciones
de mitigación como parte de esta
de auditoría.
683
map
auditCheckToReasonCodeFilter Especifica un conjunto de
comprobaciones de auditoría
y los códigos de motivo que
se utilizan para identificar los
resultados de auditoría a los que
se aplica la tarea de acciones de
auditTaskId string Especifica una auditoría a cuyos

resultados se aplica esta tarea
de acciones de mitigación de
auditoría.
findingIds matriz de cadenas Especifica un conjunto de

resultados de auditoría a los que
se aplica esta tarea de acciones
de mitigación de auditoría.
taskStatistics map El conjunto de estadísticas

de ejecución de esta tarea
auditoría.
canceledFindingsCount número Si la tarea se ha cancelado,

el número de resultados en el
destino de esta tarea de acciones
de mitigación de auditoría a los
que no se aplicaron acciones de
mitigación.
failedFindingsCount número El número de resultados en el

de mitigación de auditoría en los
que las acciones de mitigación
produjeron un error al aplicarse.
skippedFindingsCount número El número de resultados en el

de mitigación de auditoría en los
que no se aplicaron acciones
de mitigación ya que fueron
excluidos por un filtro aplicado a
la tarea.
succeededFindingsCount número El número de resultados en el

de mitigación de auditoría en
los que se aplicaron acciones
de mitigación sin errores ni
cancelación.
totalFindingsCount número El número total de resultados

en el destino de esta tarea
auditoría.
684
Detect
taskStatus string El estado actual de la tarea

auditoría. El estado produce un
error si no pudieron aplicarse
a los resultados una o varias
acciones.
Errores
No se han encontrado tareas de mitigación de auditoría con el taskId especificado.


ThrottlingException

Detect
AWS IoT Device Defender Detect permite identificar comportamientos inusuales que podrían indicar que
un dispositivo se ha visto comprometido cuando se monitorea el comportamiento de los dispositivos. Si
utiliza una combinación de métricas del lado de la nube (procedentes de AWS IoT) y de métricas del lado
del dispositivo (procedentes de agentes instalados en los dispositivos), puede detectar:
• Cambios en los patrones de conexión.

• Dispositivos que se comunican con puntos de enlace no autorizados o no reconocidos.
• Cambios en los patrones de tráfico de entrada y salida de los dispositivos.
Cree perfiles de seguridad, que contengan definiciones de comportamientos esperados de los dispositivos
y asígnelos a un grupo de dispositivos o a todos los dispositivos de su flota. AWS IoT Device Defender
Detect utiliza estos perfiles de seguridad para detectar anomalías y enviar alertas a través de métricas de
Amazon CloudWatch y notificaciones de Amazon Simple Notification Service.
AWS IoT Device Defender Detect puede detectar problemas de seguridad que se producen con frecuencia
en los dispositivos conectados:
• Tráfico desde un dispositivo a una dirección IP maliciosa conocida o a un punto de enlace no autorizado
que indica un posible comando y canal de control maliciosos.
• Tráfico anómalo, como un pico en el tráfico saliente, que indica que un dispositivo participa en un DDoS.
• Dispositivos con puertos e interfaces de administración remota a los que se puede acceder de forma
remota.
• Un pico en el índice de mensajes que se envían a la cuenta (por ejemplo, desde un dispositivo
fraudulento, lo que podría producir unos gastos excesivos por mensaje).
685
Conceptos
Casos de uso
Medir la superficie de ataque
Puede usar AWS IoT Device Defender Detect para medir la superficie de ataque de sus dispositivos.
Puede, por ejemplo, identificar dispositivos con puertos de servicio que con frecuencia son objeto de
campañas de ataques (el servicio telnet que se ejecuta en los puertos 23/2323, el servicio SSH que
se ejecuta en el puerto 22, los servicios HTTP/S que se ejecutan en los puertos 80/443/8080/8081).
Aunque estos puertos de servicio pueden tener motivos legítimos para utilizarse en los dispositivos,
también suelen formar parte de la superficie de ataque de los adversarios y llevan asociados
riesgos. Una vez que AWS IoT Device Defender Detect alerta de la superficie de ataque, esta puede
minimizarse (eliminando servicios de red que no se utilizan) o se pueden ejecutar otras evaluaciones
para identificar debilidades de seguridad (por ejemplo, un telnet configurado con contraseñas de uso
común, predeterminadas o poco seguras).
Detectar anomalías de comportamiento de dispositivos con posibles causas raíces de seguridad
Puede usar AWS IoT Device Defender Detect para alertarle sobre las métricas de comportamiento
inesperado del dispositivo (el número de puertos abiertos, el número de conexiones, un puerto abierto
inesperado, las conexiones a direcciones IP inesperadas) que pueden indicar una vulneración de la
seguridad. Por ejemplo, un número de conexiones TCP más alto de lo esperado puede indicar que un
dispositivo se está utilizando para un ataque DDoS. Un proceso que se escucha en un puerto diferente
al que espera puede indicar una puerta trasera instalada en un dispositivo para control remoto. Puede
usar AWS IoT Device Defender Detect para sondear el estado de las flotas de dispositivos y contrastar
los supuestos de seguridad (por ejemplo, que ningún dispositivo está escuchando en el puerto 23 o
2323).
Puede habilitar la detección de amenazas basada en aprendizaje automático (ML) para identificar
automáticamente posibles amenazas.
Detectar un dispositivo configurado incorrectamente
Un pico en el número o tamaño de los mensajes enviados desde un dispositivo a su cuenta puede
indicar un dispositivo configurado incorrectamente. Un dispositivo como este podría aumentar los
gastos por mensaje. Del mismo modo, un dispositivo con muchos errores de autorización podría
requerir la reconfiguración de una política.
Conceptos
métrica
AWS IoT Device Defender Detect usa métricas para detectar un comportamiento anómalo. AWS
IoT Device Defender Detect compara el valor de una métrica registrado con el valor esperado que
proporciona el usuario. Estas métricas se pueden obtener de dos fuentes: de las métricas del lado de
la nube y de las métricas del lado del dispositivo:
El comportamiento anómalo en la red de AWS IoT se detecta mediante el uso de métricas del lado
de la nube, como el número de errores de autorización o el número o el tamaño de mensajes que un
dispositivo envía o recibe a través de AWS IoT.
AWS IoT Device Defender Detect también puede recopilar, agregar y monitorizar datos de métricas
generados por dispositivos AWS IoT (por ejemplo, los puertos en los que escucha un dispositivo, la
cantidad de bytes o paquetes enviados o las conexiones TCP del dispositivo).
Puede usar AWS IoT Device Defender Detect solo con métricas del lado de la nube. Para usar las
métricas del lado del dispositivo, primero debe implementar el SDK de AWS IoT en sus dispositivos
conectados a AWS IoT o en las gateways de los dispositivos para recopilar las métricas y enviarlas a
AWS IoT. Consulte Envío de métricas desde dispositivos (p. 711).
686
Comportamientos
dimensión
Puede definir una dimensión para ajustar el ámbito de un comportamiento. Por ejemplo, puede
definir una dimensión de filtrado de temas que aplique un comportamiento a los temas de MQTT que
coincidan con un patrón. Para obtener más información acerca de cómo definir una dimensión para
utilizarla en un perfil de seguridad, consulte CreateDimension (p. 718).
perfil de seguridad
Un perfil de seguridad define comportamientos anómalos para un grupo de dispositivos (un grupo
de objetos (p. 102)) o para todos los dispositivos de su cuenta y especifica qué acciones adoptar
cuando se detecta una anomalía. Puede utilizar la consola de AWS IoT o los comandos de la API para
crear un perfil de seguridad y asociarlo a un grupo de dispositivos. AWS IoT Device Defender Detect
comienza a registrar datos relacionados con la seguridad y utiliza los comportamientos definidos en el
perfil de seguridad para detectar anomalías en el comportamiento de los dispositivos.
comportamiento
Un comportamiento indica a AWS IoT Device Defender Detect cómo puede saber cuándo un
dispositivo realiza alguna actividad anómala. Cada comportamiento consta de un nombre, una métrica,
un operador y un valor o un umbral estadístico. Para algunas métricas, también es necesario un
periodo de tiempo (durationSeconds). Todas las acciones del dispositivo que no coinciden con un
comportamiento definido desencadenan una alerta.
alerta
Cuando se detecta una anomalía, se puede enviar una notificación de alerta a través de una métrica
de CloudWatch (consulte Uso de las métricas de AWS IoT (p. 227)) o de una notificación de SNS.
También se muestra una notificación de alerta en la consola de AWS IoT junto con información
sobre dicha alerta y un historial de las alertas del dispositivo. También se envía una alerta cuando un
dispositivo monitorizado deja de exhibir un comportamiento anómalo o cuando ha estado generando
una alerta, pero deja de informar durante un período prolongado.
Comportamientos
Un perfil de seguridad contiene un conjunto de comportamientos. Cada comportamiento contiene una
métrica que especifica el comportamiento normal de un grupo de dispositivos o de todos los dispositivos de
la cuenta. Consulte Métricas (p. 688) y CreateSecurityProfile (p. 720).
A continuación, se describen algunos de los campos que se utilizan en la definición de un behavior:
name
El nombre del comportamiento.

metric
El nombre de la métrica utilizada (es decir, lo que mide el comportamiento).

dimension
Puede definir una dimensión para ajustar el ámbito de un comportamiento. Por ejemplo, puede
definir una dimensión de filtrado de temas que aplique un comportamiento a los temas de MQTT
que coincidan con un patrón. Si desea definir una dimensión para utilizarla en un perfil de seguridad,
consulte CreateDimension (p. 718).
criteria
Los criterios que determinan si un dispositivo se comporta normalmente con respecto a la metric.
comparisonOperator
El operador que relaciona el objeto medido (metric) con los criterios (value o
statisticalThreshold).
687
Métricas
Los valores posibles son: "less-than", "less-than-equals", "greater-than", "greater-than-equals",

"in-cidr-set", "not-in-cidr-set", "in-port-set" y "not-in-port-set". No todos los operadores son válidos
para todas las métricas. Los operadores para conjuntos y puertos CIDR solo son para usarlos con
métricas que impliquen dichas entidades.
value
El valor que se va a comparar con la metric. En función del tipo de métrica, debe contener
count (un valor), cidrs (una lista de CIDR) o ports (una lista de puertos).
statisticalThreshold
El umbral estadístico por el que se determina la infracción de un comportamiento. Este campo

contiene un campo statistic que tiene los siguientes valores posibles: "p0", "p0.1", "p0.01",
"p1", "p10", "p50", "p90", "p99", "p99.9", "p99.99" o "p100".
Este campo statistic indica un percentil. Da como resultado un valor por el que se determina
la conformidad con el comportamiento. Las métricas se recopilan una o varias veces a lo largo de
la duración especificada (durationSeconds) de todos los dispositivos de informe asociados a
este perfil de seguridad y los percentiles se calculan en función de dichos datos. Posteriormente,
las medidas se recopilan para un dispositivo y se acumulan a lo largo de la misma duración.
Si el valor resultante del dispositivo está por encima o por debajo (comparisonOperator)
del valor asociado con el percentil especificado, se considera que el dispositivo se ajusta al
comportamiento. De lo contrario, el dispositivo infringirá dicho comportamiento.
Un percentil indica el porcentaje de todas las mediciones consideradas que caigan por debajo del
valor asociado. Por ejemplo, si el valor asociado a "p90" (el percentil 90.º) es 123, el 90% de todas
las mediciones fueron inferiores a 123.
durationSeconds
Utilícelo para especificar el periodo de tiempo durante el cual se evalúa el comportamiento, para
aquellos criterios que tienen una dimensión de tiempo (por ejemplo, NUM_MESSAGES_SENT).
Para una comparación de métricas statisticalThreshhold, se trata del período de tiempo
durante el que se recopilan mediciones para todos los dispositivos a fin de determinar los valores
statisticalThreshold y, a continuación, para cada dispositivo para determinar cómo se
comparta en comparación.
consecutiveDatapointsToAlarm
Si un dispositivo infringe el comportamiento para el número especificado de puntos de datos

consecutivos, se genera una alarma. Si no se especifica, el valor predeterminado es 1. (Esto
difiere de la consola de AWS IoT donde se presenta de forma predeterminada un valor de 3, pero
se puede anular).
consecutiveDatapointsToClear
Si se genera una alerta y el dispositivo infractor deja de infringir el comportamiento para el número
especificado de puntos de datos consecutivos, la alarma se desactiva. Si no se especifica, el
valor predeterminado es 1. (Esto difiere de la consola de AWS IoT donde se presenta de forma
predeterminada un valor de 3, pero se puede anular).
Métricas
aws:message-byte-size
El número de bytes de un mensaje.

More info (1)
Utilice esta métrica para especificar el tamaño máximo o mínimo (en bytes) de cada mensaje
transmitido desde un dispositivo a AWS IoT.
688
Métricas
Origen: lado de la nube
Operadores: less-than | less-than-equals | greater-than | greater-than-equals
Valor: un entero no negativo
Unidades: bytes
Example
{
"name": "Max Message Size",
"metric": "aws:message-byte-size",
"criteria": {
"comparisonOperator": "less-than",
"value": {
"count": 1024
},
"consecutiveDatapointsToAlarm": 3,
"consecutiveDatapointsToClear": 3
}
}
Example Ejemplo en el que se utiliza statisticalThreshold:
{
"name": "Large Message Size",
"criteria": {
"statisticalThreshold": {
"statistic": "p90"
},
"durationSeconds": 300,
}
}
Se genera una alarma para un dispositivo si, durante tres períodos consecutivos de cinco minutos,
transmite mensajes cuyo tamaño acumulado es mayor que el medido para el 90 por ciento de todos
los demás dispositivos que informan sobre este comportamiento de perfil de seguridad.
aws:num-messages-received/aws:num-messages-sent
El número de mensajes recibidos o enviados por un dispositivo durante un período de tiempo

determinado.
More info (2)
Utilice esta métrica para especificar el número máximo o mínimo de mensajes que pueden enviarse o
recibirse entre AWS IoT y cada dispositivo en un período de tiempo determinado.
Unidades: mensajes
689
Métricas
Duración: un número entero no negativo, los valores válidos son 300, 600, 900, 1800 o 3600 segundos
Example
{
"name": "Out bound message count",
"metric": "aws:num-messages-sent",
"criteria": {
"value": {
"count": 50
},
}
}
{
"name": "Out bound message rate",
"criteria": {
"statistic": "p99"
},
}
}
aws:all-bytes-out
El número de bytes salientes de un dispositivo durante un período de tiempo determinado.

More info (3)
Utilice esta métrica para especificar la cantidad máxima o mínima de tráfico saliente que un dispositivo
debe enviar, medido en bytes, en un período de tiempo determinado.
Origen: lado del dispositivo
Unidades: bytes
Example
{
"name": "TCP outbound traffic",
"metric": "aws:all-bytes-out",
"criteria": {
690
Métricas
"value": {
"count": 4096
},
}
}
{
"metric": "aws:all-bytes-out",
"criteria": {
"statistic": "p50"
},
}
}
aws:all-bytes-in
El número de bytes entrantes en un dispositivo durante un período de tiempo determinado.

More info (4)
Utilice esta métrica para especificar la cantidad máxima o mínima de tráfico entrante que un
dispositivo debe recibir, medido en bytes, en un período de tiempo determinado.
Unidades: bytes
Example
{
"name": "TCP inbound traffic",
"metric": "aws:all-bytes-in",
"criteria": {
"value": {
"count": 4096
},
}
}
691
Métricas
{
"metric": "aws:all-bytes-in",
"criteria": {
"statistic": "p90"
},
}
}
aws:all-packets-out
El número de paquetes salientes de un dispositivo durante un período de tiempo determinado.

More info (5)
Utilice esta métrica para especificar la cantidad máxima o mínima de tráfico saliente total que un
dispositivo debe enviar en un período de tiempo determinado.
Unidades: paquetes
Duración: un entero no negativo. Los valores válidos son 300, 600, 900, 1800 o 3600 segundos.
Example
{
"metric": "aws:all-packets-out",
"criteria": {
"value": {
"count": 100
},
}
}
{
"metric": "aws:all-packets-out",
"criteria": {
"statistic": "p90"
692
Métricas
},
}
}
aws:all-packets-in
El número de paquetes entrantes en un dispositivo durante un período de tiempo determinado.

More info (6)
Utilice esta métrica para especificar la cantidad máxima o mínima de tráfico entrante total que un
dispositivo debe recibir en un período de tiempo determinado.
Unidades: paquetes
Example
{
"metric": "aws:all-packets-in",
"criteria": {
"value": {
"count": 100
},
}
}
Example
Ejemplo en el que se utiliza statisticalThreshold:
{
"metric": "aws:all-packets-in",
"criteria": {
"statistic": "p90"
},
}
693
Métricas
aws:num-authorization-failures
El número de errores de autorización durante un período de tiempo determinado.

More info (7)
Utilice esta métrica para especificar la cantidad máxima de errores de autorización permitidos para
cada dispositivo en un período de tiempo determinado. Se produce un error de autorización cuando se
deniega una solicitud desde un dispositivo a AWS IoT (por ejemplo, si un dispositivo intenta publicar
en un tema para el que no tiene suficientes permisos).
Unidad: errores
Unidades: errores
Example
{
"name": "Authorization Failures",
"metric": "aws:num-authorization-failures",
"criteria": {
"value": {
"count": 5
},
}
}
{
"name": "Authorization Failures",
"criteria": {
"statistic": "p50"
},
}
}
694
Métricas
aws:source-ip-address
La dirección IP desde la que se ha conectado un dispositivo a AWS IoT.

More info (8)
Utilice esta métrica para especificar un conjunto de CIDR permitidos (previamente denominado lista
blanca) y denegados (previamente denominado lista negra) desde los que cada dispositivo debe o no
conectarse a AWS IoT.
Operadores: in-cidr-set | not-in-cidr-set
Valores: una lista de CIDR
Unidades: n/a
Example
{
"name": "Denied source IPs",
"metric": "aws:source-ip-address",
"criteria": {
"comparisonOperator": "not-in-cidr-set",
"value": {
"cidrs": [ "12.8.0.0/16", "15.102.16.0/24" ]
}
}
}
aws:destination-ip-addresses
Un conjunto de destinos de IP.

More info (9)
Utilice esta métrica para especificar un conjunto de CIDR permitidos (previamente denominado lista
blanca) y denegados (previamente denominado lista negra) con los que cada dispositivo debe o no
comunicarse.
Operadores: in-cidr-set | not-in-cidr-set
Valores: una lista de CIDR
Unidades: n/a
Ejemplo:
Example
{
"name": "Denied destination IPs",
"metric": "aws:destination-ip-addresses",
"criteria": {
"comparisonOperator": "not-in-cidr-set",
"value": {
"cidrs": [ "12.8.0.0/16", "15.102.16.0/24" ]
695
Métricas
}
}
}
aws:listening-tcp-ports / aws:listening-udp-ports
Los puertos TCP o UDP en los que escucha el dispositivo.

More info (10)
Utilice esta métrica para especificar un conjunto de puertos TCP/UDP permitidos (previamente
denominado lista blanca) y denegados (previamente denominado lista negra) en los que cada
dispositivo debe o no escuchar.
Operadores: in-port-set | not-in-port-set
Valores: una lista de puertos
Unidades: n/a
Ejemplo:
{
"name": "Listening TCP Ports",
"metric": "aws:listening-tcp-ports",
"criteria": {
"comparisonOperator": "in-port-set",
"value": {
"ports": [ 443, 80 ]
}
}
}
aws:num-listening-tcp-ports / aws:num-listening-udp-ports
El número de puertos TCP o UDP en los que escucha el dispositivo.

More info (11)
Utilice esta métrica para especificar el número máximo o mínimo de puertos TCP o UDP que cada
dispositivo debe escuchar.
Unidades: puertos
Example
Ejemplo:
696
Métricas
"name": "Max TCP Ports",

"metric": "aws:num-listening-tcp-ports",
"criteria": {
"comparisonOperator": "less-than-equals",
"statistic": "p90"
},
}
}
aws:num-established-tcp-connections
El número de conexiones TCP para un dispositivo.

More info (12)
Utilice esta métrica para especificar el número máximo o mínimo de conexiones TCP activas que cada
dispositivo debe tener. (Todos los estados de TCP)
Unidades: conexiones
Example
{
"name": "TCP Connection Count",
"metric": "aws:num-established-tcp-connections",
"criteria": {
"value": {
"count": 3
},
}
}
{
"name": "TCP Connection Count",
"metric": "aws:num-established-tcp-connections",
"criteria": {
"statistic": "p90"
},
}
697
Métricas
aws:num-connection-attempts
Número de veces que un dispositivo intenta realizar una conexión durante un periodo determinado.
More info (13)
Utilice esta métrica para especificar el número máximo o mínimo de intentos de conexión para cada
dispositivo. Se cuentan los intentos correctos y los no correctos.
Unidades: intentos de conexión
Example
{
"name": "Connection Attempts",
"metric": "aws:num-connection-attempts",
"criteria": {
"comparisonOperator": "greater-than",
"value": {
"count": 5
},
}
}
{
"name": "Connection Attempts",
"metric": "aws:num-connection-attempts",
"criteria": {
"statistic": "p10"
},
}
}
aws:num-disconnects
Número de veces que un dispositivo se desconecta de AWS IoT durante un periodo de tiempo
determinado.
698
Establecer el ámbito de las métricas en los
perfiles de seguridad utilizando dimensiones
More info (14)
Utilice esta métrica para especificar el número máximo o mínimo de veces que un dispositivo se ha
desconectado de AWS IoT durante un periodo de tiempo determinado.
Unidades: desconexiones
Example
{
"name": "Disconnections",
"metric": "aws:num-disconnects",
"criteria": {
"value": {
"count": 5
},
}
}
{
"name": "Disconnections",
"metric": "aws:num-disconnects",
"criteria": {
"statistic": "p10"
},
}
}
Establecer el ámbito de las métricas en los perfiles de

seguridad utilizando dimensiones
Las dimensiones son atributos que se pueden definir para obtener datos más precisos sobre las métricas y
los comportamientos del perfil de seguridad. El ámbito se define proporcionando un valor o patrón que se
utiliza como filtro. Por ejemplo, puede definir una dimensión de filtrado de temas que aplique una métrica
solo a los temas de MQTT que coincidan con un determinado valor; por ejemplo "data/bulb/+/activity". Para
obtener más información acerca de cómo definir una dimensión que pueda utilizar en el perfil de seguridad,
consulte CreateDimension (p. 718).
Se pueden utilizar comodines de MQTT en los valores de las dimensiones. Los comodines de MQTT
le permiten suscribirse a varios temas simultáneamente. Hay dos tipos diferentes de comodines: de un
699
Cómo utilizar las dimensiones en la CLI de AWS
nivel (+) y de varios niveles (#). Por ejemplo, el valor de dimensión Data/bulb/+/activity crea una
suscripción que busca correspondencias en todos los temas que existen en el mismo nivel que +. Los
valores de dimensión también admiten la variable de sustitución del ID de cliente de MQTT ${iot:clientiD}.
Las dimensiones de tipo TOPIC_FILTER son compatibles con el siguiente conjunto de métricas del lado de
la nube:
• Número de mensajes enviados

• Número de mensajes recibidos
• Tamaño de bytes del mensaje
• Dirección IP de origen
• Número de errores de autorización

Para crear una dimensión y aplicarla a un comportamiento del perfil de seguridad
1. Primero cree la dimensión antes de asociarla a un perfil de seguridad. Utilice el comando

CreateDimension (p. 718) para crear una dimensión.
aws iot create-dimension \

--name TopicFilterForAuthMessages \
--type TOPIC_FILTER \
--string-values device/+/auth
{
"arn": "arn:aws:iot:us-west-2:123456789012:dimension/TopicFilterForAuthMessages",
"name": "TopicFilterForAuthMessages"
}
2. Agregue la dimensión a un perfil de seguridad existente mediante UpdateSecurityProfile (p. 732)

o agregue la dimensión a un nuevo perfil de seguridad mediante CreateSecurityProfile (p. 720).
En el siguiente ejemplo, creamos un nuevo perfil de seguridad que comprueba si los mensajes a
TopicFilterForAuthMessages tienen menos de 128 bytes y conserva el número de mensajes
enviados a temas que no son de autenticación.
aws iot create-security-profile \

--security-profile-name ProfileForConnectedDevice \
--security-profile-description "Check to see if messages to
TopicFilterForAuthMessages are under 128 bytes and retains the number of messages sent
to non-auth topics." \
--behaviors "[{\"name\":\"CellularBandwidth\",\"metric\":\"aws:message-byte-size
\",\"criteria\":{\"comparisonOperator\":\"less-than\",\"value\":{\"count\":128},
\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}},{\"name
\":\"Authorization\",\"metric\":\"aws:num-authorization-failures\",\"criteria\":
{\"comparisonOperator\":\"less-than\",\"value\":{\"count\":10},\"durationSeconds\":300,
\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}}]" \
--additional-metrics-to-retain-v2 "[{\"metric\": \"aws:num-authorization-failures\",
\"metricDimension\": {\"dimensionName\": \"TopicFilterForAuthMessages\",\"operator\":
\"NOT_IN\"}}]"
700
"securityProfileArn": "arn:aws:iot:us-west-2:1234564789012:securityprofile/
ProfileForConnectedDevice",
"securityProfileName": "ProfileForConnectedDevice"
}
También puede cargar un parámetro desde un archivo en lugar de escribirlo todo como un valor
de parámetro de línea de comandos para ahorrar tiempo. Para obtener más información, consulte
Carga de parámetros de la CLI de AWS desde un archivo. A continuación se muestra el parámetro
behavior en formato JSON expandido:
[
{
"criteria": {
"consecutiveDatapointsToClear": 1,
"value": {
"count": 128
}
},
"metricDimension": {
"dimensionName:": "TopicFilterForAuthMessages"
},
"name": "CellularBandwidth"
}
]
Para ver perfiles de seguridad con una dimensión
• Utilice el comando ListSecurityProfiles (p. 727) para ver perfiles de seguridad con una dimensión
determinada:
aws iot list-security-profiles \

--dimension-name TopicFilterForAuthMessages
{
"securityProfileIdentifiers": [
{
"name": "ProfileForConnectedDevice",
"arn": "arn:aws:iot:us-west-2:1234564789012:securityprofile/
ProfileForConnectedDevice"
}
]
}
Para actualizar la dimensión
• Utilice el comando UpdateDimension (p. 730) para actualizar una dimensión:
aws iot update-dimension \

--name TopicFilterForAuthMessages \
--string-values device/${iot:ClientId}/auth
701
{
"name": "TopicFilterForAuthMessages",
"lastModifiedDate": 1585866222.317,
"stringValues": [
"device/${iot:ClientId}/auth"
],
"creationDate": 1585854500.474,
"type": "TOPIC_FILTER",
"arn": "arn:aws:iot:us-west-2:1234564789012:dimension/TopicFilterForAuthMessages"
}
Para eliminar una dimensión
1. Para eliminar una dimensión, primero desconéctela de los perfiles de seguridad a los que esté
asociada. Utilice el comando ListSecurityProfiles (p. 727) para ver perfiles de seguridad con una
determinada dimensión.
2. Para quitar una dimensión de un perfil de seguridad, utilice el comando
UpdateSecurityProfile (p. 732). Introduzca toda la información que desee conservar, pero excluya la
dimensión:
aws iot update-security-profile \

--security-profile-name ProfileForConnectedDevice \
--security-profile-description "Check to see if authorization fails 10 times in 5
minutes or if cellular bandwidth exceeds 128" \
--behaviors "[{\"name\":\"metric\":\"aws:message-byte-size\",\"criteria
\":{\"comparisonOperator\":\"less-than\",\"value\":{\"count\":128},
\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}},{\"name
\":\"Authorization\",\"metric\":\"aws:num-authorization-failures\",\"criteria\":
{\comparisonOperator\":\"less-than\",\"value\"{\"count\":10},\"durationSeconds\":300,
\"consecutiveDatapointsToAlarm\":1,\"consecutiveDatapointsToClear\":1}}]"
{
"behaviors": [
{
"name": "CellularBandwidth",
"criteria": {
"value": {
"count": 128
}
}
},
{
"name": "Authorization",
"criteria": {
"value": {
"count": 10
}
}
702
Cómo utilizar las dimensiones en la consola
}
],
"securityProfileName": "ProfileForConnectedDevice",
"securityProfileDescription": "Check to see if authorization fails 10 times in 5
minutes or if cellular bandwidth exceeds 128",
"version": 2,
"securityProfileArn": "arn:aws:iot:us-west-2:123456789012:securityprofile/Preo/
ProfileForConnectedDevice",
}
3. Una vez desconectada la dimensión, utilice el comando DeleteDimension (p. 721) para eliminar la
dimensión:
aws iot delete-dimension \

--name TopicFilterForAuthMessages

Para crear una dimensión y aplicarla a un comportamiento del perfil de seguridad
1. En la consola de AWS IoT, en el panel de navegación, expanda Defend, expanda Detect y seleccione
Security profiles (Perfiles de seguridad).
2. En la página Security profiles (Perfiles de seguridad), elija Create (Crear) para agregar un nuevo perfil
de seguridad o Edit (Editar) para aplicar una dimensión a un perfil de seguridad existente.
3. En la página Expected behaviors (Comportamientos esperados), seleccione una de las cinco
dimensiones del lado de la nube admitidas en Metric (Métrica). Aparecerán los cuadros Dimension
(Dimensión) y Dimension operator (Operador de dimensión). Para obtener información sobre las
métricas del lado de la nube admitidas, consulte Establecer el ámbito de las métricas en los perfiles de
seguridad utilizando dimensiones (p. 699).
4. En el menú desplegable Dimension (Dimensión), seleccione Add dimension (Agregar dimensión).
5. En la página Create a new dimension (Crear una nueva dimensión), escriba los detalles de la nueva
dimensión. En Dimensions values (Valores de dimensión), se pueden utilizar los caracteres comodín
de MQTT # y +, así como la variable de sustitución del ID de cliente de MQTT ${iot:ClientId}.
703
6. Elija Save (Guardar).

7. También puede agregar dimensiones a las métricas en Additional Metrics to retain (Métricas
adicionales que se van a mantener).
8. Escriba los datos de los demás campos necesarios para terminar de crear el comportamiento y elija
Next (Siguiente).
9. Complete los pasos restantes para terminar de crear el perfil de seguridad.
Para ver las infracciones
1. En la consola de AWS IoT, en el panel de navegación, expanda Defend y Detect. A continuación,

seleccione Violations (Infracciones).
704
2. En la columna Behavior (Comportamiento), sitúe el ratón sobre el comportamiento cuya información

sobre infracciones desee ver.
Para ver y actualizar las dimensiones
Dimensions (Dimensiones).
2. Seleccione la dimensión que desee editar.
3. Seleccione Actions (Acciones), Edit (Editar).
705
Para eliminar una dimensión
Dimensions (Dimensiones).
2. Seleccione la dimensión que desee eliminar.
3. Para confirmar que la dimensión no está asociada a ningún perfil de seguridad, consulte la columna
Used in (Usado en) . Si la dimensión está asociada a un perfil de seguridad, abra la página Security
profiles (Perfiles de seguridad) de la izquierda y edite los perfiles de seguridad a los que está asociada
la dimensión. Cuando elimine la dimensión, también se eliminará el comportamiento. Si desea
mantener el comportamiento, elija los puntos suspensivos y haga clic en Copy (Copiar). Continúe
después con la eliminación del comportamiento. Si desea eliminar otra dimensión, siga los pasos de
esta sección.
706
Monitorización del comportamiento
de dispositivos no registrados
4. Seleccione Actions (Acciones), Delete (Eliminar).
Monitorización del comportamiento de dispositivos no

registrados
AWS IoT Device Defender Detect permite identificar comportamientos inusuales en dispositivos que no
figuran en el registro de AWS IoT. Puede definir perfiles de seguridad que sean específicos de uno de los
siguientes tipos de destino:
• Todos los dispositivos

• Todos los dispositivos registrados (objetos en el registro de AWS IoT)
• Todos los dispositivos no registrados
• Los dispositivos de un grupo de objetos
Un perfil de seguridad define un conjunto de comportamientos esperados para los dispositivos de su

cuenta y especifica las acciones que se realizarán cuando se detecte una anomalía. Los perfiles de
seguridad deben asociarse al mayor número de destinos específicos para controlar con detalle qué
dispositivos se están evaluando en ese perfil.
707
Cómo utilizar AWS IoT Device Defender Detect
Los dispositivos no registrados deben proporcionar un identificador de cliente de MQTT o un nombre de

objeto coherentes (para los dispositivos que registran métricas de dispositivo) durante todo el ciclo de vida
del dispositivo, de forma que todas las infracciones y métricas se atribuyan al mismo dispositivo.
Important
Los mensajes registrados por los dispositivos se rechazan si el nombre del objeto contiene
caracteres de control o si el nombre del objeto tiene más de 128 bytes de caracteres con
codificación UTF-8.

1. Puede usar AWS IoT Device Defender Detect solo con las métricas del lado de la nube, pero si
pretende usar métricas notificadas por el dispositivo, primero debe implementar el SDK de AWS
IoT en sus dispositivos conectados a AWS IoT o en las gateways de dispositivos. Para obtener más
información, consulte Envío de métricas desde dispositivos (p. 711).
2. Considere la posibilidad de ver las métricas que sus dispositivos generan antes de definir
comportamientos y crear alarmas. AWS IoT puede recopilar métricas de sus dispositivos, por lo que
puede identificar en primer lugar un comportamiento habitual o inusual de un grupo de dispositivos
o de todos los dispositivos de su cuenta. Use CreateSecurityProfile (p. 720), pero especifique solo
aquellas métricas de additionalMetricsToRetain que le interesen. No especifique behaviors
en este punto.
Utilice la consola de AWS IoT para analizar sus métricas de dispositivos y determinar qué constituye
un comportamiento típico para sus dispositivos.
3. Cree un conjunto de comportamientos para el perfil de seguridad. Los comportamientos
contienen métricas que especifican el comportamiento normal de un grupo de dispositivos o
de todos los dispositivos de su cuenta. Para obtener más información y ejemplos, consulte
Métricas (p. 688). Después de crear un conjunto de comportamientos, puede validarlos con
ValidateSecurityProfileBehaviors (p. 733).
4. Utilice la acción CreateSecurityProfile (p. 720) para crear un perfil de seguridad que incluya los
comportamientos. Puede utilizar el parámetro alertTargets para enviar alertas a un destino (un
tema de SNS) cuando un dispositivo vulnere un comportamiento. (Si envía alertas usando SNS, tenga
en cuenta que estas se tendrán en cuenta para calcular la cuota de temas de SNS de la cuenta de
AWS. Si se produce una gran oleada de infracciones, podría superarse la cuota de temas de SNS.
También puede utilizar las métricas de CloudWatch para comprobar las vulneraciones. Para obtener
Las métricas mostradas por AWS IoT proporcionan información que puede analizar de
diferentes maneras. Los siguientes casos de uso se basan en una situación en la que
tiene diez objetos que se conectan a Internet una vez al día. Cada día:
• Diez objetos se conectan con AWS IoT casi al mismo tiempo.
• Cada objeto se suscribe a un filtro de temas y, a continuación, espera una hora

antes de desconectarse. Durante este período, los objetos se comunican entre sí y
obtienen más información sobre el estado del mundo.
• Cada objeto publica alguna percepción que tenga según los datos que acaba de
encontrar utilizando UpdateThingShadow.
• Cada objeto se desconecta de AWS IoT.
Estos temas exploran algunas de las preguntas que podría tener en esta situación
para comenzar.
• ¿Cómo se me puede enviar una notificación si mis objetos no se conectan

correctamente cada día? (p. 228)
708
• ¿Cómo se me puede enviar una notificación si mis objetos no publican datos cada
día? (p. 229)
• ¿Cómo se me puede enviar una notificación si las actualizaciones de la sombra de

mi objeto se rechazan cada día? (p. 229)
(p. 227).
5. Utilice la acción AttachSecurityProfile (p. 717) para asociar el perfil de seguridad a un grupo de
dispositivos (un grupo de objetos), a todos los objetos registrados en la cuenta, a todos los objetos no
registrados o a todos los dispositivos. AWS IoT Device Defender Detect comienza comprobando si
hay un comportamiento anómalo, y si se detectan vulneraciones del comportamiento, envía alertas.
Es posible que desee asociar un perfil de seguridad a todos los objetos no registrados si, por ejemplo,
tiene previsto interactuar con dispositivos móviles que no están en el registro de objetos de su cuenta.
Puede definir diferentes conjuntos de comportamientos para diferentes grupos de dispositivos para
satisfacer sus necesidades.
Para asociar un perfil de seguridad a un grupo de dispositivos, debe especificar el ARN del grupo de
objetos que los contiene. El ARN de un grupo de objetos tiene el siguiente formato:
arn:aws:iot:region:account-id:thinggroup/thing-group-name
Para asociar un perfil de seguridad a todos los objetos registrados en una cuenta de AWS (y omitir los
objetos no registrados), debe especificar un ARN con el siguiente formato.
arn:aws:iot:region:account-id:all/registered-things
Para asociar un perfil de seguridad a todos los objetos no registrados, debe especificar un ARN con el
siguiente formato:
arn:aws:iot:region:account-id:all/unregistered-things
Para asociar un perfil de seguridad a todos los dispositivos, debe especificar un ARN con el siguiente
formato:
arn:aws:iot:region:account-id:all/things
6. También puede realizar un seguimiento de las infracciones con la acción

ListActiveViolations (p. 725), que le permite ver qué infracciones se han detectado en un perfil de
seguridad o dispositivo de destino determinado.
Utilice la acción ListViolationEvents (p. 729) para ver qué infracciones se detectaron durante un
período de tiempo especificado. Puede filtrar estos resultados por un dispositivo o perfil de seguridad.
7. Si sus dispositivos infringen los comportamientos definidos con demasiada frecuencia o no lo
suficiente, debe ajustar el comportamiento.
8. Para revisar los perfiles de seguridad que se han configurado y los dispositivos
que se están monitoreando, utilice las acciones ListSecurityProfiles (p. 727),
ListSecurityProfilesForTarget (p. 728) y ListTargetsForSecurityProfile (p. 729).
Utilice la acción DescribeSecurityProfile (p. 724) para obtener más detalles sobre un perfil de
seguridad.
9. Para actualizar un perfil de seguridad, utilice la acción UpdateSecurityProfile (p. 732). Utilice
la acción DetachSecurityProfile (p. 725) para desconectar un perfil de seguridad de destino de
una cuenta o grupo de objetos. Utilice la acción DeleteSecurityProfile (p. 722) para eliminar
completamente un perfil de seguridad.
709
Permisos
Permisos
Esta sección contiene información sobre cómo configurar los roles y políticas de IAM necesarios para
administrar AWS IoT Device Defender Detect. Para obtener más información, consulte la Guía del usuario
de IAM.
Otorgar permiso a AWS IoT Device Defender Detect para

publicar alertas en un tema de SNS
Si utiliza el parámetro alertTargets en CreateSecurityProfile (p. 720), debe especificar un rol de IAM
con dos políticas: una política de permisos y una política de confianza. La política de permisos concede
permiso a AWS IoT Device Defender para publicar notificaciones en su tema de SNS. La política de
confianza otorga permiso a AWS IoT Device Defender para asumir el rol requerido.
{
"Version":"2012-10-17",
"Statement":[
{
"Effect":"Allow",
"Action":[
"sns:Publish"
],
"Resource":[
"arn:aws:sns:region:account-id:your-topic-name"
]
}
]
}
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
"Principal": {
},
}
]
}
Política para pasar roles
También necesita una política de permisos de IAM asociada al usuario de IAM que permita al usuario
pasar roles. Consulte Concesión de permisos a un usuario para transferir un rol a un servicio de AWS.
{
"Version": "2012-10-17",
"Statement": [
{
"Sid": "",
"Effect": "Allow",
710
Envío de métricas desde dispositivos
"Action": [
"iam:GetRole",
"iam:PassRole"
],
"Resource": "arn:aws:iam::account-id:role/Role_To_Pass"
}
]
}

AWS IoT Device Defender Detect puede recopilar, agregar y monitorear los datos de métricas generados
por los dispositivos de AWS IoT para identificar aquellos dispositivos que muestran un comportamiento
anómalo. En esta sección, se explica cómo enviar métricas desde un dispositivo a AWS IoT Device
Defender.
Debe implementar de forma segura el SDK de AWS IoT en los dispositivos o las gateway de dispositivos
conectados a AWS IoT para recopilar métricas del lado del dispositivo. AWS IoT Device Defender
proporciona agentes de muestra que puede utilizar como ejemplos para crear el suyo propio. Si no puede
proporcionar las métricas del dispositivo, podrá disfrutar de una funcionalidad limitada a través de las
métricas del lado de la nube.
Tenga en cuenta lo siguiente:
• Actualmente, tiene disponible un ejemplo de agente de informes de métricas de dispositivo en C

en https://github.com/aws-samples/aws-iot-device-defender-agent-c. También hay un ejemplo de
Python de un agente que genera informes sobre las métricas de un dispositivo en GitHub, en https://
github.com/aws-samples/aws-iot-device-defender-agent-sdk-python. En concreto, consulte el archivo
greengrass_defender_agent.py.
• Para utilizar los agentes de muestra o crear su propio agente personalizado, debe instalar el SDK para
dispositivos de AWS IoT. Si desea buscar recursos en su lenguaje de desarrollo, consulte Recursos de
AWS IoT Core.
• Todos los agentes deben crear una conexión con AWS IoT y publicar las métricas en uno de estos
temas de MQTT de AWS IoT Device Defender reservados:
$aws/things/THING_NAME/defender/metrics/json
o bien
$aws/things/THING_NAME/defender/metrics/cbor
AWS IoT Device Defender utiliza uno de estos temas para responder con el estado de recepción de los
informes de métricas:
$aws/things/THING_NAME/defender/metrics/json/accepted
$aws/things/THING_NAME/defender/metrics/cbor/accepted
$aws/things/THING_NAME/defender/metrics/json/rejected
$aws/things/THING_NAME/defender/metrics/cbor/rejected
• Para notificar las métricas, un dispositivo debe registrarse como un objeto en AWS IoT.
711
• Por lo general, un dispositivo debería enviar un informe de métrica una vez cada 5 minutos. Los
dispositivos pueden enviar cómo máximo un informe de métricas cada 5 minutos. (Un dispositivo no
puede realizar más que un informe de métricas cada 5 minutos).
• Los dispositivos debe informar de las métricas actuales. No se permite realizar informes históricos de
métricas.
• Puede utilizar Trabajos (p. 413) para establecer el intervalo de informes de métricas de las instancias del
agente de informes de métricas. En las muestras de AWS IoT Device Defender Agent C, se incluye un
ejemplo. Para obtener más información, consulte el archivo README.md.
Especificación de documentos de métricas de dispositivos

Estructura general
Nombre largo Nombre corto Obligatorio Tipo Restricciones Notas
header hed S Objeto Bloque

completo
obligatorio
para componer
un informe
correcto.
métricas met S Objeto Bloque

completo
obligatorio
para componer
un informe
correcto.
Bloque de encabezado
Nombre largo Nombre corto Obligatorio Tipo Restricciones Notas
report_id rid S Entero Valor

monotónico en
aumento. Se
recomienda
una marca
temporal
Epoch.
version v S Cadena Major.Minor Incrementos

de versiones
secundarias
con suma
de campo.
Incrementos
de versiones
principales si
se eliminan las
métricas.
Bloque de métricas:
712
Conexiones de TCP
Nombre Nombre Elemento Obligatorio Tipo Restricciones Notas

largo corto principal
tcp_connectionstc métricas N Objeto
established_connections
ec tcp_connectionsN Lista<Conexión> Estado
de TCP
establecido
connections cs established_connections
N Lista<Objeto>
remote_addr rad connections S Número ip:port La IP puede

ser IPv6 o
IPv4
local_port lp connections N Número >= 0
local_interface li connections N Cadena Nombre de

la interfaz
total t established_connections
N Número >= 0 Número de
conexiones
establecidas
Puertos TCP de escucha

listening_tcp_ports
tp métricas N Objeto
ports pts listening_tcp_ports

N Lista<Puerto> > 0
port pt ports N Número >0 Los puertos

deben ser
números
mayores que
0
interface if ports N Cadena Nombre de

la interfaz
total t listening_tcp_ports
N Número >= 0
Puertos UDP de escucha

listening_udp_ports
up métricas N Objeto
ports pts listening_udp_ports

N Lista<Puerto> > 0
port pt ports N Número >0 Los puertos

deben ser
números
713

mayores que
0
interface if ports N Cadena Nombre de

la interfaz
total t listening_udp_ports
N Número >= 0
Estadísticas de la red

network_stats ns métricas N Objeto
bytes_in bi network_stats N Número Delta Metric,

>= 0
bytes_out bo network_stats N Número Delta Metric,

>= 0
packets_in pi network_stats N Número Delta Metric,

>= 0
packets_out po network_stats N Número Delta Metric,

>= 0
Example
La siguiente estructura JSON utiliza nombres largos.
{
"header": {
"report_id": 1530304554,
"version": "1.0"
},
"metrics": {
"listening_tcp_ports": {
"ports": [
{
"interface": "eth0",
"port": 24800
},
{
"port": 22
},
{
"port": 53
}
],
"total": 3
},
"listening_udp_ports": {
"ports": [
{
714
"port": 5353
},
{
"port": 67
}
],
"total": 2
},
"network_stats": {
"bytes_in": 29358693495,
"bytes_out": 26485035,
"packets_in": 10013573555,
"packets_out": 11382615
},
"tcp_connections": {
"established_connections": {
"connections": [
{
"local_interface": "eth0",
"local_port": 80,
"remote_addr": "192.168.0.1:8000"
},
{
"local_interface": "eth0",
"local_port": 80,
"remote_addr": "192.168.0.1:8000"
}
],
"total": 2
}
}
}
}
Example Ejemplo de una estructura JSON con nombres cortos
{
"hed": {
"rid": 1530305228,
"v": "1.0"
},
"met": {
"tp": {
"pts": [
{
"if": "eth0",
"pt": 24800
},
{
"if": "eth0",
"pt": 22
},
{
"if": "eth0",
"pt": 53
}
],
"t": 3
},
"up": {
"pts": [
{
715
Comandos de detección
"if": "eth0",
"pt": 5353
},
{
"if": "eth0",
"pt": 67
}
],
"t": 2
},
"ns": {
"bi": 29359307173,
"bo": 26490711,
"pi": 10014614051,
"po": 11387620
},
"tc": {
"ec" : {
"cs": [
{
"li": "eth0",
"lp": 80,
"rad": "192.168.0.1:8000"
},
{
"li": "eth0",
"lp": 80,
"rad": "192.168.0.1:8000"
}
],
"t": 2
}
}
}
}
Comandos de detección
Puede utilizar los comandos de AWS IoT Device Defender Detect de esta sección para identificar
comportamientos inusuales que podrían indicar que un dispositivo está comprometido.
Comandos de detección AWS IoT Device Defender

Nombre Descripción
AttachSecurityProfile (p. 717) Asocia un perfil de seguridad de AWS IoT Device

Defender a uno de los siguientes tipos de destino:

• Todos los dispositivos registrados (objetos en el
registro de AWS IoT)
CreateDimension (p. 718) Crea una dimensión que puede utilizar para limitar
el ámbito de los comportamientos que defina en un
perfil de seguridad de AWS IoT Device Defender.
CreateSecurityProfile (p. 720) Crea un perfil de seguridad de AWS IoT Device

Defender
716
AttachSecurityProfile
Nombre Descripción
DeleteDimension (p. 721) Elimina una dimensión si no hay ningún

comportamiento en los perfiles de seguridad de
AWS IoT Device Defender que haga referencia a
ella.
DeleteSecurityProfile (p. 722) Elimina un perfil de seguridad de AWS IoT Device

Defender
DescribeDimension (p. 722) Obtiene información sobre una dimensión que

se puede utilizar para limitar el ámbito de los
comportamientos de un perfil de seguridad de
AWS IoT Device Defender.
DescribeSecurityProfile (p. 724) Obtiene información sobre un perfil de seguridad

de AWS IoT Device Defender.
DetachSecurityProfile (p. 725) Desasocia un perfil de seguridad de AWS IoT

Device Defender de un grupo de objetos o de esta
cuenta de AWS.
ListActiveViolations (p. 725) Enumera las infracciones activas de un perfil de

seguridad de AWS IoT Device Defender.
ListDimensions (p. 726) Muestra las dimensiones definidas en la cuenta de

AWS.
ListSecurityProfiles (p. 727) Muestra los perfiles de seguridad de AWS IoT

Device Defender de la cuenta de AWS, incluidos
los perfiles que hacen referencia a una dimensión.
ListSecurityProfilesForTarget (p. 728) Enumera los perfiles de seguridad de AWS IoT

Device Defender que se han asociado a un destino
(grupo de objetos).
ListTargetsForSecurityProfile (p. 729) Enumera los destinos (grupos de objetos)

asociados con un perfil de seguridad de AWS IoT
Device Defender determinado.
ListViolationEvents (p. 729) Enumera las vulneraciones del perfil de seguridad

de AWS IoT Device Defender descubiertas durante
el período de tiempo determinado.
UpdateDimension (p. 730) Actualiza el valor de una dimensión definida para

su uso en los comportamientos de los perfiles de
seguridad.
UpdateSecurityProfile (p. 732) Actualiza un perfil de seguridad de AWS IoT

Device Defender.
ValidateSecurityProfileBehaviors (p. 733) Valida la especificación de comportamiento de un

perfil de seguridad de AWS IoT Device Defender.
AttachSecurityProfile
Asocia un perfil de seguridad de AWS IoT Device Defender a uno de los siguientes tipos de destino:
717
CreateDimension

• Todos los dispositivos registrados (objetos en el registro de AWS IoT)
Cada tipo de destino puede tener hasta cinco perfiles de seguridad asociados.
Para obtener más información, consulte AttachSecurityProfile en la referencia de la API.
Sinopsis:
aws iot attach-security-profile \

--security-profile-name <value> \
--security-profile-target-arn <value> \
{
"securityProfileName": "string",
"securityProfileTargetArn": "string"
}
Para asociar un perfil de seguridad a un grupo de dispositivos, debe especificar el ARN del grupo de
objetos que los contiene. El ARN de un grupo de objetos tiene el siguiente formato:
arn:aws:iot:region:account-id:thinggroup/thing-group-name
Para asociar un perfil de seguridad a todos los objetos registrados en una cuenta (y omitir los objetos no
registrados), debe especificar un ARN con el siguiente formato:
arn:aws:iot:region:account-id:all/registered-things
Para asociar un perfil de seguridad a todos los objetos no registrados, debe especificar un ARN con el
siguiente formato:
arn:aws:iot:region:account-id:all/unregistered-things
Para asociar un perfil de seguridad a todos los dispositivos, debe especificar un ARN con el siguiente
formato:
arn:aws:iot:region:accountid:all/things
CreateDimension
Cree una dimensión para controlar el ámbito de comportamiento de un perfil de seguridad de AWS
IoT Device Defender. El ámbito se define proporcionando un valor o patrón que se utiliza como
filtro. TOPIC_FILTER es la única dimensión admitida actualmente. En el caso de las dimensiones
TOPIC_FILTER, este filtro especifica el subconjunto de temas de MQTT a los que se aplica el
comportamiento. Las dimensiones admiten los caracteres comodín # y + de MQTT, así como la variable
${iot:clientiD}.
718
CreateDimension
Para agregar una dimensión a un perfil de seguridad, consulte CreateSecurityProfile (p. 720).
Para obtener más información, consulte CreateDimension en la referencia de la API.
Sinopsis:

--name <value> \
--type <value> \
--string-values <value> \
[--client-request-token <value>] \
Note
Si omite clientRequestToken, se genera automáticamente un token de solicitud de cliente

único.
Example
En este ejemplo, se crea una dimensión denominada TopicFilterForAuthMessages que filtra los temas de
MQTT que coinciden con el patrón device/+/auth. La dimensión se aplica a un comportamiento de un perfil
de seguridad.

--name TopicFilterForAuthMessages --type TOPIC_FILTER --string-values device/+/auth
La respuesta será similar a la siguiente:
{
"arn": "arn:aws:iot:eu-west-2:123456789012:dimension/TopicFilterForAuthMessages"
}
Example
En este ejemplo, se crea una dimensión llamada MyFavoriteTopics con varios temas.

--name MyFavoriteTopics --type TOPIC_FILTER \ --string-values topic1 topic2
{
"clientRequestToken": "string",
"tags": [
{
"Key": "string",
"Value": "string"
}
],
"type": "string",
"string-values": "string"
}
719
CreateSecurityProfile
Salida:
{
"arn": "string",
"name": "string"
}
CreateSecurityProfile
Crea un perfil de seguridad de AWS IoT Device Defender
Para obtener más información, consulte CreateSecurityProfile en la referencia de la API.
Sinopsis:

[--security-profile-description <value>] \
[--behaviors <value>] \
[--alert-targets <value>] \
[--additional-metrics-to-retain <value>] \
[--tags <value>] \
Example
Para definir un comportamiento con una dimensión, utilice el campo MetricDimension
situado junto a la métrica. Para conservar una métrica con una dimensión, utilice el campo
AdditionalMetricsToRetainV2. MetricDimension tiene un campo de operador que permite invertir
filtros de tema.
En el ejemplo siguiente, se muestra una definición que indica que no debería haber mensajes enviados a
otras dimensiones distintas de FavoriteTopics. Además, esta definición permite retener métricas sobre
el número de mensajes enviados al tema de autenticación.

--security-profile-name security-profile-for-smart-lights \
--behaviors '[{
"name": "num-messages-sent-to-unexpected-topic",
"metricDimension": {
"dimensionName": "FavoriteTopics",
"operator": "NOT_IN"
},
"criteria": {
"value": {"count": 1},
"durationSeconds": 300
}}]' \
--additional-metrics-to-retain-v2 '[{
"metricDimension": {"dimensionName": "TopicFilterForAuthMessages"}
}]'
Example
720
DeleteDimension
{
"additionalMetricsToRetainV2": [ "string" ],
"alertTargets": {
"string" : {
"alertTargetArn": "string",
"roleArn": "string"
}
},
"behaviors": [
{
"criteria": {
"comparisonOperator": "string",
"consecutiveDatapointsToAlarm": number,
"consecutiveDatapointsToClear": number,
"durationSeconds": number,
"statistic": "string"
},
"value": {
"cidrs": [ "string" ],
"count": number,
"ports": [ number ]
}
},
"metricDimension": [ "string" ],
"metric": "string",
"name": "string"
}
],
"securityProfileDescription": "string",
"tags": [
{
"Key": "string",
"Value": "string"
}
]
}
Salida:
{
"securityProfileArn": "string"
}
DeleteDimension
Elimina una dimensión de AWS IoT Device Defender. Solo se pueden eliminar las dimensiones que no se
estén utilizando en ningún perfil de seguridad.
Para eliminar una dimensión, primero debe desconectar la dimensión del comportamiento del perfil de
seguridad. Para obtener información, consulte UpdateSecurityProfile (p. 732).
Para obtener más información, consulte DeleteDimension en la referencia de la API.
Sinopsis:
aws iot delete-dimension \

--name <value> \
721
DeleteSecurityProfile
Ejemplo
En este ejemplo, se elimina la dimensión llamada TopicFilterForAuthMessages.
aws iot delete-dimension --name TopicFilterForAuthMessages
Este comando no devuelve ninguna respuesta.
{
"name": "string",
"arn": "string",
}
Salida:
Ninguna
DeleteSecurityProfile
Elimina un perfil de seguridad de AWS IoT Device Defender
Para obtener más información, consulte DeleteSecurityProfile en la referencia de la API.
Sinopsis:
aws iot delete-security-profile \

{
"expectedVersion": "long"
}
Salida:
Ninguna
DescribeDimension
Obtiene información sobre una dimensión que se puede utilizar en comportamientos de un perfil de
seguridad de AWS IoT Device Defender.
Para obtener más información, consulte DescribeDimension en la referencia de la API.
722
DescribeDimension
Sinopsis:
aws iot describe-dimension \

--name <value> \
Example
En este ejemplo, se obtiene la definición de la dimensión TopicFilterForAuthMessages.
aws iot describe-dimension --name TopicFilterForAuthMessages
{
"arn": "arn:aws:iot:eu-west-2:1123456789012:dimension/TopicFilterForAuthMessages",
"stringValues": [
"device/+/auth"
],
"creationDate": 1578620223.255,
}
{
"name": "string"
}
Salida:
{
"arn": "string",
"name": "string",
"type": "string",
"string-values": "string",
"additional-metrics-to-retain-v2": [ "string" ]
}
Example
aws iot describe-dimension --name myAdminTopicDimension
{
"string-values": "device/+/auth",
"creationDate": 1578620223.255,
723
DescribeSecurityProfile
DescribeSecurityProfile
Obtiene información sobre un perfil de seguridad de AWS IoT Device Defender.
Para obtener más información, consulte DescribeSecurityProfile en la referencia de la API.
Sinopsis:
aws iot describe-security-profile \

{
"securityProfileName": "string"
}
Salida:
{
"securityProfileArn": "string",
"behaviors": [
{
"name": "string",
"metricDimension": [ "string ],
"metric": "string",
"criteria": {
"value": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
"durationSeconds": "integer",
"consecutiveDatapointsToAlarm": "integer",
"consecutiveDatapointsToClear": "integer",
}
}
}
],
"alertTargets": {
"string": {
"roleArn": "string"
}
},
"additionalMetricsToRetain": [
"string"
],
724
DetachSecurityProfile
"version": "long",
"creationDate": "timestamp",
"lastModifiedDate": "timestamp"
}
DetachSecurityProfile
Desasocia un perfil de seguridad de AWS IoT Device Defender de un grupo de objetos o de esta cuenta de
AWS.
Para obtener más información, consulte DetachSecurityProfile en la referencia de la API.
Sinopsis:
aws iot detach-security-profile \

{
}
Salida:
Ninguno
ListActiveViolations
Enumera las infracciones activas de un perfil de seguridad de AWS IoT Device Defender.
Para obtener más información, consulte ListActiveViolations en la referencia de la API.
Sinopsis:
aws iot list-active-violations \

[--thing-name <value>] \
[--security-profile-name <value>] \
{
}
Salida:
725
ListDimensions
{
"activeViolations": [
{
"violationId": "string",
"behavior": {
"name": "string",
"dimensionNames": [ "string" ],
"metric": "string",
"criteria": {
"value": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
}
}
},
"lastViolationValue": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
"lastViolationTime": "timestamp",
"violationStartTime": "timestamp"
}
],
}
ListDimensions
Muestra las dimensiones definidas en la cuenta de AWS que puede utilizar en los perfiles de seguridad de
AWS IoT Device Defender.
Para ver todos los perfiles de seguridad en los que se aplica una dimensión, utilice
ListSecurityProfiles (p. 727).
Para obtener más información, consulte ListDimensions en la referencia de la API.
Sinopsis:
aws iot list-dimensions \

726
ListSecurityProfiles
Example
En este ejemplo, se muestran todas las dimensiones definidas para la cuenta de AWS.
aws iot list-dimensions
{
}
Salida:
{
}
ListSecurityProfiles
Muestra los perfiles de seguridad de AWS IoT Device Defender de la cuenta de AWS. Puede usar filtros
para enumerar solo los perfiles de seguridad asociados con un grupo de objetos o solo los asociados con
su cuenta.
Para obtener más información, consulte ListSecurityProfiles en la referencia de la API.
Sinopsis:

Example
En el ejemplo siguiente, se muestran todos los perfiles de seguridad que tienen comportamientos que
utilizan la dimensión TopicFilterForAuthMessages.

--dimension-name TopicFilterForAuthMessages
{
{
"name": "ExpectedBehaviorsForSmartDevice",
"arn": "arn:aws:iot:eu-west-2:123456789012:securityprofile/
ExpectedBehaviorsForSmartDevice"
}
]
}
727
ListSecurityProfilesForTarget
{
}
Salida:
{
{
"name": "string",
"arn": "string"
}
],
}
ListSecurityProfilesForTarget
Enumera los perfiles de seguridad de AWS IoT Device Defender que se han asociado a un destino (grupo
de objetos).
Para obtener más información, consulte ListSecurityProfilesForTarget en la referencia de la API.
Sinopsis:
aws iot list-security-profiles-for-target \

[--recursive | --no-recursive] \
{
"recursive": "boolean",
}
Salida:
{
"securityProfileTargetMappings": [
{
"securityProfileIdentifier": {
"name": "string",
"arn": "string"
},
"target": {
"arn": "string"
}
}
],
728
ListTargetsForSecurityProfile
}
ListTargetsForSecurityProfile
Enumera los destinos (grupos de objetos) asociados con un perfil de seguridad de AWS IoT Device
Defender determinado.
Para obtener más información, consulte ListTargetsForSecurityProfile en la referencia de la API.
Sinopsis:
aws iot list-targets-for-security-profile \

{
}
Salida:
{
"securityProfileTargets": [
{
"arn": "string"
}
],
}
ListViolationEvents
Enumera las vulneraciones del perfil de seguridad de AWS IoT Device Defender descubiertas durante el
período de tiempo determinado. Puede usar filtros para limitar los resultados a aquellas alertas emitidas
para un perfil de seguridad, comportamiento u objeto en concreto (dispositivo).
Para obtener más información, consulte ListViolationEvents en la referencia de la API.
Sinopsis:
aws iot list-violation-events \

[--thing-name <value>] \
[--security-profile-name <value>] \
729
UpdateDimension
{
"endTime": "timestamp",
}
Salida:
{
"violationEvents": [
{
"violationId": "string",
"behavior": {
"name": "string",
"metric": "string",
"criteria": {
"value": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
}
}
},
"metricValue": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
"violationEventType": "string",
"violationEventTime": "timestamp"
}
],
}
UpdateDimension
Actualice una dimensión para cambiar el ámbito de la métrica de un perfil de seguridad de AWS IoT Device
Defender. El ámbito se define proporcionando un valor o patrón que se utiliza como filtro. En el caso de las
730
UpdateDimension
dimensiones TOPIC_FILTER, este filtro especifica el subconjunto de temas de MQTT a los que se aplica el
comportamiento.
Para obtener más información, consulte UpdateDimension en la referencia de la API.
Sinopsis:

--name <value> \
--string-values <value> \
[--client-request-token <value>] \
Example
En este ejemplo, se actualiza una dimensión llamada TopicFilterForAuthMessages estableciendo un patrón

que filtra los temas de MQTT que coinciden con el patrón device/+/auth. La dimensión se aplica a un
comportamiento de un perfil de seguridad.

--name TopicFilterForAuthMessages --string-values device/+/auth
{
"creationDate": 1578620223.255,
"string-values": "device/+/auth"
}
{
}
Salida:
{
"arn": "string",
"name": "string",
"type": "string",
}
731
UpdateSecurityProfile
UpdateSecurityProfile
Actualiza un perfil de seguridad de AWS IoT Device Defender.
Para obtener más información, consulte UpdateSecurityProfile en la referencia de la API.
Sinopsis:
aws iot update-security-profile \

[--security-profile-description <value>] \
[--behaviors <value>] \
[--alert-targets <value>] \
[--additional-metrics-to-retain <value>] \
[--delete-behaviors | --no-delete-behaviors] \
[--delete-alert-targets | --no-delete-alert-targets] \
[--delete-additional-metrics-to-retain | --no-delete-additional-metrics-to-retain] \
{
"behaviors": [
{
"name": "string",
"metric": "string",
"criteria": {
"value": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
}
}
}
],
"alertTargets": {
"string": {
"roleArn": "string"
}
},
"string"
],
"deleteBehaviors": "boolean",
"deleteAlertTargets": "boolean",
"deleteAdditionalMetricsToRetain": "boolean",
732
ValidateSecurityProfileBehaviors
"expectedVersion": "long"
}
Salida:
{
"securityProfileArn": "string",
"behaviors": [
{
"name": "string",
"metric": "string",
"criteria": {
"value": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
}
}
}
],
"alertTargets": {
"string": {
"roleArn": "string"
}
},
"string"
],
"version": "long",
"creationDate": "timestamp",
"lastModifiedDate": "timestamp"
}
ValidateSecurityProfileBehaviors
Valida la especificación de comportamiento de un perfil de seguridad de AWS IoT Device Defender.
Para obtener más información, consulte ValidateSecurityProfileBehaviors en la referencia de la API.
Sinopsis:
aws iot validate-security-profile-behaviors \

--behaviors <value> \
733
Integración del agente de dispositivo
con AWS IoT Greengrass
{
"behaviors": [
{
"name": "string",
"metric": "string",
"criteria": {
"value": {
"count": "long",
"cidrs": [
"string"
],
"ports": [
"integer"
]
},
}
}
}
]
}
Salida:
{
"valid": "boolean",
"validationErrors": [
{
}
]
}
Integración del agente de dispositivo con AWS IoT

Greengrass
AWS IoT Device Defender se puede utilizar con AWS IoT Greengrass. La integración del agente del
dispositivo sigue el modelo estándar de implementación de la función Lambda de AWS IoT Greengrass, lo
que le permite agregar seguridad de AWS IoT Device Defender a sus dispositivos de núcleo de AWS IoT
Greengrass. Siga estos pasos para integrar un agente de dispositivo.
Requisitos previos:
• Configurar su entorno de AWS IoT Greengrass

• Configurar y ejecutar su núcleo de AWS IoT Greengrass.
• Asegúrese de que puede implementar y ejecutar con éxito una función Lambda en su núcleo de AWS
IoT Greengrass.
En general, el proceso que se describe aquí sigue las instrucciones que se detallan en la secciónCrear y
empaquetar una función Lambda de la Guía para desarrolladores de AWS IoT Greengrass.
734
Integración del agente de dispositivo
con AWS IoT Greengrass
Para crear un paquete Lambda
1. Clone el repositorio de muestras de Python de AWS IoT Device Defender.
git clone https://github.com/aws-samples/aws-iot-device-defender-agent-sdk-python.git
2. Cree y active un entorno virtual (opcional, pero recomendado).
pip install virtualenv

virtualenv metrics_lambda_environment
source metrics_lambda_environment/bin/activate
3. Instale el agente de AWS IoT Device Defender de ejemplo en el entorno virtual. Realice la instalación
desde PyPi.
pip install AWSIoTDeviceDefenderAgentSDK
4. Instale el código fuente descargado.
cd aws-iot-device-defender-agent-sdk-python
#This must be run from the same directory as setup.py
pip install .
5. Cree un directorio vacío para ensamblar su función Lambda. Este es el directorio Lambda.
mkdir metrics_lambda
cd metrics_lambda
6. Complete los pasos del 1 al 4 de Crear y empaquetar una función Lambda.

7. Descomprima el SDK de Python de AWS IoT Greengrass en su directorio Lambda.
unzip ../aws_greengrass_core_sdk/sdk/python_sdk_1_1_0.zip
cp -R ../aws_greengrass_core_sdk/examples/HelloWorld/greengrass_common .
cp -R ../aws_greengrass_core_sdk/examples/HelloWorld/greengrasssdk .
cp -R ../aws_greengrass_core_sdk/examples/HelloWorld/greengrass_ipc_python_sdk .
8. Copie el módulo AWSIoTDeviceDefenderAgentSDK en el nivel raíz del directorio Lambda.
cp -R ../aws-iot-device-defender-agent-sdk-python/AWSIoTDeviceDefenderAgentSDK .
9. Copie el agente de AWS IoT Greengrass en el nivel raíz de su directorio Lambda.
cp ../aws-iot-device-defender-agent-sdk-python/samples/greengrass/
greengrass_core_metrics_agent/greengrass_defender_agent.py .
10. Personalice el agente de AWS IoT Greengrass para que incluya el nombre de su dispositivo de AWS
IoT Greengrass principal y la velocidad de muestreo de las métricas que desee:
• Sustituya GREENGRASS_CORENAME por el nombre de su núcleo de AWS IoT Greengrass.

• Establezca SAMPLE_RATE_SECONDS en el intervalo de notificación de métricas que desee. El
intervalo de notificación más corto admitido por AWS IoT Device Defender es de 5 minutos (300
segundos).
11. Copie las dependencias de su entorno virtual (o su sistema) en el nivel raíz de su directorio Lambda.
cp -R ../metrics_lambda_environment/lib/python2.7/site-packages/psutil .
cp -R ../metrics_lambda_environment/lib/python2.7/site-packages/cbor .
735
para agentes de dispositivos
12. Cree un archivo zip de su función Lambda. Ejecute este comando en el nivel raíz de su directorio
Lambda.
rm *.zip
zip -r greengrass_defender_metrics_lambda.zip *
Para configurar e implementar una función Lambda de AWS IoT Greengrass
1. Cargue el archivo zip de lambda.

2. Seleccione el runtime Python 2.7 y especifique
greengrass_defender_agent.function_handler en el campo Handler (Controlador).
3. Configure la función Lambda como una función Lambda de larga duración.
4. Configure una suscripción desde su función Lambda a la nube de AWS IoT. En el caso de AWS IoT
Device Defender, no es necesario que la nube de AWS esté suscrita a la función Lambda.
5. Cree un recurso local para permitir que su función Lambda recopile métricas desde el host del núcleo
de AWS IoT Greengrass:
• Siga las instrucciones de Obtener acceso a recursos locales con funciones Lambda. Use los
siguientes parámetros:
• Nombre del recurso: Core Proc
• Escriba: Volume
• Ruta de origen: /proc
• Ruta de destino: /host_proc
• Permiso de acceso a los archivos del propietario del grupo: añadir automáticamente los permisos
de grupo de SO del grupo de Linux que posea el recurso
• Asocie el recurso con su función Lambda de métricas.
6. Implemente su función Lambda en el grupo de AWS IoT Greengrass.
Para consultar las métricas de un dispositivo AWS IoT Device Defender a través de la consola de
AWS IoT
1. Modifique temporalmente el tema de publicación en su función Lambda de AWS IoT Greengrass en

"metrics/test" (métricas/prueba).
2. Implemente la función Lambda.
3. Para ver las métricas que envía su núcleo de AWS IoT Greengrass, en la página Test (Probar) de la
consola de AWS IoT, añada una suscripción al tema temporal ("metrics/test").
Prácticas recomendadas de seguridad para

agentes de dispositivos
Privilegios mínimos
Al proceso del agente se debe otorgar solo los permisos mínimos necesarios para realizar sus tareas.
Mecanismos básicos
• El agente debe ejecutarse como un usuario no raíz.
• El agente se debe ejecutar como un usuario dedicado, en su propio grupo.
736
• Al usuario/grupo se le deben otorgar permisos de solo lectura sobre los recursos necesarios para
recopilar y transmitir métricas.
• Ejemplo: solo lectura en /proc /sys para el agente de muestra.
• Para obtener un ejemplo de cómo configurar un proceso para que se ejecute con permisos
reducidos, consulte las instrucciones de configuración que se incluyen con el agente de muestra de
Python.
Hay una serie de mecanismos Linux conocidos que pueden ayudarle a restringir o aislar aún más el
proceso de su agente:
Mecanismos avanzados
• CGroups
• SELinux
• Chroot
• Espacios de nombres Linux
Resiliencia operativa
Un proceso de agente debe ser resiliente a errores y excepciones operativas inesperados y no debe
bloquearse ni salir de forma permanente. El código debe manejar con soltura excepciones y, como
precaución, debe configurarse para reiniciarse automáticamente en caso de terminación inesperada
(por ejemplo, debido a reinicios del sistema o excepciones no detectadas).
Dependencias mínimas
Un agente debe usar el menor número posible de dependencias (es decir, bibliotecas de terceros)
en su implementación. Si el uso de una biblioteca se justifica debido a la complejidad de una tarea
(por ejemplo, Transport Layer Security), use solo dependencias bien mantenidas y establezca un
mecanismo para mantenerlas actualizadas. Si las dependencias agregadas contienen funcionalidades
que el agente no usa y que están activas de manera predeterminada (por ejemplo, abrir puertos,
sockets de dominio), desactívelas en su código o por medio de los archivos de configuración de la
biblioteca.
Aislamiento de procesos
Un proceso de agente solo debe contener la funcionalidad requerida para realizar la recopilación y la
transmisión de métricas del dispositivo. No debe aprovecharse de otros procesos del sistema como
un contenedor ni implementar funcionalidad para otros casos de uso fuera de su ámbito. Además, el
proceso del agente debe abstenerse de crear canales de comunicación de entrada como puertos de
socket de dominio y de servicio de red que permitirían que procesos locales o remotos interfiriesen en
su funcionamiento e influyesen en su integridad y aislamiento.
Sigilo
El nombre de un proceso de agente no debe contener palabras clave como seguridad, monitorización
o auditoría que indiquen su finalidad y valor de seguridad. Se debe optar por nombres genéricos de
códigos y nombres de procesos aleatorios y únicos en cada dispositivo. Se debe seguir el mismo
principio al asignar nombre al directorio en el que residen los binarios del agente y los nombres y
valores de los argumentos del proceso.
Información mínima compartida
Ningún artefacto de agente implementado en los dispositivos debe contener información confidencial
como credenciales con privilegios, depuración ni código muerto, o comentarios insertados o archivos
de documentación que revelen detalles sobre el procesamiento del lado del servidor de métricas
recopiladas por el agente u otros detalles sobre sistemas backend.
Transport Layer Security
Para establecer canales seguros de TLS para la transmisión de datos, un agente debe hacer cumplir
todas las validaciones del lado del cliente, como la validación de certificados y nombres de dominio en
737
el nivel de la aplicación, si no están habilitadas de manera predeterminada. Además, un agente debe

usar un almacén de certificados raíz que contenga entidades de confianza y no contenga certificados
que pertenezcan a emisores de certificados atacados.
Implementación segura
Cualquier mecanismo de implementación del agente, como inserción o sincronización de código y

repositorios que contengan sus binarios, código fuente y cualquier archivo de configuración (incluidos
certificados raíz de confianza), debe controlarse para evitar la inserción o alteración no autorizada
del código. Si el mecanismo de implementación se basa en la comunicación de red, se deben usar
métodos criptográficos para proteger la integridad de los artefactos de implementación en tránsito.
Documentación adicional
• Seguridad en AWS IoT (p. 122)
• Understanding the AWS IoT Security Model
• Redhat: A Bite of Python
• 10 common security gotchas in Python and how to avoid them
• What Is Least Privilege & Why Do You Need It?
• OWASP Embedded Security Top 10
• OWASP IoT Project
738
Mensajes de los eventos

Esta sección contiene información sobre los mensajes publicados por AWS IoT cuando se actualizan o se
modifican objetos o trabajos. Para obtener información sobre el servicio AWS IoT Events que le permite
crear detectores para monitorizar los dispositivos con la finalidad de ver si se producen errores o cambios
en su funcionamiento y para desencadenar acciones específicas cuando se produzcan, consulte AWS IoT
Events.
AWS IoT publica mensajes de eventos cuando se producen determinados eventos. Por ejemplo, el registro
genera eventos cuando se añaden, actualizan o eliminan objetos. Cada evento provoca que se envíe un
único mensaje de evento. Los mensajes de evento se publican a través de MQTT con una carga JSON. El
contenido de la carga depende del tipo de evento.
Note
Se garantiza que los mensajes de eventos se publican una vez. Es posible que se publiquen más
de una. No se garantiza el orden de los mensajes de eventos.
Para recibir mensajes de eventos, el dispositivo debe usar una política adecuada que le permita
conectarse a la gateway de dispositivos de AWS IoT y suscribirse a los temas de eventos de MQTT.
También debe suscribirse a los filtros de temas adecuados.
A continuación, mostramos un ejemplo de política necesaria para recibir eventos del ciclo de vida:
{
"Version":"2012-10-17",
"Statement":[{
"Effect":"Allow",
"Action":[
"iot:Subscribe",
"iot:Receive"
],
"Resource":[
"arn:aws:iot:region:account:/$aws/events/*"
]
}]
}
Puede controlar qué tipos de eventos se publican mediante una llamada a la API
UpdateEventConfigurations o utilizar el comando de la CLI update-event-configurations. Por ejemplo:
aws iot update-event-configurations --event-configurations "{\"THING\":{\"Enabled\": true}}"

Note
Todas las comillas (") van precedidas de barras diagonales invertidas (\).
Puede consultar las configuraciones de eventos actuales mediante una llamada a la API
DescribeEventConfigurations o utilizando el comando de la CLI describe-event-configurations. Por ejemplo:
aws iot describe-event-configurations
El resultado del comando describe-event-configurations tendrá un aspecto similar al siguiente:
{
"eventConfigurations": {
"THING_TYPE": {
739
Eventos de registro
"Enabled": false
},
"JOB_EXECUTION": {
"Enabled": false
},
"THING_GROUP_HIERARCHY": {
"Enabled": false
},
"CERTIFICATE": {
"Enabled": false
},
"THING_TYPE_ASSOCIATION": {
"Enabled": false
},
"THING_GROUP_MEMBERSHIP": {
"Enabled": false
},
"CA_CERTIFICATE": {
"Enabled": false
},
"THING": {
"Enabled": true
},
"JOB": {
"Enabled": false
},
"POLICY": {
"Enabled": false
},
"THING_GROUP": {
"Enabled": false
}
},
}
Eventos de registro
El registro publica mensajes de eventos cuando se crean, actualizan o eliminan objetos, tipos de objetos y
grupos de objetos. El registro admite actualmente los siguientes tipos de eventos:
Objeto creado, actualizado o eliminado
El registro publica los siguientes mensajes de eventos cuando se crean, actualizan o eliminan objetos:
• $aws/events/thing/<thingName>/created
• $aws/events/thing/<thingName>/updated
• $aws/events/thing/<thingName>/deleted
Los mensajes contienen la siguiente carga de ejemplo:
{
"eventType" : "THING_EVENT",
"eventId" : "f5ae9b94-8b8e-4d8e-8c8f-b3266dd89853",
"timestamp" : 1234567890123,
"operation" : "CREATED|UPDATED|DELETED",
"accountId" : "123456789012",
"thingId" : "b604f69c-aa9a-4d4a-829e-c480e958a0b5",
"thingTypeName" : null,
740
Eventos de registro
"attributes": {
"attribute3": "value3",
"attribute1": "value1",
"attribute2": "value2"
}
}
Las cargas contienen los siguientes atributos:

eventType
Se establece en "THING_EVENT".
eventId
Un ID de evento exclusivo (cadena).

timestamp
La marca de tiempo UNIX de cuándo se produjo el evento.

operación
La operación en la que se activó el evento. Los valores válidos son:

• CREATED
• UPDATED
• DELETED
accountId
thingId
El ID del objeto que se crea, actualiza o elimina.

thingName
El nombre del objeto que se crea, actualiza o elimina.

versionNumber
La versión del objeto que se crea, actualiza o elimina. Este valor se establece en 1 cuando se
crea un objeto. Aumenta en 1 cada vez que se actualiza el objeto.
thingTypeName
El tipo de objeto asociado al objeto, si existiera. De lo contrario, null.

attributes
Un conjunto de pares nombre-valor asociados al objeto.

Tipo de objeto creado, descartado, eliminado o al que se le ha quitado la marca de descartado
El registro publica los siguientes mensajes de eventos cuando se crean, se descartan, se eliminan o
se quita la marca de descartado de los tipos de objetos:
• $aws/events/thingType/<thingTypeName>/created
• $aws/events/thingType/<thingTypeName>/updated
• $aws/events/thingType/<thingTypeName>/deleted
El mensaje contiene la siguiente carga de ejemplo:
{
"eventType" : "THING_TYPE_EVENT",
"eventId" : "8827376c-4b05-49a3-9b3b-733729df7ed5",
"timestamp" : 1234567890123,
741
Eventos de registro
"accountId" : "123456789012",
"thingTypeId" : "c530ae83-32aa-4592-94d3-da29879d1aac",
"thingTypeName" : "MyThingType",
"isDeprecated" : false|true,
"deprecationDate" : null,
"searchableAttributes" : [ "attribute1", "attribute2", "attribute3" ],
"description" : "My thing type"
}

eventType
Se establece en "THING_TYPE_EVENT".
eventId

timestamp

operación

• CREATED
• UPDATED
• DELETED
accountId
thingTypeId
El ID del tipo de objeto que se crea o elimina, o que está descartado.

thingTypeName
El nombre del tipo de objeto que se crea o elimina, o que está descartado.
isDeprecated
true si el tipo de objeto está descartado. De lo contrario, devuelve false.

deprecationDate
La marca de tiempo UNIX para cuando el tipo de objeto está descartado.

searchableAttributes
Un conjunto de pares nombre-valor asociados con el tipo de objeto que puede utilizarse para
realizar búsquedas.
description
Una descripción del tipo de objeto.

Tipo de objeto asociado o desasociado de un objeto
El registro publica los siguientes mensajes de eventos cuando se asocia o desasocia un tipo de objeto
a un objeto.
• $aws/events/thingTypeAssociation/thing/<thingName>/<typeName>
742
Eventos de registro
"eventId" : "87f8e095-531c-47b3-aab5-5171364d138d",
"eventType" : "THING_TYPE_ASSOCIATION_EVENT",
"operation" : "CREATED|DELETED",
"thingName": "myThing",
"thingTypeName" : "MyThingType",
"timestamp" : 1234567890123,
}

eventId

eventType
Se establece en "THING_TYPE_ASSOCIATION_EVENT".
operación

• CREATED
• DELETED
thingId
El ID del objeto cuya asociación de tipo ha cambiado.

thingName
El nombre del objeto cuya asociación de tipo ha cambiado.

thingTypeName
El tipo de objeto asociado o desasociado del objeto.

timestamp

Grupo de objetos creado, actualizado o eliminado
El registro publica los siguientes mensajes de eventos cuando se crea, actualiza o elimina un grupo de
objetos.
• $aws/events/thingGroup/<groupName>/created
• $aws/events/thingGroup/<groupName>/updated
• $aws/events/thingGroup/<groupName>/deleted
{
"eventType" : "THING_GROUP_EVENT",
"eventId" : "87f8e095-531c-47b3-aab5-5171364d138d",
"timestamp" : 1234567890123,
"accountId" : "123456789012",
"thingGroupId" : "8f82a106-6b1d-4331-8984-a84db5f6f8cb",
"thingGroupName" : "MyRootThingGroup",
"parentGroupName" : null,
"parentGroupId" : null,
"description" : "My root thing group",
"rootToParentThingGroups" : null,
"attributes" : {
"attribute1" : "value1",
743
Eventos de registro
"attribute3" : "value3",
"attribute2" : "value2"
}
}

eventType
Se establece en "THING_GROUP_EVENT".
eventId

timestamp

operación

• CREATED
• UPDATED
• DELETED
accountId
thingGroupId
El ID del grupo de objetos que se crea, actualiza o elimina.

thingGroupName
El nombre del grupo de objetos que se crea, actualiza o elimina.

versionNumber
La versión del grupo de objetos. Este valor se establece en 1 cuando se crea un grupo de objetos.
Aumenta en 1 cada vez que se actualiza el grupo de objetos.
parentGroupName
El nombre del grupo principal de objetos, si existe.

parentGroupId
El ID del grupo principal de objetos, si existe.

description
Una descripción del grupo de objetos.

rootToParentThingGroups
Una matriz de información acerca del grupo principal de objetos. Hay una entrada para cada
grupo principal de objetos, que empieza por el elemento principal del grupo de objetos actual y
continúa hasta que se alcanza el grupo de objetos raíz. Cada entrada contiene el nombre del
grupo de objetos y el ARN del grupo de objetos.
attributes
Un conjunto de pares nombre-valor asociados al grupo de objetos.

Objeto añadido o eliminado de un grupo de objetos
El registro publica los siguientes mensajes de eventos cuando se añade un objeto a un grupo de
objetos o se elimina de este.
744
Eventos de registro
• $aws/events/thingGroupMembership/thingGroup/<thingGroupName>/
thing/<thingName>/added
• $aws/events/thingGroupMembership/thingGroup/<thingGroupName>/
thing/<thingName>/removed
{
"eventType" : "THING_GROUP_MEMBERSHIP_EVENT",
"eventId" : "d684bd5f-6f6e-48e1-950c-766ac7f02fd1",
"timestamp" : 1234567890123,
"operation" : "ADDED|REMOVED",
"accountId" : "123456789012",
"groupArn" : "arn:aws:iot:ap-northeast-2:123456789012:thinggroup/
MyChildThingGroup",
"groupId" : "06838589-373f-4312-b1f2-53f2192291c4",
"thingArn" : "arn:aws:iot:ap-northeast-2:123456789012:thing/MyThing",
"membershipId" : "8505ebf8-4d32-4286-80e9-c23a4a16bbd8"
}

eventType
Se establece en "THING_GROUP_MEMBERSHIP_EVENT".
eventId
El ID del evento.
timestamp

operación
ADDED cuando se añade un objeto a un grupo de objetos. REMOVED cuando se elimina un objeto
de un grupo de objetos.
accountId
groupArn
El ARN del grupo de objetos.

groupId
El ID del grupo.
thingArn
El ARN del objeto que se añadió o quitó del grupo de objetos.

thingId
El ID del objeto que se añadió o quitó del grupo de objetos.

membershipId
Un ID que representa la relación entre objeto y el grupo de objetos. Este valor se genera cuando
añade un objeto a un grupo de objetos.
Grupo de objetos añadido o eliminado de un grupo de objetos
El registro publica los siguientes mensajes de eventos cuando se añade un grupo de objetos a otro
grupo de objetos o se elimina de este.
745
Eventos de trabajos
• $aws/events/thingGroupHierarchy/thingGroup/<parentThingGroupName>/
childThingGroup/<childThingGroupName>/added
• $aws/events/thingGroupHierarchy/thingGroup/<parentThingGroupName>/
childThingGroup/<childThingGroupName>/removed
{
"eventType" : "THING_GROUP_HIERARCHY_EVENT",
"eventId" : "264192c7-b573-46ef-ab7b-489fcd47da41",
"timestamp" : 1234567890123,
"operation" : "ADDED|REMOVED",
"accountId" : "123456789012",
"thingGroupId" : "8f82a106-6b1d-4331-8984-a84db5f6f8cb",
"thingGroupName" : "MyRootThingGroup",
"childGroupId" : "06838589-373f-4312-b1f2-53f2192291c4",
"childGroupName" : "MyChildThingGroup"
}

eventType
Se establece en "THING_GROUP_HIERARCHY_EVENT".
eventId
El ID del evento.
timestamp

operación
ADDED cuando se añade un objeto a un grupo de objetos. REMOVED cuando se elimina un objeto
de un grupo de objetos.
accountId
thingGroupId
El ID del grupo principal de objetos.

thingGroupName
El nombre del grupo principal de objetos.

childGroupId
El ID del grupo secundario de objetos.

childGroupName
El nombre del grupo secundario de objetos.
Eventos de trabajos
El servicio Jobs de AWS IoT también publica en temas reservados en el protocolo MQTT cuando
los trabajos están pendientes, completados o cancelados y cuando un dispositivo informa del éxito
746
Eventos de trabajos
o del fracaso cuando se ejecuta un trabajo. Los dispositivos o las aplicaciones de administración y
monitorización pueden realizar un seguimiento del estado de los trabajos mediante la suscripción a estos
temas. Utilice la API UpdateEventConfigurations para controlar los tipos de eventos de trabajo que recibe.
Dado que cancelar o eliminar un trabajo puede llevar un tiempo, se envían dos mensajes para indicar
el comienzo y el final de una solicitud. Por ejemplo, cuando se inicia una solicitud de cancelación, se
envía un mensaje al tema $aws/events/job/jobID/cancellation_in_progress. Cuando finaliza
una solicitud de cancelación, se envía un mensaje al tema $aws/events/job/jobID/canceled.
En las solicitudes de eliminación de trabajos se lleva a cabo un proceso parecido. Las aplicaciones de
administración y monitorización pueden suscribirse a estos temas y hacer un seguimiento del estado de los
trabajos.
Para obtener más información acerca de cómo publicar en temas de MQTT y suscribirse a ellos, consulte
Agente de mensajes de AWS IoT (p. 266).
Trabajo completado, cancelado o eliminado
El servicio Jobs de AWS IoT publica un mensaje en un tema de MQTT cuando se completa, cancela o
elimina un trabajo, o bien cuando la cancelación o la eliminación está en curso:
• $aws/events/job/jobID/completed
• $aws/events/job/jobID/canceled
• $aws/events/job/jobID/deleted
• $aws/events/job/jobID/cancellation_in_progress
• $aws/events/job/jobID/deletion_in_progress
El mensaje completed contiene la siguiente carga de ejemplo:
{
"eventType": "JOB",
"eventId": "7364ffd1-8b65-4824-85d5-6c14686c97c6",
"timestamp": 1234567890,
"operation": "completed",
"jobId": "27450507-bf6f-4012-92af-bb8a1c8c4484",
"status": "COMPLETED",
"targetSelection": "SNAPSHOT|CONTINUOUS",
"targets": [
"arn:aws:iot:us-east-1:123456789012:thing/a39f6f91-70cf-4bd2-a381-9c66df1a80d0",
"arn:aws:iot:us-east-1:123456789012:thinggroup/2fc4c0a4-6e45-4525-
a238-0fe8d3dd21bb"
],
"description": "My Job Description",
"completedAt": 1234567890123,
"createdAt": 1234567890123,
"numberOfCanceledThings": 0,
"numberOfRejectedThings": 0,
"numberOfFailedThings": 0,
"numberOfRemovedThings": 0,
"numberOfSucceededThings": 3
}
}
El mensaje canceled contiene la siguiente carga de ejemplo:
{
"eventType": "JOB",
"eventId": "568d2ade-2e9c-46e6-a115-18afa1286b06",
"timestamp": 1234567890,
747
Eventos de trabajos
"operation": "canceled",
"jobId": "4d2a531a-da2e-47bb-8b9e-ff5adcd53ef0",
"targets": [
"arn:aws:iot:us-east-1:123456789012:thing/Thing0-947b9c0c-ff10-4a80-b4b3-
cd33d0145a0f",
"arn:aws:iot:us-east-1:123456789012:thinggroup/ThingGroup1-95c644d5-1621-41a6-9aa5-
ad2de581d18f"
],
"description": "My job description",
"createdAt": 1234567890123,
"lastUpdatedAt": 1234567890123
}
El mensaje deleted contiene la siguiente carga de ejemplo:
{
"eventType": "JOB",
"timestamp": 1234567890,
"operation": "deleted",
"status": "DELETED",
"targets": [
cd33d0145a0f",
"arn:aws:iot:us-east-1:123456789012:thinggroup/
ThingGroup1-95c644d5-1621-41a6-9aa5-ad2de581d18f"
],
"createdAt": 1234567890123,
"comment": "Comment for this operation"
}
El mensaje cancellation_in_progress contiene la siguiente carga de ejemplo:
{
"eventType": "JOB",
"timestamp": 1234567890,
"operation": "cancellation_in_progress",
"status": "CANCELLATION_IN_PROGRESS",
"targets": [
cd33d0145a0f",
],
"createdAt": 1234567890123,
}
El mensaje deletion_in_progress contiene la siguiente carga de ejemplo:
748
Eventos del ciclo de vida
"eventType": "JOB",
"timestamp": 1234567890,
"operation": "deletion_in_progress",
"status": "DELETION_IN_PROGRESS",
"targets": [
cd33d0145a0f",
],
"createdAt": 1234567890123,
}
Estado final de ejecución de trabajo
El servicio Jobs de AWS IoT publica un mensaje cuando un dispositivo actualiza la ejecución de un
trabajo al estado final:
• $aws/events/jobExecution/jobID/succeeded
• $aws/events/jobExecution/jobID/failed
• $aws/events/jobExecution/jobID/rejected
• $aws/events/jobExecution/jobID/canceled
• $aws/events/jobExecution/jobID/timed_out
• $aws/events/jobExecution/jobID/removed
• $aws/events/jobExecution/jobID/deleted
{
"eventType": "JOB_EXECUTION",
"eventId": "cca89fa5-8a7f-4ced-8c20-5e653afb3572",
"timestamp": 1234567890,
"operation": "succeeded|failed|rejected|canceled|removed|timed_out",
"jobId": "154b39e5-60b0-48a4-9b73-f6f8dd032d27",
"thingArn": "arn:aws:iot:us-east-1:123456789012:myThing/6d639fbc-8f85-4a90-924d-
a2867f8366a7",
"status": "SUCCEEDED|FAILED|REJECTED|CANCELED|REMOVED|TIMED_OUT",
"statusDetails": {
"key": "value"
}
}
Eventos del ciclo de vida

AWS IoT publica eventos del ciclo de vida en los temas MQTT tratados en las siguientes secciones. Estos
mensajes le permiten recibir notificaciones de los eventos del ciclo de vida desde el agente de mensajes.
Note
Es posible que los mensajes de ciclo de vida se envíen de forma desordenada. Puede que reciba
mensajes duplicados.
749
Eventos de conexión/desconexión
AWS IoT publica un mensaje en los siguientes temas MQTT cuando un cliente se conecta o se
desconecta:
• $aws/events/presence/connected/clientId: un cliente se ha conectado al agente de mensajes.

• $aws/events/presence/disconnected/clientId: un cliente se ha desconectado del agente de
mensajes.
A continuación, se muestra una lista de elementos JSON que se encuentran en los mensajes de conexión/
desconexión publicados en el tema $aws/events/presence/connected/clientId.
clientId
El ID del cliente que se conecta o se desconecta.

Note
Los ID de cliente que contienen los símbolos # o + no recibirán eventos del ciclo de vida.
clientInitiatedDisconnect
True si el cliente inició la desconexión. De lo contrario, devuelve false. Solo se encuentra en los
mensajes de desconexión.
disconnectReason
La razón por la que el cliente se está desconectando. Sólo se encuentra en mensajes de desconexión.
La tabla siguiente contiene valores válidos.
Motivo de desconexión Descripción
AUTH_ERROR El cliente no pudo autenticarse o la autorización

devolvió un error.
CLIENT_INITIATED_DISCONNECT El cliente indica que se desconectará. El cliente

puede hacerlo enviando un paquete de control
DISCONNECT de MQTT o un Close frame si el
cliente está utilizando una conexión WebSocket.
CLIENT_ERROR El cliente hizo algo mal que provocó su

desconexión. Por ejemplo, un cliente se
desconectará por enviar más de un paquete
CONNECT de MQTT en la misma conexión o si
el cliente intenta publicar con una carga útil que
supera el límite de carga útil.
CONNECTION_LOST La conexión cliente-servidor está cortada. Esto

puede ocurrir durante un período de alta latencia
de red o cuando se pierde la conexión a Internet.
DUPLICATE_CLIENTID El cliente está utilizando un ID de cliente que ya

está en uso. En este caso, el cliente que ya está
conectado se desconectará con esta razón de
desconexión.
FORBIDDEN_ACCESS No se permite la conexión del cliente. Por

ejemplo, un cliente con una dirección IP
denegada no podrá conectarse.
750
Motivo de desconexión Descripción
MQTT_KEEP_ALIVE_TIMEOUT Si no hay comunicación cliente-servidor para 1,5

veces el tiempo de mantenimiento del cliente, el
cliente se desconecta.
SERVER_ERROR Desconectado debido a problemas inesperados

del servidor.
SERVER_INITIATED_DISCONNECT El servidor desconecta de forma intencionada un

cliente por razones operativas.
THROTTLED El cliente se desconecta por exceder una

limitación controlada.
WEBSOCKET_TTL_EXPIRATION El cliente se desconecta porque un WebSocket

se ha conectado un tiempo superior a su valor de
tiempo de vida.
eventType
El tipo de evento. Los valores válidos son connected o disconnected.

ipAddress
La dirección IP del cliente que se conecta. Puede estar en formato IPv4 o IPv6. Sólo se encuentra en
los mensajes de conexión.
principalIdentifier
Las credenciales que se utilizan para la autenticación. En el caso de los certificados de autenticación
mutua de TLS, se trata del ID de certificado. En cuanto a las demás conexiones, se trata de las
credenciales de IAM.
sessionIdentifier
Un identificador único global de AWS IoT que existe durante toda la vida de la sesión.
timestamp
Aproximación del momento en que se produjo el evento, expresada en milisegundos según la fecha de
inicio Unix. La precisión de la marca de tiempo es de +/- 2 minutos.
versionNumber
El número de versión del evento del ciclo de vida. Se trata de un valor entero largo que aumenta de
forma monótona para cada conexión de un ID de cliente. El número de versión puede utilizarlo un
suscriptor para deducir el orden de los eventos del ciclo de vida.
Note
Los mensajes de conexión y desconexión de una conexión de cliente tienen el mismo número
de versión.
El número de versión podría saltarse algunos valores y no se garantiza que se vaya a
incrementar de forma coherente en 1 para cada evento.
Si un cliente no se conecta durante aproximadamente una hora, el número de versión se
restablece a 0. Para las sesiones persistentes, el número de versión se restablece a 0
después de que un cliente se haya desconectado durante un periodo mayor que el tiempo de
vida (TTL) configurado para la sesión persistente.
Un mensaje de conexión tiene la siguiente estructura.
751
Eventos de suscripción/cancelación de suscripción
{
"clientId": "186b5",
"timestamp": 1573002230757,
"eventType": "connected",
"sessionIdentifier": "a4666d2a7d844ae4ac5d7b38c9cb7967",
"principalIdentifier": "12345678901234567890123456789012",
"ipAddress": "192.0.2.0",
"versionNumber": 0
}
Un mensaje de desconexión tiene la siguiente estructura.
{
"timestamp": 1573002340451,
"eventType": "disconnected",
"sessionIdentifier": "a4666d2a7d844ae4ac5d7b38c9cb7967",
"principalIdentifier": "12345678901234567890123456789012",
"clientInitiatedDisconnect": true,
"disconnectReason": "CLIENT_INITIATED_DISCONNECT",
"versionNumber": 0
}
Gestión de desconexiones del cliente

La práctica recomendada consiste siempre en tener implementado un estado de espera para los eventos
del ciclo de vida, incluidos los mensajes Last Will and Testament (LWT). Cuando se recibe un mensaje
de desconexión, el código debe esperar un periodo de tiempo y verificar que un dispositivo sigue sin
conexión antes de tomar cualquier medida. Una forma de hacerlo consiste en utilizar colas con retraso
de SQS. Cuando un cliente recibe un evento de ciclo de vida o un mensaje LWT, se puede poner en cola
un mensaje (por ejemplo, durante 5 segundos). Cuando dicho mensaje está disponible y se procesa (por
parte de Lambda u otro servicio), primero se puede comprobar si el dispositivo sigue sin conexión antes de
tomar otras medidas.

AWS IoT publica un mensaje en el tema MQTT siguiente cuando un cliente se suscribe a un tema MQTT o
cancela su suscripción a este:
$aws/events/subscriptions/subscribed/clientId
$aws/events/subscriptions/unsubscribed/clientId
Donde clientId es el ID de cliente MQTT que se conecta con el agente de mensajes de AWS IoT.
El mensaje publicado en este tema tiene la estructura siguiente:
{
"timestamp": 1460065214626,
"eventType": "subscribed" | "unsubscribed",
"sessionIdentifier": "00000000-0000-0000-0000-000000000000",
752
"principalIdentifier": "000000000000/ABCDEFGHIJKLMNOPQRSTU:some-user/
ABCDEFGHIJKLMNOPQRSTU:some-user",
"topics" : ["foo/bar","device/data","dog/cat"]
}
A continuación, se ofrece una lista de elementos JSON que se encuentran en los mensajes suscritos y no
suscritos publicados en los temas $aws/events/subscriptions/subscribed/clientId y $aws/
events/subscriptions/unsubscribed/clientId.
clientId
El ID del cliente que se suscribe o cancela su suscripción.

Note
Los ID de cliente que contienen los símbolos # o + no recibirán eventos del ciclo de vida.
eventType
El tipo de evento. Los valores válidos son subscribed o unsubscribed.

principalIdentifier
Las credenciales que se utilizan para la autenticación. En el caso de los certificados de autenticación
mutua de TLS, se trata del ID de certificado. En cuanto a las demás conexiones, se trata de las
credenciales de IAM.
sessionIdentifier
Un identificador único global de AWS IoT que existe durante toda la vida de la sesión.
timestamp
Aproximación del momento en que se produjo el evento, expresada en milisegundos según la fecha de
inicio Unix. La precisión de la marca de tiempo es de +/- 2 minutos.
topics
Una matriz de los temas MQTT a los que se ha suscrito el cliente.
Note
Es posible que los mensajes de ciclo de vida se envíen de forma desordenada. Puede que reciba
mensajes duplicados.
753
Integración Alexa Voice Service

(AVS) para AWS IoT
Integración Alexa Voice Service (AVS) para AWS IoT es una nueva característica que incorpora Alexa
Voice en cualquier dispositivo conectado de forma económica sin generar costos de mensajería. AVS para
AWS IoT reduce los gastos y la complejidad de la integración de Alexa. Esta función utiliza AWS IoT para
transferir las tareas de audio que hacen un uso intensivo de procesos informáticos y de la memoria del
dispositivo a la nube. Gracias al ahorro de costos en la lista de materiales de ingeniería (eBoM), ahora los
fabricantes de dispositivos pueden incorporar Alexa en dispositivos IoT con recursos limitados de manera
más económica para permitir que los consumidores hablen directamente con Alexa en su hogar, oficina o
habitación del hotel y disfruten así de una experiencia de sonido ambiente.
Actualmente, los dispositivos de IoT domésticos inteligentes se fabrican con microcontroladores de bajo
costo (MCU) que tienen memoria limitada para ejecutar sistemas operativos en tiempo real. Anteriormente,
las soluciones AVS para productos integrados de Alexa requerían costosos dispositivos basados en
procesadores de aplicaciones con más de 50 MB de memoria ejecutándose en Linux o Android. Con
estos costosos requisitos de hardware, resultaba prohibitivo integrar Alexa Voice en dispositivos IoT con
recursos limitados. AVS para AWS IoT permite integrar la funcionalidad de Alexa en MCU, como la clase
de procesadores ARM Cortex M con menos de 1 MB de RAM integrada. Para ello, AVS transfiere las
tareas de memoria y computación a un dispositivo virtual de Alexa integrado en la nube. Esto reduce el
costo de eBoM hasta en un 50 %.
Para obtener más información sobre los procesadores de la serie ARM Cortex-M, consulte ARM o
Wikipedia. Para obtener más información acerca de los requisitos de hardware para los productos
integrados de Alexa, consulte Aumento de la CPU, la memoria y el almacenamiento del dispositivo
integrado de Alexa en el portal para desarrolladores de Amazon Alexa.
Note
AVS para AWS IoT está disponible en todas las regiones de AWS en las que el AWS IoT está
disponible, excepto en las regiones de China (Pekín y Ningxia). Para obtener la lista actual de
regiones de AWS, consulte la tabla de regiones de AWS.
AVS para AWS IoT tiene tres componentes:
• Un conjunto de temas de MQTT reservados para transferir mensajes de audio entre dispositivos
compatibles con Alexa y AVS.
• Un dispositivo virtual habilitado para Alexa en la nube que transfiere las tareas relacionadas con la
recuperación de medios, la descodificación de audio, la mezcla de audio y la administración del estado
del dispositivo físico al dispositivo virtual.
• Un conjunto de API que permiten la recepción y el envío de mensajes a través de temas reservados, la
interacción con el micrófono y el altavoz del dispositivo, y la administración del estado del dispositivo.
El siguiente diagrama ilustra cómo estos componentes funcionan juntos. También muestra cómo los
fabricantes de dispositivos utilizan el servicio Login with Amazon para autenticarse en el servicio AVS.
754
Introducción a Integración Alexa Voice Service
(AVS) para AWS IoT en un dispositivo NXP
Los fabricantes de dispositivos tienen dos opciones para comenzar a utilizar la integración de AVS para
AWS IoT .
• Kits de desarrollo: los kits de desarrollo lanzados por nuestros socios permiten empezar a utilizar
el servicio fácilmente. Los kits de desarrollo de NXP i.MX RT 106 A y Qualcomm Home Hub 100
Development Kit for Amazon AVS son los dos primeros kits disponibles en el mercado. Puede
encontrarlos en Kits de desarrollo para AVS. Los kits incluyen conectividad inmediata con AWS IoT,
algoritmos de audio aptos para AVS para captura de voz de largo alcance, cancelación de eco, Alexa
Wake Word y AVS para código de aplicación de AWS IoT. Puede usar el código de la aplicación para
crear rápidamente prototipos de un dispositivo y mover la implementación al diseño de MCU elegido
para las pruebas y producción de dispositivos cuando esté listo.
• Código de aplicación personalizado del lado del dispositivo: los desarrolladores también pueden
escribir una aplicación de AVS para AWS IoT personalizada mediante la API disponible públicamente.
La documentación de esta API está disponible en la página para desarrolladores de AVS. Puede
descargar el SDK de FreeRTOS y AWS IoT Device desde la consola de FreeRTOS (https://
console.aws.amazon.com/freertos/) o GitHub.
Para empezar a utilizar un kit de desarrollo NXP i.MX 106A, consulte Introducción a Integración Alexa
Voice Service (AVS) para AWS IoT en un dispositivo NXP.
Introducción a Integración Alexa Voice Service

(AVS) para AWS IoT en un dispositivo NXP
El kit de desarrollo NXP i.MX 106A le permite obtener una vista previa de Integración Alexa Voice Service
(AVS) para AWS IoT mediante una cuenta de NXP preconfigurada. Después de obtener una vista previa
755
Vista previa de Integración Alexa Voice Service (AVS)
para AWS IoT con una cuenta de NXP preconfigurada
de la funcionalidad con la cuenta de NXP, debe personalizar el firmware, el código fuente de la aplicación y
la aplicación móvil de NXP proporcionada con el kit para usar su propia cuenta. En este tema se describen
los pasos para obtener una vista previa con la cuenta preconfigurada y personalizar el dispositivo con su
propia cuenta.
Temas
• Vista previa de Integración Alexa Voice Service (AVS) para AWS IoT con una cuenta de NXP
preconfigurada (p. 756)
• Utilice sus cuentas de desarrollador de AWS y Alexa Voice Service para configurar AVS para AWS
IoT (p. 759)

Requisitos previos
Para seguir estos pasos, necesita los siguientes recursos.
• Kit de desarrollo NXP i.MX 106A

• Un equipo Mac, Windows 7/10 o Linux
• Un controlador serie que funcione con el equipo
• Un dispositivo móvil Android o iOS
• Android Debug Bridge (ADB)
• Una cuenta de Amazon Alexa
Instalar y arrancar el kit de desarrollo

1. Active el kit del dispositivo. El kit se distribuye con una tarjeta Get Started Onboarding. Esta tarjeta
contiene instrucciones para activar el kit y adquirir el paquete de software necesario y los archivos
de diseño de referencia. El paquete de software contiene el código fuente del SDK y la aplicación
Android auxiliar (VoiceCompanionApp.apk). Si utiliza un dispositivo iOS, debe solicitar acceso a la
aplicación TestFlight para iOS a su representante local de NXP.
Después de descargar y extraer el paquete de software, verá la siguiente estructura de archivos.
756
La carpeta MobileApplication contiene la aplicación móvil de Android.
La carpeta Tools contiene scripts que se utilizan para configurar el dispositivo.
También puede encontrar la siguiente documentación:
• SLN-ALEXA-IOT-DG.pdf en la Guía para desarrolladores de NXP

• SLN-ALEXA-IOT-MG.pdf en la Guía de migración de NXP
• SLN-ALEXA-IOT-UG.pdf en la Guía del usuario de NXP
2. Arranque el kit del dispositivo. El cable divisor USB que se distribuye con el kit tiene conexiones de
alimentación y datos.
a. Conecte ambas conexiones USB-A a su equipo.

b. Conecte el conector USB-C al kit. Es posible que la configuración sea similar a la de la imagen
siguiente.
Cuando la placa tenga alimentación, el LED D1 se iluminará con una luz verde. El LED D2 (más
cercano al altavoz) indica el estado del dispositivo. Cuando el dispositivo se enciende, este LED
parpadea en varios colores. Cuando el dispositivo ejecuta el código de la aplicación, el LED D2
parpadea en amarillo. Cuando se completa la inicialización del dispositivo, la luz del LED D2 cambia a
color naranja para indicar que está esperando a que se añadan las credenciales de la conexión wifi al
dispositivo.
La Guía del usuario de NXP contiene una descripción de los controles físicos del dispositivo.
757
3. Utilice la aplicación del terminal para saber cómo funciona la aplicación cliente en el dispositivo.
También puede usarla para depurar y asegurarse de que el dispositivo tenga el estado correcto.
Escriba los siguientes comandos para empezar a usar la aplicación:
• help: muestra una lista de los comandos disponibles.

• enable_usb_log: habilita el registro en el dispositivo. Esto le ayuda a saber lo que está haciendo
la aplicación.
• logs: muestra las últimas líneas de los registros. En este punto, los registros deben indicar que el
dispositivo está esperando las credenciales de la conexión wifi.
Conectar el dispositivo a AWS IoT y Amazon Alexa

1. Instale la aplicación móvil correspondiente. Si utiliza un dispositivo Android, puede usar ADB en el
terminal para instalar el archivo VoiceCompanionApp.apk. Si utiliza un dispositivo iOS, utilice la
aplicación TestFlight.
2. Aprovisione las credenciales de la conexión wifi. Puede aprovisionar las credenciales de la conexión
wifi mediante la aplicación móvil auxiliar o el terminal.
a. Siga estos pasos para aprovisionar las credenciales de la conexión wifi mediante la aplicación
móvil.
i. Cuando el dispositivo arranca desde su nuevo estado de fábrica, crea un punto de acceso
wifi. Abra la aplicación móvil auxiliar y elija WIFI PROVISION (APROVISIONAR WIFI) para
conectarse a este punto de acceso.
ii. Elija una red de la lista.
iii. Escriba su contraseña y elija Send (Enviar) para transmitir las credenciales al kit del
dispositivo.
758
Utilice sus cuentas de desarrollador de AWS y Alexa
Voice Service para configurar AVS para AWS IoT
b. En la aplicación del terminal, escriba el siguiente comando.
setup YourWiFiNetworkName YourWiFiNetworkPassword
c. Elija Enter (Intro).

3. Autentique el kit del dispositivo y conéctese a AWS IoT y a Amazon Alexa. Asegúrese de que el
dispositivo móvil y el kit del dispositivo están utilizando la misma red wifi para que los dos dispositivos
puedan comunicarse.
Para ello, pulse el botón Discover (Detectar) en la aplicación móvil. Cuando termine la detección,
verá una lista de números de serie de los kits de dispositivo disponibles que se encuentran cerca.
Si hay más de uno disponible, puede confirmar el número de serie único de su kit escribiendo
serial_number en la aplicación del terminal.
4. Elija el kit de dispositivo que desea usar. La aplicación móvil utiliza el servicio Login with Amazon
para solicitarle sus credenciales de usuario de Amazon. El kit del dispositivo comienza a registrar el
dispositivo en AVS. La luz del LED D2 cambia a morado para indicar que el registro del dispositivo ha
comenzado.
Note
Si su dispositivo móvil ya tiene instalada la aplicación de compras de Amazon, la aplicación

móvil auxiliar usa automáticamente la cuenta de Amazon utilizada para iniciar sesión en la
aplicación de compras.
Después de iniciar sesión en su cuenta de Amazon, la aplicación auxiliar realiza los siguientes pasos:
1. El kit del dispositivo recibe el token de acceso del servicio Login with Amazon y comienza a conectar el
dispositivo a AWS IoT y AVS. La aplicación móvil muestra un porcentaje de finalización. La luz del LED
D2 del dispositivo cambia a naranja.
2. El LED D1 parpadea en verde cada 500 milisegundos hasta que el dispositivo se conecta a AWS IoT.
3. Cuando el dispositivo se conecta a AWS IoT, el kit del dispositivo comienza a conectar el dispositivo a
AVS. El LED D1 parpadea en verde cada 250 milisegundos.
4. Cuando el dispositivo se conecta a AVS, el color del número de serie del kit del dispositivo cambia a
amarillo en la aplicación móvil. La aplicación móvil muestra el mensaje Complete (Completado). El LED
D1 se apaga y el dispositivo emite un sonido de campana. El dispositivo está ahora conectado a la
cuenta de AWS IoT de NXP.
Puede probar algunos comandos de Alexa Voice, como los siguientes:
• "Alexa, ¿qué tiempo hace?"

• "Alexa, dame un resumen de las noticias".
• "Alexa, pon música".

Requisitos previos
Para este procedimiento, necesita los siguientes recursos.
• Kit de desarrollo NXP i.MX 106A

• MCUXPresso v10.3.1
759
• Sonda de depuración de Segger J-Link

• Un equipo Mac
• Un dispositivo móvil Android
• Android Studio
• Android Debug Bridge
• Una cuenta de Amazon Alexa
• Una cuenta de AWS
Configurar su cuenta de AWS IoT y aprovisionar el dispositivo

1. Genere las credenciales con las que va a autenticarse en AWS IoT. Todos los dispositivos deben
tener un certificado de dispositivo, una clave privada y un certificado de CA raíz instalado para
comunicarse con AWS IoT. Siga las instrucciones de Registro de un dispositivo en el registro para
registrar su dispositivo en AWS IoT. Para obtener más información acerca de los certificados X.509,
consulte Certificados de cliente X.509 (p. 127).
2. Desplácese hasta la carpeta raíz y abra la Guía para desarrolladores de NXP. Siga las instrucciones
de la sección 9 (Sistema de archivos) para convertir los certificados y claves de cliente a un formato
binario que el sistema de archivos NXP pueda leer.
Utilice el siguiente script y los siguientes comandos para convertir los certificados y las claves. El script
bin_dump.py está en la carpeta Tools\Ivaldi.zip\Scripts\sln_alexa_iot_utils.
python3 bin_dump.py CertificateName-certificate.pem.crt CertificateName-

certificate.pem.crt.bin
python3 bin_dump.py CertificateName-private.pem.key CertificateName-private.pem.key.bin
Para obtener información acerca de las opciones para generar credenciales para dispositivos de
producción a escala, consulte Aprovisionamiento de dispositivos (p. 535).
Para configurar el dispositivo en la consola para desarrolladores de Alexa Voice Service
1. Vaya a la carpeta raíz y abra la Guía de migración de NXP.

2. Para obtener las firmas MD5 y SHA256 que necesita para crear una clave de API de AVS, siga
las instrucciones de la sección 2 "Creación de un almacén de claves para la aplicación Android
auxiliar de AVS" en la Guía de migración de NXP. (Esto incluye desplazarse hasta la consola para
desarrolladores de Alexa Voice Service).
3. Para crear un perfil de seguridad de Login with Amazon (Inicio de sesión con Amazon) y crear un
producto de AVS, siga las instrucciones de la sección 3 de la Guía de migración de NXP.
Para volver a crear la aplicación móvil de Android
1. Abra el proyecto VoiceCompanionApp en Android Studio. El archivo VoiceCompanionApp.apk se

incluye en el paquete de software de NXP.
2. En Android Studio, añada la clave de API que generó en el procedimiento anterior al archivo
api_key.txt en la carpeta assets. Esto sincroniza la aplicación móvil auxiliar con su perfil de
seguridad de AVS. La aplicación utiliza la clave de API cuando inicia sesión mediante el servicio Login
with Amazon. Cuando la aplicación obtiene un código de autorización de Amazon, transfiere el código
al firmware del dispositivo. A continuación, el dispositivo obtiene tokens de acceso y actualización del
servicio Login with Amazon para realizar llamadas a AVS.
760
3. En Android Studio, elija Build Project (Crear proyecto) y Generate a Signed Bundle/APK (Generar un
paquete firmado/APK). Para obtener más información, consulte la sección 4 "Creación y generación
de la aplicación móvil" en la Guía de migración de NXP. Para obtener más información acerca de
cómo realizar la autorización con Alexa de esta manera, consulte la página sobre cómo autorizar
desde una aplicación auxiliar (Android/iOS).
4. Instale la aplicación móvil actualizada en su dispositivo móvil. Configure ADB en su equipo Mac e
instale el archivo APK de Android actualizado en su teléfono móvil mediante la consola del terminal. Si
instaló la aplicación móvil para obtener una vista previa del servicio AVS para AWS IoT con la cuenta
de NXP preconfigurada, debe desinstalar y volver a instalar la aplicación.
Para actualizar la aplicación cliente con sus credenciales de AWS
1. Siga las instrucciones de la sección 3 y la sección 4 de la Guía para desarrolladores de NXP y realice
las modificaciones necesarias en el controlador Segger J-Link. En estas instrucciones, también se
explica cómo importar los proyectos bootstrap, Bootloader y ais_demo utilizando el IDE de
MCUxPresso.
2. Siga las instrucciones para actualizar el código fuente y volver a crear la aplicación que se indican en
la sección 7 "Cambios en el firmware RT106A" de la Guía de migración de NXP. Le recomendamos
que utilice MCUXPRESSOPresso v10.3.1.
Estos cambios en el código fuente permiten que el firmware del dispositivo se comunique con su
cuenta de AWS y su producto AVS en lugar de con la cuenta de NXP predeterminada.
Para configurar y conectar el dispositivo a AWS IoT y Amazon Alexa
1. Restablezca el dispositivo a los ajustes de fábrica. Si ha obtenido una vista previa del servicio AVS
para AWS IoT con la cuenta de NXP preconfigurada, debe restablecer el firmware del dispositivo antes
de iniciar sesión de nuevo con la aplicación móvil auxiliar. Esto garantiza que la aplicación móvil y el
dispositivo utilicen su perfil de seguridad. Asegúrese de que el dispositivo está conectado al equipo.
Pulse SW1 durante 10 segundos para iniciar el restablecimiento de fábrica.
La Guía del usuario de NXP, que se incluye en el paquete de software de NXP, contiene una
descripción de los controles físicos del dispositivo.
2. Vuelva a programar el firmware para utilizar el certificado y la clave que generó para el dispositivo.
Agregue la clave y el certificado a los binarios Bootstrap y Ais_demo actualizados que creó en el
procedimiento anterior. También es recomendable volver a programar el firmware con los binarios
Intelligent toolbox, app_crt y CA_crt predeterminados.
Para obtener instrucciones, consulte la sección 5 "Creación y programación" de la Guía para

desarrolladores de NXP.
3. Siga las instrucciones del procedimiento anterior Conectar el dispositivo a AWS y Amazon
Alexa (p. 758). De esta forma, se conectará a AVS para AWS IoT con su propio perfil de seguridad y
sus credenciales.
761
SDK de AWS Mobile para Android
SDK de AWS IoT para dispositivos y

móviles
Contenido
• SDK de AWS Mobile para Android (p. 762)
• Arduino Yún SDK (p. 762)
• AWS IoT Device SDK para Embedded C (p. 763)
• AWS IoT C++ device SDK (p. 763)
• AWS Mobile SDK para iOS (p. 763)
• AWS IoT device SDK for Java (p. 763)
• AWS IoT device SDK for JavaScript (p. 764)
• AWS IoT device SDK for Python (p. 764)
Los SDK de AWS IoT para dispositivos y móviles le permiten conectar los dispositivos a AWS IoT de
forma sencilla y rápida. 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. Para obtener información
sobre los SDK de AWS que se utilizan para acceder a las API de AWS, consulte los SDKs y las
herramientas de AWS.
Note
Actualmente, el aprovisionamiento de flotas (beta) solo es compatible con el SDK de dispositivos

de AWS IoT para Embedded C.
SDK de AWS Mobile para Android

AWS SDK para Android contiene una biblioteca, ejemplos y documentación para que los desarrolladores
creen aplicaciones móviles conectadas mediante AWS. Este SDK también permite llamar a las API de
AWS IoT. Para obtener más información, consulte los siguientes temas:
• AWS Mobile SDK for Android on GitHub

• AWS Mobile SDK for Android Readme
• Ejemplos de AWS Mobile SDK for Android
Arduino Yún SDK

AWS IoT Arduino Yún SDK permite a los desarrolladores conectar sus tarjetas compatibles Arduino Yún
con AWS IoT. Al conectar un dispositivo a AWS IoT, los usuarios pueden trabajar de forma segura con el
agente de mensajes, las reglas y las sombras de objeto que AWS IoT proporciona, y con otros servicios
de AWS como AWS Lambda, Kinesis y Amazon S3. Para obtener más información, consulte los siguientes
temas:
• Arduino Yún SDK on GitHub

• Arduino Yún SDK Readme
762
AWS IoT Device SDK para Embedded C
AWS IoT Device SDK para Embedded C

AWS IoT Device SDK for Embedded C es un conjunto de archivos de origen C, que se puede utilizar
en aplicaciones insertadas para establecer conexiones seguras con la plataforma de AWS IoT.
Contiene clientes de transporte, implementaciones TLS y ejemplos de uso. También es compatible con
características específicas de AWS IoT como una API para tener acceso al servicio Device Shadow. Se
distribuye como código fuente y está diseñado para integrarse en el firmware cliente junto con código de
aplicación, otras bibliotecas y RTOS. Para obtener más información, consulte los siguientes temas:
• AWS IoT Device SDK para Embedded C en GitHub

• AWS IoT Device SDK for Embedded C Readme
• AWS IoT Device SDK for Embedded C Porting Guide
AWS IoT C++ device SDK

AWS IoT C++ Device SDK permite a los desarrolladores compilar aplicaciones conectadas mediante AWS
y las API de AWS IoT. 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
los siguientes temas:
• AWS IoT C++ Device SDK v2 en GitHub

• Archivo léame del AWS IoT C++ Device SDK v2
• AWS IoT C++ Device SDK en GitHub
• AWS IoT C++ Device SDK Readme
AWS Mobile SDK para iOS

AWS SDK para iOS es un kit de desarrollo de software de código abierto, distribuido con licencia de
Apache Open Source. El SDK para iOS contiene una biblioteca, ejemplos de código y documentación para
ayudar a los desarrolladores a crear aplicaciones móviles conectadas mediante AWS. Este SDK también
permite llamar a la API de AWS IoT.
• AWS SDK for iOS on GitHub

• AWS SDK for iOS Readme
• AWS SDK for iOS Samples
AWS IoT device SDK for Java

AWS IoT Device SDK for Java permite a los desarrolladores de Java tener acceso a la plataforma de
AWS IoT mediante MQTT o MQTT sobre protocolo WebSocket. El SDK es compatible con las sombras.
Puede tener acceso a las sombras mediante los métodos GET, UPDATE y DELETE de HTTP. El SDK es
también compatible con un modelo de acceso a sombras simplificado, lo que permite a los desarrolladores
intercambiar datos con las sombras utilizando únicamente métodos getter y setter, sin tener que serializar
ni deserializar documentos JSON. Para obtener más información, consulte los siguientes temas:
• AWS IoT Device SDK for Java v2 en GitHub

• Archivo léame de AWS IoT Device SDK for Java v2
• AWS IoT Device SDK for Java on GitHub
763
AWS IoT device SDK for JavaScript
• AWS IoT Device SDK for Java Readme
AWS IoT device SDK for JavaScript

El paquete aws-iot-device-sdk.js permite a los desarrolladores escribir aplicaciones JavaScript que tengan
acceso a AWS IoT mediante MQTT o MQTT sobre protocolo WebSocket. Se puede utilizar en entornos de
Node.js y aplicaciones de navegador. Para obtener más información, consulte los siguientes temas:
• AWS IoT Device SDK for JavaScript v2 en GitHub

• Archivo léame de AWS IoT Device SDK for JavaScript v2
• AWS IoT Device SDK for JavaScript on GitHub
• AWS IoT Device SDK for JavaScript Readme
AWS IoT device SDK for Python

AWS IoT Device SDK for Python permite a los desarrolladores escribir scripts de Python para tener acceso
con sus dispositivos a la plataforma de AWS IoT mediante MQTT o MQTT sobre protocolo WebSocket.
Al conectar sus dispositivos a AWS IoT, los usuarios pueden trabajar de forma segura con el agente de
mensajes, las reglas y las sombras de objeto que AWS IoT proporciona, y con otros servicios de AWS
como AWS Lambda, Kinesis y Amazon S3 y más.
• AWS IoT Device SDK for Python v2 en GitHub

• AWS IoT Device SDK for Python v2 Readme
• AWS IoT Device SDK for Python v1 on GitHub
• AWS IoT Device SDK for Python v1 Readme
764
Diagnóstico de problemas de conectividad
Solución de problemas de AWS IoT

La siguiente información puede ayudarle a solucionar problemas habituales en AWS IoT.
Tareas
• Diagnóstico de problemas de conectividad (p. 765)
• Diagnóstico de problemas de las reglas (p. 765)
• Diagnóstico de problemas relacionados con las sombras (p. 766)
• Diagnosticar problemas con acciones del flujo de entrada de Salesforce IoT (p. 768)
• Solución de problemas de consultas de agregación en el servicio de indexación de flotas (p. 769)
• Guía para solucionar problemas de AWS IoT Device Defender (p. 770)
• Errores de AWS IoT (p. 772)
Diagnóstico de problemas de conectividad

Autenticación
¿Cómo autentican mis dispositivos los puntos de enlace de AWS IoT?
Agregue el certificado de entidad de certificación de AWS IoT al almacén de confianza de su cliente.

Consulte la documentación sobre la autenticación del servidor en AWS IoT Core y siga los enlaces
para descargar el certificado de CA correspondiente.
¿Cómo puedo validar un certificado configurado correctamente?
Ejecute el comando s_client de OpenSSL para probar una conexión con el punto de enlace de
AWS IoT:
openssl s_client -connect custom_endpoint.iot.us-east-1.amazonaws.com:8443 -

CAfile CA.pem -cert cert.pem -key privateKey.pem
Para obtener más información sobre el uso de openssl s_client, consulte Documentación de
OpenSSL s_client.
Autorización
He recibido una respuesta PUBNACK o SUBNACK del agente. ¿Qué tengo que hacer?
Asegúrese de que el certificado que utilice para llamar a AWS IoT tenga una política asociada. De
forma predeterminada, todas las operaciones de publicación o suscripción se deniegan.
Diagnóstico de problemas de las reglas

La mejor forma de solucionar problemas con las reglas es utilizar CloudWatch Logs. Cuando habilita
CloudWatch Logs para AWS IoT, puede ver qué reglas se activan, así como su éxito o fracaso. También
obtiene información sobre si las condiciones de la cláusula WHERE coinciden. Para obtener más
información, consulte Monitoreo de AWS IoT mediante CloudWatch Logs (p. 239).
El problema más habitual de las reglas es la autorización. Los registros se muestran si el rol no está
autorizado a realizar operaciones AssumeRole en el recurso. A continuación hay un log de ejemplo
generado por el registro detallado (p. 225):
765
Diagnóstico de problemas relacionados con las sombras
{
"timestamp": "2017-12-09 22:49:17.954",
"traceId": "ff563525-6469-506a-e141-78d40375fc4e",
"accountId": "123456789012",
"eventType": "RuleExecution",
"clientId": "iotconsole-123456789012-3",
"topicName": "test-topic",
"ruleName": "rule1",
"ruleAction": "DynamoAction",
"resources": {
"ItemHashKeyField": "id",
"Table": "trashbin",
"Operation": "Insert",
"ItemHashKeyValue": "id",
"IsPayloadJSON": "true"
},
"principalId": "ABCDEFG1234567ABCD890:outis",
"details": "User: arn:aws:sts::123456789012:assumed-role/dynamo-testbin/5aUMInJH
is not authorized to perform: dynamodb:PutItem on resource: arn:aws:dynamodb:us-
east-1:123456789012:table/testbin (Service: AmazonDynamoDBv2; Status Code: 400; Error Code:
AccessDeniedException; Request ID: AKQJ987654321AKQJ123456789AKQJ987654321AKQJ987654321)"
}
A continuación hay un log de ejemplo similar generado por el registro global (p. 223):
2017-12-09 22:49:17.954 TRACEID:ff562535-6964-506a-e141-78d40375fc4e

PRINCIPALID:ABCDEFG1234567ABCD890:outis [ERROR] EVENT:DynamoActionFailure
TOPICNAME:test-topic CLIENTID:iotconsole-123456789012-3
MESSAGE:Dynamo Insert record failed. The error received was User:
arn:aws:sts::123456789012:assumed-role/dynamo-testbin/5aUMInJI is not authorized to
perform: dynamodb:PutItem on resource: arn:aws:dynamodb:us-east-1:123456789012:table/
testbin
(Service: AmazonDynamoDBv2; Status Code: 400; Error Code: AccessDeniedException; Request
ID: AKQJ987654321AKQJ987654321AKQJ987654321AKQJ987654321).
Message arrived on: test-topic, Action: dynamo, Table: trashbin, HashKeyField: id,
HashKeyValue: id, RangeKeyField: None, RangeKeyValue: 123456789012
No newer events found at the moment. Retry.
Para obtener más información, consulte the section called “Visualización de registros de AWS IoT en la
consola de CloudWatch” (p. 239).
El usuario final controla los servicios externos. Antes de ejecutar la regla, asegúrese de que los servicios
externos estén configurados con suficientes unidades de capacidad y procesamiento.
Diagnóstico de problemas relacionados con las

sombras
Diagnóstico de sombras
Problema Directrices para solucionar problemas
El documento de la sombra de un dispositivo se Si no está familiarizado con JSON, modifique los

rechaza con Invalid JSON document. ejemplos proporcionados en esta guía y adáptelos
a sus necesidades. Para obtener más información,
766
Diagnóstico de problemas relacionados con las sombras
Problema Directrices para solucionar problemas

consulte Sintaxis de los documentos de sombra del
dispositivo (p. 407).
He enviado un JSON correcto, pero no se Compruebe que ha seguido las directrices de

almacena o solo se almacena parcialmente en el formato JSON. Solo se almacenarán los campos
documento de sombra del dispositivo. JSON de las secciones desired y reported. No
se tendrá en cuenta el contenido JSON (aunque
sea formalmente correcto) que no esté en estas
secciones.
He recibido un error que indica que la sombra del La sombra del dispositivo admite únicamente
dispositivo supera el tamaño máximo permitido. 8 KB de datos. Intente acortar los nombres de los
campos que están dentro del documento JSON
o cree más sombras generando más objetos.
Un dispositivo puede tener asociado un número
ilimitado de objetos o sombras. El único requisito
es que cada nombre de objeto debe ser único en la
cuenta.
Cuando recibo la sombra de un dispositivo, esta En la recepción, el servicio de AWS IoT agrega
supera los 8 KB. ¿Por qué pasa esto? metadatos a la sombra del dispositivo. El servicio
incluye estos datos en su respuesta, pero no
cuentan para el límite de 8 KB. Para calcular el
límite, solo se tienen en cuenta los datos de estado
desired y reported del documento de estado
enviado a la sombra del dispositivo.
Mi solicitud se ha rechazado porque la versión es Realice una operación GET para sincronizarse con
incorrecta. ¿Qué tengo que hacer? la última versión del documento de estado. Al usar
MQTT, suscríbase al tema /update/accepted para
recibir notificaciones sobre cambios de estado y la
última versión del documento JSON.
La marca de tiempo está desajustada en varios El servicio AWS IoT actualiza la marca de tiempo
segundos. de algunos campos individuales y de todo el
documento JSON cuando los recibe; la marca de
tiempo también se actualiza cuando el documento
de estado se publica en el mensaje ./update/
accepted y ./update/delta. Los mensajes pueden
retrasarse en la red, lo que puede provocar una
demora de varios segundos en la marca de tiempo.
Mi dispositivo puede publicar en los temas de Compruebe que haya creado políticas en IAM que
sombra correspondientes y suscribirse a ellos, permitan a sus credenciales tener acceso a estos
pero cuando intento actualizar el documento de temas y a su acción correspondiente (UPDATE/
sombra mediante la API de REST de HTTP, recibo GET/DELETE). Las políticas de IAM y las de
un mensaje HTTP 403. certificado son independientes.
Otros problemas. El servicio Device Shadow registra los errores en

CloudWatch Logs. Para identificar los problemas
de configuración y de dispositivo, habilite
CloudWatch Logs y consulte los registros para
obtener información de depuración.
767
Diagnosticar problemas con acciones de Salesforce
Diagnosticar problemas con acciones del flujo de

entrada de Salesforce IoT
Registro de seguimiento de ejecución
¿Cómo puedo ver el registro de seguimiento de ejecución de una acción de Salesforce?
Consulte la sección Monitoreo de AWS IoT mediante CloudWatch Logs (p. 239). Una vez que haya
activado los registros, podrá ver el seguimiento de la ejecución de la acción de Salesforce.
Éxito y error de una acción

¿Cómo puedo saber que los mensajes se han enviado correctamente a un flujo de entrada de Salesforce
IoT?
Consulte los registros generados por la ejecución de la acción de Salesforce en CloudWatch Logs.
Si aparece Action executed successfully, eso significa que el motor de reglas de AWS IoT
recibió la confirmación de Salesforce IoT de que el mensaje se envió correctamente al flujo de entrada
de destino.
Si tiene problemas con la plataforma de Salesforce IoT, póngase en contacto con la ayuda de
Salesforce IoT.
¿Qué hago si los mensajes no se han enviado correctamente a un flujo de entrada de Salesforce IoT?
Consulte los registros generados por la ejecución de la acción de Salesforce en CloudWatch Logs. En
función de la entrada de registro, puede realizar las siguientes operaciones:
Failed to locate the host
Compruebe que el parámetro url de la acción es correcto y que el flujo de entrada de Salesforce
IoT existe.
Received Internal Server Error from Salesforce
Reintentar. Si el problema continúa, póngase en contacto con el equipo de soporte de Salesforce

IoT.
Received Bad Request Exception from Salesforce
Compruebe si la carga que envía presenta errores.

Received Unsupported Media Type Exception from Salesforce
Salesforce IoT no admite una carga binaria en este momento. Compruebe que está enviando una
carga JSON.
Received Unauthorized Exception from Salesforce
Compruebe que el parámetro token de la acción es correcto y que su token sigue siendo válido.
Received Not Found Exception from Salesforce
Compruebe que el parámetro url de la acción es correcto y que el flujo de entrada de Salesforce
IoT existe.
Si recibe un error que no aparece aquí, póngase en contacto con AWS Support.
768
Solución de problemas de consultas de
agregación en el servicio de indexación de flotas
Solución de problemas de consultas de agregación

en el servicio de indexación de flotas
Si surgen errores de discordancia de tipo, puede utilizar CloudWatch Logs para solucionar el problema.
CloudWatch Logs debe estar habilitado para que el servicio de indexación de flotas pueda crear los
registros. Para obtener más información, consulte Monitoreo de AWS IoT mediante CloudWatch
Logs (p. 239).
Cuando realiza consultas de agregación en campos no administrados, solo puede especificar un campo
definido en el argumento customFields pasado a UpdateIndexingConfiguration o update-
indexing-configuration. Si el valor del campo no coincide con el tipo de datos del campo configurado, este
valor se omite al realizar una consulta de agregación.
El servicio de indexación de flotas envía un registro de errores a CloudWatch Logs cuando un campo no
se puede indexar debido a un tipo no coincidente. El registro de errores contiene el nombre del campo,
el valor que no se pudo convertir y el nombre de objeto del dispositivo. A continuación, se muestra un
ejemplo de registro de error.
{
"timestamp": "2017-02-20 20:31:22.932",
"traceId": "79738924-1025-3a00-a669-7bec69f7f07a",
"accountId": "000000000000",
"status": "SucceededWithIssues",
"eventType": "IndexingCustomFieldFailed",
"thingName": "thing0",
"failedCustomFields": [
{
"Name": "attributeName1",
"Value": "apple",
"ExpectedType": "String"
},
{
"Name": "attributeName2",
"Value": "2",
"ExpectedType": "Boolean"
}
]
}
Si un dispositivo se ha desconectado durante aproximadamente una hora, el valor timestamp del

estado de conectividad podría no aparecer. Para las sesiones persistentes, el valor podría no aparecer
después de que un cliente se haya desconectado durante un periodo mayor que el tiempo de vida (TTL)
configurado para la sesión persistente. Los datos de estado de conectividad solo se indexan para las
conexiones donde el ID de cliente tiene un nombre de objeto coincidente. (El ID de cliente es el valor que
se utiliza para conectar un dispositivo a AWS IoT Core).
769
Guía para solucionar problemas
de AWS IoT Device Defender
Guía para solucionar problemas de AWS IoT

Device Defender
Generales
P: ¿Hay algún requisito previo para usar AWS IoT Device Defender?
R: Si desea utilizar métricas registradas por el dispositivo, primero debe implementar un agente en
sus dispositivos AWS IoT conectados o en las gateways de dispositivos. Los dispositivos deben
proporcionar un identificador de cliente o nombre de objeto coherentes.
Auditoría
P: Permití una comprobación y mi auditoría ha estado mostrando "En curso" durante mucho tiempo. ¿Hay
algún problema? ¿Cuándo recibiré los resultados?
R: Cuando se habilita una comprobación, la recopilación de datos comienza inmediatamente. Sin

embargo, si la cuenta tiene una gran cantidad de datos que recopilar (certificados, objetos, políticas,
etc.), los resultados de la comprobación podrían no estar disponible durante un tiempo una vez
habilitada.
Detect
P: ¿Cómo puedo conocer los umbrales que se establecen en un comportamiento del perfil de seguridad de
AWS IoT Device Defender?
R: Comience por crear un comportamiento del perfil de seguridad con umbrales bajos y asócielo a un
grupo de objetos que conste de un conjunto representativo de dispositivos. Puede utilizar AWS IoT
Device Defender para ver las métricas actuales y después ajustar el comportamiento de los umbrales
para que coincidan con su caso de uso.
P: He creado un comportamiento, pero no activa una vulneración cuando la espero. ¿Cómo debo
solucionarlo?
R: Cuando define un comportamiento, especifica la forma en que espera que el dispositivo

se comporte con normalidad. Por ejemplo, si tiene una cámara de seguridad que se conecta
exclusivamente a un servidor central en el puerto TCP 8888, no espere que se realicen otras
conexiones. Para recibir una alerta si la cámara hace una conexión en otro puerto, puede definir un
comportamiento como este:
{
"name": "Listening TCP Ports",
"metric": "aws:listening-tcp-ports",
"criteria": {
"comparisonOperator": "in-port-set",
"value": {
"ports": [ 8888 ]
}
}
}
Si la cámara realiza una conexión TCP en el puerto TCP 443, el comportamiento del dispositivo se
infringiría y se activaría una alerta.
P: Se están vulnerando uno o más de mis comportamientos. ¿Cómo elimino la vulneración?
R: Las alarmas se desactivan después de que el dispositivo retoma un comportamiento esperado, tal
y como se define en los perfiles de comportamiento. Los perfiles de comportamiento se evalúan al
770
Guía para solucionar problemas
de AWS IoT Device Defender
recibir los datos de las métricas de su dispositivo. Si el dispositivo no publica ninguna métrica durante
más de dos días, el evento de vulneración se establece en alarm-invalidated automáticamente.
P: Eliminé un comportamiento que generaba una vulneración; ¿cómo puedo detener las alertas?
R: Al eliminar un comportamiento se detienen todas las vulneraciones y alertas futuras de dicho

comportamiento. Las alertas anteriores deben eliminarse del mecanismo de notificación. Cuando se
elimina un comportamiento, el registro de vulneraciones de ese comportamiento se conserva durante
el mismo período de tiempo que todas las demás vulneraciones en su cuenta.
Métricas de dispositivo
P: Estoy enviando informes de métricas que sé que vulneran mis comportamientos, pero no se activa
ninguna vulneración. ¿Por qué?
R: Verifique que sus informes de métricas se estén aceptando suscribiéndose a los siguientes temas
de MQTT:
$aws/things/THING_NAME/defender/metrics/FORMAT/rejected
$aws/things/THING_NAME/defender/metrics/FORMAT/accepted
donde THING_NAME es el nombre del objeto que informa de la métrica y FORMAT es "json" o "cbor",
según el formato del informe de métricas que envía el objeto.
Una vez que se haya suscrito, debe recibir mensajes sobre estos temas para cada informe de métrica
enviado. Un mensaje rejected indica que hubo un problema al analizar el informe de métrica. Se
incluye un mensaje de error en la carga del mensaje para ayudarle a corregir cualquier error en su
informe de métrica. Un mensaje accepted indica que se ha analizado correctamente el informe de
métrica.
P: ¿Qué sucede si envío una métrica vacía en mi informe de métrica?
R: Una lista vacía de puertos o direcciones IP se considera siempre que está en conformidad con el
comportamiento correspondiente. Si el comportamiento correspondiente supusiera una vulneración, la
vulneración se eliminaría.
P: ¿Por qué los informes de métricas de mi dispositivo contienen mensajes para dispositivos que no están
en el registro de AWS IoT?
Si tiene uno o varios perfiles de seguridad asociados a todos los objetos o a todos los objetos no
registrados, AWS IoT Device Defender incluye métricas de los objetos no registrados. Si desea excluir
las métricas de objetos no registrados, puede asociar los perfiles a todos los dispositivos registrados
en lugar de a todos los dispositivos.
P: No veo los mensajes de uno o varios dispositivos no registrados a pesar de que puedo aplicar un perfil
de seguridad a todos los dispositivos no registrados o a todos los dispositivos. ¿Cómo puedo solucionarlo?
Compruebe que está enviando un informe de métricas en uno de los formatos compatibles. Para
obtener más información, consulte Especificación de documentos de métricas de dispositivos (p. 712).
Compruebe que los dispositivos no registrados utilizan un identificador de cliente o nombre de objeto
coherentes. Los mensajes registrados por los dispositivos se rechazan si el nombre del objeto
contiene caracteres de control o si el nombre del objeto tiene más de 128 bytes de caracteres con
codificación UTF-8.
P: ¿Qué sucede si un dispositivo no registrado se añade al registro o si un dispositivo registrado deja de
estarlo?
R: Si un dispositivo se añade o se elimina del registro:

• Verá dos vulneraciones independientes para el dispositivo (una en su nombre de objeto registrado
y otra en su identidad no registrada) si se siguen publicando métricas para las vulneraciones. Las
771
Errores de AWS IoT
vulneraciones activas de la identidad antigua dejan de aparecer al cabo de dos días, pero están
disponibles en el historial de vulneraciones durante un máximo de 14 días.
P: ¿Qué valor debo proporcionar en el campo de ID del informe de métricas de mi dispositivo?
R: Utilice un valor único para cada informe de métrica, expresado como un número entero positivo.
Una práctica común es utilizar una marca de tiempo Epoch de Unix.
P: ¿Debo crear una conexión con MQTT dedicada para las métricas de AWS IoT Device Defender?
R: No se requiere una conexión con MQTT independiente.

P: ¿Qué ID de cliente debería usar al conectarme para publicar métricas de dispositivos?
Para dispositivos (objetos) que estén el registro de AWS IoT registro, utilice el nombre del objeto
registrado. Para los productos que no estén en el registro de AWS IoT, utilice un identificador
coherente al conectarse a AWS IoT. Esta práctica le permite crear una correspondencia entre las
vulneraciones y el nombre de objeto.
P: ¿Puedo publicar métricas para un dispositivo con un ID de cliente diferente?
Es posible publicar métricas en nombre de otro objeto. Para ello, publique las métricas en el tema de
AWS IoT Device Defender reservado para dicho dispositivo. Por ejemplo, Thing-1 desea publicar
métricas de sí mismo y también en nombre de Thing-2. Thing-1 recopila sus propias métricas y las
publica en el tema de MQTT:
$aws/things/Thing-1/defender/metrics/json
Thing-1 obtiene las métricas de Thing-2 y publica dichas métricas en el tema de MQTT:
$aws/things/Thing-2/defender/metrics/json
P: ¿Cuántos comportamientos y perfiles de seguridad puedo tener en mi cuenta?
R: Consulte los puntos de enlace y las cuotas de AWS IoT Device Defender.
P: ¿Qué aspecto tiene un rol de destino prototípico para un destino de alerta?
R: Un rol que permite a AWS IoT Device Defender publicar alertas en un destino de alerta (tema de
SNS) requiere dos cosas:
• Una relación de confianza que especifique iot.amazonaws.com como la entidad de confianza y
• Una política asociada que conceda a AWS IoT permiso para publicar en un tema de SNS
especificado. Por ejemplo:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "sns:Publish",
"Resource": "<sns-topic-arn>"
}
]
}
Errores de AWS IoT

En esta sección se presentan los códigos de error que envía AWS IoT.
772
Errores de AWS IoT
Códigos de error del agente de mensajes
Código de error Descripción del error
400 Solicitud errónea.
401 Sin autorización.
403 prohibido.
503 Servicio no disponible.
Identidad y códigos de error de seguridad
Códigos de error de sombra de dispositivo
400 Solicitud errónea.
403 prohibido.
404 No encontrado.
409 Conflicto.
413 Solicitud demasiado grande.
422 No se pudo procesar una solicitud.
429 Demasiadas solicitudes.
500 Error interno.
503 Servicio no disponible.
773
Cuotas de AWS IoT

Para obtener información sobre las cuotas de AWS IoT Core, consulte Puntos de enlace y cuotas de AWS
IoT Core en la Referencia general de AWS.
774

Manual AWS IoT

Cargado por

Copyright:

Formatos disponibles

Manual AWS IoT

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Manual AWS IoT

Cargado por

Copyright:

Formatos disponibles

AWS IoT

Guía del desarrollador

AWS IoT: Guía del desarrollador

Configuración de AWS IoT ................................................................................................. 85

AWS Training and Certification .......................................................................................... 152

HTTP ............................................................................................................................ 282

Propiedades del documento .............................................................................................. 386

Iniciar una sesión SSH .................................................................................................... 527

Pasos siguientes ............................................................................................................. 581

Eventos de trabajos ................................................................................................................. 746

¿Qué es AWS IoT?

Componentes de AWS IoT

Integración Alexa Voice Service (AVS) para AWS IoT

Puede definir autorizadores personalizados para permitirle administrar su propia estrategia de

Los autorizadores personalizados pueden implementar varias estrategias de autenticación

Sombra del dispositivo

Proporciona representaciones persistentes de los dispositivos en la nube de AWS. Es posible publicar

Proporciona funciones de procesamiento de mensajes y de integración con otros servicios de AWS.

Comparte la responsabilidad de la seguridad en la nube de AWS. Los dispositivos deben proteger

Primeros pasos con AWS IoT

Acceso a AWS IoT

• Amazon Simple Storage Service—Proporciona almacenamiento escalable en la nube de AWS. Para

Funcionamiento de AWS IoT

Introducción a AWS IoT Core

Inicie sesión en la consola de AWS IoT.

Para crear una cuenta de AWS

1. Abra la página de inicio de AWS y elija Crear una cuenta de AWS.

1. En la página Le damos la bienvenida a la consola de AWS IoT, en el panel de navegación, seleccione

No es recomendable utilizar información de identificación personal en el nombre del objeto.

Creación y activación de un certificado de dispositivo

1. Elija Create certificate.

El enlace Download (Descargar) de la CA raíz de AWS IoT le llevará a la página

Creación de una política de AWS IoT Core

Para crear una política de AWS IoT Core

1. En el panel de navegación de la izquierda, seleccione Seguridad y, a continuación, elija Políticas. En

3. En el campo Acción, escriba iot:Connect. En el campo ARN de recurso, escriba *. Marque la

Puede restringir qué clientes (dispositivos) pueden conectarse, especificando un ARN de

El ARN de tema tiene este formato:

Para obtener más información, consulte Políticas de IAM (p. 193).

Asociación de una política de AWS IoT Core a un

1. En el panel de navegación de la izquierda, seleccione Seguridad y, a continuación, elija Certificados.

Asociación de un certificado a un objeto

Para asociar un certificado al objeto que representa el dispositivo en el registro

Configuración del dispositivo

Visualización de los mensajes de MQTT de

Para ver los mensajes MQTT

1. En la consola de AWS IoT, en el panel de navegación izquierdo, elija Test (Probar).

El tema my/topic aparece en la columna Suscripciones.

Para emular un objeto de IoT enviando un mensaje

• En la página del cliente MQTT, en la sección Publicación, en el campo Especifique un tema y el

En la sección de carga del mensaje, introduzca el siguiente JSON:

Configuración y comprobación de reglas

• Crear un tema de Amazon SNS.

Creación de un tema de SNS

Amazon SNS no está disponible en todas las regiones de AWS.

1. Abra la consola de Amazon SNS.

3. Elija Create new topic.

5. Anote el ARN del tema que acaba de crear.

Suscripción a un tema de Amazon SNS

1. En la consola de Amazon SNS, seleccione Suscripciones en el panel izquierdo. En el menú

from future import print_function