# AWS IoT Events-Data Ejemplos de usando AWS CLI
<a name="cli_iot-events-data_code_examples"></a>

En los siguientes ejemplos de código se muestra cómo realizar acciones e implementar escenarios comunes usando AWS Command Line Interface con AWS IoT Events-Data.

Las *acciones* son extractos de código de programas más grandes y deben ejecutarse en contexto. Mientras las acciones muestran cómo llamar a las distintas funciones de servicio, es posible ver las acciones en contexto en los escenarios relacionados.

En cada ejemplo se incluye un enlace al código de origen completo, con instrucciones de configuración y ejecución del código en el contexto.

**Topics**
+ [Acciones](#actions)

## Acciones
<a name="actions"></a>

### `batch-put-message`
<a name="iot-events-data_BatchPutMessage_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `batch-put-message`.

**AWS CLI**  
**Para enviar mensajes (entradas) a AWS IoT Events**  
En el siguiente ejemplo de `batch-put-message`, se envía un conjunto de mensajes al sistema de AWS IoT Events. La carga útil de cada mensaje se transforma en la entrada que especifique (`inputName`) y se ingiere en cualquier detector que supervise dicha entrada. Si se envían varios mensajes, no se puede garantizar el orden en que se vayan a procesar dichos mensajes. Para garantizar un orden, debe enviar los mensajes de uno en uno y esperar una respuesta satisfactoria.  

```
aws iotevents-data batch-put-message \
    --cli-binary-format raw-in-base64-out \
    --cli-input-json file://highPressureMessage.json
```
Contenido de `highPressureMessage.json`:  

```
{
    "messages": [
        {
            "messageId": "00001",
            "inputName": "PressureInput",
            "payload": "{\"motorid\": \"Fulton-A32\", \"sensorData\": {\"pressure\": 80, \"temperature\": 39} }"
        }
    ]
}
```
Salida:  

```
{
    "BatchPutMessageErrorEntries": []
}
```
Para obtener más información, consulte [BatchPutMessage](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-data-BatchPutMessage) en la *Guía para desarrolladores de AWS IoT\$1*.  
+  Para obtener más información sobre la API, consulte [BatchPutMessage](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/batch-put-message.html) en la *Referencia de comandos de la AWS CLI*. 

### `batch-update-detector`
<a name="iot-events-data_BatchUpdateDetector_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `batch-update-detector`.

**AWS CLI**  
**Para actualizar un detector (instancia)**  
El siguiente ejemplo de `batch-update-detector` actualiza el estado, los valores de las variables y la configuración del temporizador de uno o más detectores (instancias) de un modelo de detector específico.  

```
aws iotevents-data batch-update-detector \
    --cli-input-json file://budFulton-A32.json
```
Contenido de `budFulton-A32.json`:  

```
{
    "detectors": [
        {
            "messageId": "00001",
            "detectorModelName": "motorDetectorModel",
            "keyValue": "Fulton-A32",
            "state": {
                "stateName": "Normal",
                "variables": [
                    {
                        "name": "pressureThresholdBreached",
                        "value": "0"
                    }
                ],
                "timers": [
                ]
            }
        }
    ]
}
```
Salida:  

```
{
    "batchUpdateDetectorErrorEntries": []
}
```
Para obtener más información, consulte [BatchUpdateDetector](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-data-BatchUpdateDetector) en la *Guía para desarrolladores de AWS IoT\$1*.  
+  Para obtener detalles sobre la API, consulte [BatchUpdateDetector](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/batch-update-detector.html) en la *Referencia de comandos de la AWS CLI*. 

### `create-detector-model`
<a name="iot-events-data_CreateDetectorModel_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `create-detector-model`.

**AWS CLI**  
**Para crear un modelo de detector**  
En el siguiente ejemplo de `create-detector-model`, se muestra cómo crear un modelo.  

```
aws iotevents create-detector-model \
    --cli-input-json file://motorDetectorModel.json
```
Contenido de `motorDetectorModel.json`:  

```
{
    "detectorModelName": "motorDetectorModel",
    "detectorModelDefinition": {
        "states": [
            {
                "stateName": "Normal",
                "onEnter": {
                    "events": [
                        {
                            "eventName": "init",
                            "condition": "true",
                            "actions": [
                                {
                                    "setVariable": {
                                        "variableName": "pressureThresholdBreached",
                                        "value": "0"
                                    }
                                }
                            ]
                        }
                    ]
                },
                "onInput": {
                    "transitionEvents": [
                        {
                            "eventName": "Overpressurized",
                            "condition": "$input.PressureInput.sensorData.pressure &gt; 70",
                            "actions": [
                                {
                                    "setVariable": {
                                        "variableName": "pressureThresholdBreached",
                                        "value": "$variable.pressureThresholdBreached + 3"
                                    }
                                }
                            ],
                            "nextState": "Dangerous"
                        }
                    ]
                }
            },
            {
                "stateName": "Dangerous",
                "onEnter": {
                    "events": [
                        {
                            "eventName": "Pressure Threshold Breached",
                            "condition": "$variable.pressureThresholdBreached &gt; 1",
                            "actions": [
                                {
                                    "sns": {
                                        "targetArn": "arn:aws:sns:us-east-1:123456789012:underPressureAction"
                                    }
                                }
                            ]
                        }
                    ]
                },
                "onInput": {
                    "events": [
                        {
                            "eventName": "Overpressurized",
                            "condition": "$input.PressureInput.sensorData.pressure &gt; 70",
                            "actions": [
                                {
                                    "setVariable": {
                                        "variableName": "pressureThresholdBreached",
                                        "value": "3"
                                    }
                                }
                            ]
                        },
                        {
                            "eventName": "Pressure Okay",
                            "condition": "$input.PressureInput.sensorData.pressure &lt;= 70",
                            "actions": [
                                {
                                    "setVariable": {
                                        "variableName": "pressureThresholdBreached",
                                        "value": "$variable.pressureThresholdBreached - 1"
                                    }
                                }
                            ]
                        }
                    ],
                    "transitionEvents": [
                        {
                            "eventName": "BackToNormal",
                            "condition": "$input.PressureInput.sensorData.pressure &lt;= 70 &amp;&amp; $variable.pressureThresholdBreached &lt;= 1",
                            "nextState": "Normal"
                        }
                    ]
                },
                "onExit": {
                    "events": [
                        {
                            "eventName": "Normal Pressure Restored",
                            "condition": "true",
                            "actions": [
                                {
                                    "sns": {
                                        "targetArn": "arn:aws:sns:us-east-1:123456789012:pressureClearedAction"
                                    }
                                }
                            ]
                        }
                    ]
                }
            }
        ],
        "initialStateName": "Normal"
    },
    "key": "motorid",
    "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole"
}
```
Salida:  

```
{
    "detectorModelConfiguration": {
        "status": "ACTIVATING",
        "lastUpdateTime": 1560796816.077,
        "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole",
        "creationTime": 1560796816.077,
        "detectorModelArn": "arn:aws:iotevents:us-west-2:123456789012:detectorModel/motorDetectorModel",
        "key": "motorid",
        "detectorModelName": "motorDetectorModel",
        "detectorModelVersion": "1"
    }
}
```
Para obtener más información, consulte [CreateDetectorModel](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-CreateDetectorModel) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [CreateDetectorModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/create-detector-model.html) en la *Referencia de comandos de la AWS CLI*. 

### `create-input`
<a name="iot-events-data_CreateInput_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `create-input`.

**AWS CLI**  
**Para crear una entrada**  
En el siguiente ejemplo de `create-input`, se crea una entrada.  

```
aws iotevents create-input \
    --cli-input-json file://pressureInput.json
```
Contenido de `pressureInput.json`:  

```
{
    "inputName": "PressureInput",
    "inputDescription": "Pressure readings from a motor",
    "inputDefinition": {
        "attributes": [
                { "jsonPath": "sensorData.pressure" },
                { "jsonPath": "motorid" }
            ]
    }
}
```
Salida:  

```
{
    "inputConfiguration": {
        "status": "ACTIVE",
        "inputArn": "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput",
        "lastUpdateTime": 1560795312.542,
        "creationTime": 1560795312.542,
        "inputName": "PressureInput",
        "inputDescription": "Pressure readings from a motor"
    }
}
```
Para obtener más información, consulte [CreateInput](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-CreateInput) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [CreateInput](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/create-input.html) en la *Referencia de comandos de la AWS CLI*. 

### `delete-detector-model`
<a name="iot-events-data_DeleteDetectorModel_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `delete-detector-model`.

**AWS CLI**  
**Para eliminar un modelo de detector**  
En el siguiente ejemplo de `delete-detector-model`, se muestra cómo eliminar un modelo de detector. También se eliminan todas las instancias activas del modelo de detector.  

```
aws iotevents delete-detector-model \
    --detector-model-name motorDetectorModel*
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [DeleteDetectorModel](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-DeleteDetectorModel) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [DeleteDetectorModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/delete-detector-model.html) en la *Referencia de comandos de la AWS CLI*. 

### `delete-input`
<a name="iot-events-data_DeleteInput_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `delete-input`.

**AWS CLI**  
**Para eliminar una entrada**  
En el siguiente ejemplo de `delete-input`, se elimina una entrada.  

```
aws iotevents delete-input \
    --input-name PressureInput
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [DeleteInput](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-DeleteInput) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [DeleteInput](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/delete-input.html) en la *Referencia de comandos de la AWS CLI*. 

### `describe-detector-model`
<a name="iot-events-data_DescribeDetectorModel_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `describe-detector-model`.

**AWS CLI**  
**Para obtener información de un modelo de detector**  
En el siguiente ejemplo de `describe-detector-model`, se describe un modelo de detector. Cuando no se especifica el parámetro `version`, el comando devuelve información sobre la versión más reciente.  

```
aws iotevents describe-detector-model \
    --detector-model-name motorDetectorModel
```
Salida:  

```
{
    "detectorModel": {
        "detectorModelConfiguration": {
            "status": "ACTIVE",
            "lastUpdateTime": 1560796816.077,
            "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole",
            "creationTime": 1560796816.077,
            "detectorModelArn": "arn:aws:iotevents:us-west-2:123456789012:detectorModel/motorDetectorModel",
            "key": "motorid",
            "detectorModelName": "motorDetectorModel",
            "detectorModelVersion": "1"
        },
        "detectorModelDefinition": {
            "states": [
                {
                    "onInput": {
                        "transitionEvents": [
                            {
                                "eventName": "Overpressurized",
                                "actions": [
                                    {
                                        "setVariable": {
                                            "variableName": "pressureThresholdBreached",
                                            "value": "$variable.pressureThresholdBreached + 3"
                                        }
                                    }
                                ],
                                "condition": "$input.PressureInput.sensorData.pressure > 70",
                                "nextState": "Dangerous"
                            }
                        ],
                        "events": []
                    },
                    "stateName": "Normal",
                    "onEnter": {
                        "events": [
                            {
                                "eventName": "init",
                                "actions": [
                                    {
                                        "setVariable": {
                                            "variableName": "pressureThresholdBreached",
                                            "value": "0"
                                        }
                                    }
                                ],
                                "condition": "true"
                            }
                        ]
                    },
                    "onExit": {
                        "events": []
                    }
                },
                {
                    "onInput": {
                        "transitionEvents": [
                            {
                                "eventName": "BackToNormal",
                                "actions": [],
                                "condition": "$input.PressureInput.sensorData.pressure <= 70 && $variable.pressureThresholdBreached <= 1",
                                "nextState": "Normal"
                            }
                        ],
                        "events": [
                            {
                                "eventName": "Overpressurized",
                                "actions": [
                                    {
                                        "setVariable": {
                                            "variableName": "pressureThresholdBreached",
                                            "value": "3"
                                        }
                                    }
                                ],
                                "condition": "$input.PressureInput.sensorData.pressure > 70"
                            },
                            {
                                "eventName": "Pressure Okay",
                                "actions": [
                                    {
                                        "setVariable": {
                                            "variableName": "pressureThresholdBreached",
                                            "value": "$variable.pressureThresholdBreached - 1"
                                        }
                                    }
                                ],
                                "condition": "$input.PressureInput.sensorData.pressure <= 70"
                            }
                        ]
                    },
                    "stateName": "Dangerous",
                    "onEnter": {
                        "events": [
                            {
                                "eventName": "Pressure Threshold Breached",
                                "actions": [
                                    {
                                        "sns": {
                                            "targetArn": "arn:aws:sns:us-east-1:123456789012:underPressureAction"
                                        }
                                    }
                                ],
                                "condition": "$variable.pressureThresholdBreached > 1"
                            }
                        ]
                    },
                    "onExit": {
                        "events": [
                            {
                                "eventName": "Normal Pressure Restored",
                                "actions": [
                                    {
                                        "sns": {
                                            "targetArn": "arn:aws:sns:us-east-1:123456789012:pressureClearedAction"
                                        }
                                    }
                                ],
                                "condition": "true"
                            }
                        ]
                    }
                }
            ],
            "initialStateName": "Normal"
        }
    }
}
```
Para obtener más información, consulte [DescribeDetectorModel](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-DescribeDetectorModel) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [DescribeDetectorModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/describe-detector-model.html) en la *Referencia de comandos de la AWS CLI*. 

### `describe-detector`
<a name="iot-events-data_DescribeDetector_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `describe-detector`.

**AWS CLI**  
**Para obtener información sobre un detector (instancia)**  
El siguiente ejemplo de `describe-detector` devuelve información acerca del detector especificado (instancia).  

```
aws iotevents-data describe-detector \
    --detector-model-name motorDetectorModel \
    --key-value "Fulton-A32"
```
Salida:  

```
{
    "detector": {
        "lastUpdateTime": 1560797852.776,
        "creationTime": 1560797852.775,
        "state": {
            "variables": [
                {
                    "name": "pressureThresholdBreached",
                    "value": "3"
                }
            ],
            "stateName": "Dangerous",
            "timers": []
        },
        "keyValue": "Fulton-A32",
        "detectorModelName": "motorDetectorModel",
        "detectorModelVersion": "1"
    }
}
```
Para obtener más información, consulte [DescribeDetector](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-data-DescribeDetector) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [DescribeDetector](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/describe-detector.html) en la *Referencia de comandos de la AWS CLI*. 

### `describe-input`
<a name="iot-events-data_DescribeInput_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `describe-input`.

**AWS CLI**  
**Para obtener información acerca de una entrada**  
En el siguiente ejemplo de `describe-input`, se recuperan los detalles de una entrada.  

```
aws iotevents describe-input \
    --input-name PressureInput
```
Salida:  

```
{
    "input": {
        "inputConfiguration": {
            "status": "ACTIVE",
            "inputArn": "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput",
            "lastUpdateTime": 1560795312.542,
            "creationTime": 1560795312.542,
            "inputName": "PressureInput",
            "inputDescription": "Pressure readings from a motor"
        },
        "inputDefinition": {
            "attributes": [
                {
                    "jsonPath": "sensorData.pressure"
                },
                {
                    "jsonPath": "motorid"
                }
            ]
        }
    }
}
```
Para obtener más información, consulte [DescribeInput](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-DescribeInput) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [DescribeInput](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/describe-input.html) en la *Referencia de comandos de la AWS CLI*. 

### `describe-logging-options`
<a name="iot-events-data_DescribeLoggingOptions_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `describe-logging-options`.

**AWS CLI**  
**Para obtener información sobre la configuración de registro**  
El siguiente ejemplo de `describe-logging-options` recupera las opciones de registro de AWS IoT Events actuales.  

```
aws iotevents describe-logging-options
```
Salida:  

```
{
    "loggingOptions": {
        "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole",
        "enabled": false,
        "level": "ERROR"
    }
}
```
Para obtener más información, consulte [DescribeLoggingOptions](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-DescribeLoggingOptions) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [DescribeLoggingOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/describe-logging-options.html) en la *Referencia de comandos de la AWS CLI*. 

### `list-detector-model-versions`
<a name="iot-events-data_ListDetectorModelVersions_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `list-detector-model-versions`.

**AWS CLI**  
**Para obtener información acerca de las versiones de un modelo de detector**  
En el siguiente ejemplo de `list-detector-model-versions`, se muestra una lista de todas las versiones de un modelo de detector. Solo se devuelven los metadatos asociados a cada versión de modelo de detector.  

```
aws iotevents list-detector-model-versions \
    --detector-model-name motorDetectorModel
```
Salida:  

```
{
    "detectorModelVersionSummaries": [
        {
            "status": "ACTIVE",
            "lastUpdateTime": 1560796816.077,
            "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole",
            "creationTime": 1560796816.077,
            "detectorModelArn": "arn:aws:iotevents:us-west-2:123456789012:detectorModel/motorDetectorModel",
            "detectorModelName": "motorDetectorModel",
            "detectorModelVersion": "1"
        }
    ]
}
```
Para obtener más información, consulte [ListDetectorModelVersions](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-ListDetectorModelVersions) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [ListDetectorModelVersions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/list-detector-model-versions.html) en la *Referencia de comandos de la AWS CLI*. 

### `list-detector-models`
<a name="iot-events-data_ListDetectorModels_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `list-detector-models`.

**AWS CLI**  
**Para obtener una lista de los modelos de detector**  
En el siguiente ejemplo de `list-detector-models`, se muestra una lista de los modelos de detector que ha creado. Solo se devuelven los metadatos asociados a cada modelo de detector.  

```
aws iotevents list-detector-models
```
Salida:  

```
{
    "detectorModelSummaries": [
        {
            "detectorModelName": "motorDetectorModel",
            "creationTime": 1552072424.212
            "detectorModelDescription": "Detect overpressure in a motor."
        }
    ]
}
```
Para obtener más información, consulte [ListDetectorModels](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-ListDetectorModels) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [ListDetectorModels](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/list-detector-models.html) en la *Referencia de comandos de la AWS CLI*. 

### `list-detectors`
<a name="iot-events-data_ListDetectors_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `list-detectors`.

**AWS CLI**  
**Para obtener una lista de detectores para un modelo de detector**  
En el siguiente ejemplo de `list-detectors`, se muestra una lista de los detectores (las instancias de un modelo de detector).  

```
aws iotevents-data list-detectors \
    --detector-model-name motorDetectorModel
```
Salida:  

```
{
    "detectorSummaries": [
        {
            "lastUpdateTime": 1558129925.2,
            "creationTime": 1552073155.527,
            "state": {
                "stateName": "Normal"
            },
            "keyValue": "Fulton-A32",
            "detectorModelName": "motorDetectorModel",
            "detectorModelVersion": "1"
        }
    ]
}
```
Para obtener más información, consulte [ListDetectors](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-ListDetectors) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [ListDetectors](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/list-detectors.html) en la *Referencia de comandos de la AWS CLI*. 

### `list-inputs`
<a name="iot-events-data_ListInputs_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `list-inputs`.

**AWS CLI**  
**Para enumerar las entradas**  
En el siguiente ejemplo de `list-inputs`, se enumeran las entradas que ha creado.  

```
aws iotevents list-inputs
```
Salida:  

```
{
    "status": "ACTIVE",
    "inputArn": "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput",
    "lastUpdateTime": 1551742986.768,
    "creationTime": 1551742986.768,
    "inputName": "PressureInput",
    "inputDescription": "Pressure readings from a motor"
}
```
Para obtener más información, consulte [ListInputs](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-ListInputs) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener información sobre la API, consulte [ListInputs](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/list-inputs.html) en la *Referencia de comandos de la AWS CLI*. 

### `list-tags-for-resource`
<a name="iot-events-data_ListTagsForResource_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `list-tags-for-resource`.

**AWS CLI**  
**Para enumerar las etiquetas asignadas a un recurso**  
El siguiente ejemplo de `list-tags-for-resource` es una lista las etiquetas (metadatos) que ha asignado al recurso.  

```
aws iotevents list-tags-for-resource \
    --resource-arn "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput"
```
Salida:  

```
{
    "tags": [
        {
            "value": "motor",
            "key": "deviceType"
        }
    ]
}
```
Para obtener más información, consulte [ListTagsForResource](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-ListTagsForResource) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para ver los detalles de la API, consulte [ListTagsForResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/list-tags-for-resource.html) en la *Referencia de comandos de la AWS CLI*. 

### `put-logging-options`
<a name="iot-events-data_PutLoggingOptions_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `put-logging-options`.

**AWS CLI**  
**Para configurar las opciones de registro**  
En el siguiente ejemplo de `list-tags-for-resource`, se definen o actualizan las opciones de registro de AWS IoT Events actuales. Si actualiza el valor de cualquier campo `loggingOptions`, los cambios tardarán hasta un minuto en surtir efecto. Por otra parte, si cambia la política asociada al rol que ha especificado en el campo `roleArn` (por ejemplo, para corregir una política no válida), el cambio tardará hasta cinco minutos en surtir efecto.  

```
aws iotevents put-logging-options \
    --cli-input-json file://logging-options.json
```
Contenido de `logging-options.json`:  

```
{
    "loggingOptions": {
        "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole",
        "level": "DEBUG",
        "enabled": true,
        "detectorDebugOptions": [
            {
                "detectorModelName": "motorDetectorModel",
                "keyValue": "Fulton-A32"
            }
        ]
    }
}
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [PutLoggingOptions](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-PutLoggingOptions) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener detalles sobre la API, consulte [PutLoggingOptions](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/put-logging-options.html) en la *Referencia de comandos de la AWS CLI*. 

### `tag-resource`
<a name="iot-events-data_TagResource_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `tag-resource`.

**AWS CLI**  
**Para agregar etiquetas a un recurso**  
En el siguiente ejemplo de `tag-resource`, se agregan o modifican las etiquetas del recurso especificado. Las etiquetas son metadatos que puede utilizar para administrar un recurso.  

```
aws iotevents tag-resource \
    --cli-input-json file://pressureInput.tag.json
```
Contenido de `pressureInput.tag.json`:  

```
{
    "resourceArn": "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput",
    "tags": [
        {
            "key": "deviceType",
            "value": "motor"
        }
    ]
}
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [TagResource](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-TagResource) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para ver los detalles de la API, consulte [TagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/tag-resource.html) en la *Referencia de comandos de la AWS CLI*. 

### `untag-resource`
<a name="iot-events-data_UntagResource_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `untag-resource`.

**AWS CLI**  
**Para eliminar etiquetas de un recurso**  
En el siguiente ejemplo de `untag-resource`, se eliminan la etiquetas especificadas del recurso.  

```
aws iotevents untag-resource \
    --cli-input-json file://pressureInput.untag.json
```
Contenido de `pressureInput.untag.json`:  

```
{
    "resourceArn": "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput",
    "tagKeys": [
            "deviceType"
    ]
}
```
Este comando no genera ninguna salida.  
Para obtener más información, consulte [UntagResource](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-UntagResource) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para ver los detalles de la API, consulte [UntagResource](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/untag-resource.html) en la *Referencia de comandos de la AWS CLI*. 

### `update-detector-model`
<a name="iot-events-data_UpdateDetectorModel_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `update-detector-model`.

**AWS CLI**  
**Para actualizar un modelo de detector**  
En el siguiente ejemplo de `update-detector-model`, se muestra cómo actualizar un modelo de detector. Los detectores (instancias) generados por la versión anterior se eliminan y, a continuación, se vuelven a crear a medida que llegan nuevas entradas.  

```
aws iotevents update-detector-model \
    --cli-input-json file://motorDetectorModel.update.json
```
Contenido de motorDetectorModel.update.json:  

```
{
  "detectorModelName": "motorDetectorModel",
  "detectorModelDefinition": {
    "states": [
      {
        "stateName": "Normal",
        "onEnter": {
          "events": [
            {
              "eventName": "init",
              "condition": "true",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "0"
                  }
                }
              ]
            }
          ]
        },
        "onInput": {
          "transitionEvents": [
            {
              "eventName": "Overpressurized",
              "condition": "$input.PressureInput.sensorData.pressure > 70",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "$variable.pressureThresholdBreached + 3"
                  }
                }
              ],
              "nextState": "Dangerous"
            }
          ]
        }
      },
      {
        "stateName": "Dangerous",
        "onEnter": {
          "events": [
            {
              "eventName": "Pressure Threshold Breached",
              "condition": "$variable.pressureThresholdBreached > 1",
              "actions": [
                {
                  "sns": {
                    "targetArn": "arn:aws:sns:us-east-1:123456789012:underPressureAction"
                  }
                }
              ]
            }
          ]
        },
        "onInput": {
          "events": [
            {
              "eventName": "Overpressurized",
              "condition": "$input.PressureInput.sensorData.pressure > 70",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "3"
                  }
                }
              ]
            },
            {
              "eventName": "Pressure Okay",
              "condition": "$input.PressureInput.sensorData.pressure <= 70",
              "actions": [
                {
                  "setVariable": {
                    "variableName": "pressureThresholdBreached",
                    "value": "$variable.pressureThresholdBreached - 1"
                  }
                }
              ]
            }
          ],
          "transitionEvents": [
            {
              "eventName": "BackToNormal",
              "condition": "$input.PressureInput.sensorData.pressure <= 70 && $variable.pressureThresholdBreached <= 1",
              "nextState": "Normal"
            }
          ]
        },
        "onExit": {
          "events": [
            {
              "eventName": "Normal Pressure Restored",
              "condition": "true",
              "actions": [
                {
                  "sns": {
                    "targetArn": "arn:aws:sns:us-east-1:123456789012:pressureClearedAction"
                  }
                }
              ]
            }
          ]
        }
      }
    ],
    "initialStateName": "Normal"
  },
  "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole"
}
```
Salida:  

```
{
    "detectorModelConfiguration": {
        "status": "ACTIVATING",
        "lastUpdateTime": 1560799387.719,
        "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole",
        "creationTime": 1560799387.719,
        "detectorModelArn": "arn:aws:iotevents:us-west-2:123456789012:detectorModel/motorDetectorModel",
        "key": "motorid",
        "detectorModelName": "motorDetectorModel",
        "detectorModelVersion": "2"
    }
}
```
Para obtener más información, consulte [UpdateDetectorModel](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-UpdateDetectorModel) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [UpdateDetectorModel](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/update-detector-model.html) en la *Referencia de comandos de la AWS CLI*. 

### `update-input`
<a name="iot-events-data_UpdateInput_cli_topic"></a>

En el siguiente ejemplo de código, se muestra cómo utilizar `update-input`.

**AWS CLI**  
**Para actualizar una entrada**  
En el siguiente ejemplo de `update-input`, se muestra cómo se actualiza una entrada.  

```
aws iotevents update-input \
    --cli-input-json file://pressureInput.json
```
Contenido de `pressureInput.json`:  

```
{
    "inputName": "PressureInput",
    "inputDescription": "Pressure readings from a motor",
    "inputDefinition": {
        "attributes": [
            { "jsonPath": "sensorData.pressure" },
            { "jsonPath": "motorid" }
        ]
    }
}
```
Salida:  

```
{
    "inputConfiguration": {
        "status": "ACTIVE",
        "inputArn": "arn:aws:iotevents:us-west-2:123456789012:input/PressureInput",
        "lastUpdateTime": 1560795976.458,
        "creationTime": 1560795312.542,
        "inputName": "PressureInput",
        "inputDescription": "Pressure readings from a motor"
    }
}
```
Para obtener más información, consulte [UpdateInput](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-commands.html#api-iotevents-UpdateInput) en la *Guía para desarrolladores de AWS IoT Events\$1*.  
+  Para obtener más información sobre la API, consulte [UpdateInput](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iotevents-data/update-input.html) en la *Referencia de comandos de la AWS CLI*.