

Aviso de fin de soporte: el 20 de mayo de 2026, AWS finalizará el soporte para AWS IoT Events. Después del 20 de mayo de 2026, ya no podrás acceder a la AWS IoT Events consola ni a AWS IoT Events los recursos. Para obtener más información, consulta [AWS IoT Events el fin del soporte](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Primeros pasos con la AWS IoT Events consola
<a name="iotevents-getting-started"></a>

En esta sección le mostramos cómo crear una entrada y un modelo de detector utilizando la [consola de AWS IoT Events](https://console.aws.amazon.com/iotevents/). Se modelan dos estados de un motor: un estado normal y un estado de sobrepresión. Cuando la presión medida en el motor supera un determinado umbral, el modelo pasa del estado normal al estado de sobrepresión. A continuación, envía un mensaje de Amazon SNS para alertar a un técnico sobre la condición. Cuando la presión vuelve a caer por debajo del umbral durante tres lecturas de presión consecutivas, el modelo vuelve al estado normal y envía otro mensaje de Amazon SNS como confirmación.

Comprobamos que haya tres lecturas consecutivas por debajo del umbral de presión para eliminar posibles tartamudeos de mensajes de estado de sobrepresión o normal por si hubiera una fase de recuperación no lineal o una lectura de presión anómala.

En la consola también puede encontrar varias plantillas prefabricadas de modelos de detectores que puede personalizar. También puede usar la consola para importar modelos de detectores que otros hayan escrito o exportar sus modelos de detector y usarlos en diferentes AWS regiones. Si importa un modelo de detector, asegúrese de crear las entradas necesarias o de volver a crearlas para la nueva región y actualice cualquier función ARNs utilizada.

Usa la AWS IoT Events consola para obtener información sobre lo siguiente.

**Definir entradas**  
Para supervisar sus dispositivos y procesos, deben tener una forma de transferir datos de telemetría a AWS IoT Events. Esto se hace enviando mensajes como *entradas* a AWS IoT Events. Puede hacer esto de varias formas:  
+ Utilice la operación [ BatchPutMessage](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchPutMessage.html).
+ En AWS IoT Core, escribe una regla de [AWS IoT Events acción](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html#iotevents-rule) para el motor de AWS IoT reglas al que reenvía los datos de tus mensajes. AWS IoT Events Debe identificar la entrada por su nombre.
+ En AWS IoT Analytics, utilice la [ CreateDataset](https://docs.aws.amazon.com/iotanalytics/latest/userguide/automate.html#aws-iot-analytics-automate-create-dataset)operación para crear un conjunto de datos con`contentDeliveryRules`. Estas reglas especifican la AWS IoT Events entrada a la que se envía automáticamente el contenido del conjunto de datos.
Para que sus dispositivos puedan enviar datos de este modo, debe definir una o más entradas. Para ello, asigne un nombre a cada entrada y especifique qué campos de los datos del mensaje entrante supervisa la entrada.

**Crear un modelo de detector**  
Defina un *modelo de detector* (un modelo de su equipo o proceso) utilizando *estados*. Para cada estado, defina una lógica condicional (booleana) que evalúe las entradas para detectar eventos significativos. Cuando el modelo de detector detecta un evento, puede cambiar el estado o iniciar acciones personalizadas o predefinidas mediante otros AWS servicios. Puede definir eventos adicionales que inicien acciones al entrar o salir de un estado y, opcionalmente, al cumplirse una condición.   
En este tutorial, usted envía un mensaje de Amazon SNS como acción cuando el modelo entra o sale de un determinado estado.

**Cómo supervisar un dispositivo o proceso**  
Si supervisa varios dispositivos o procesos, especifique un campo en cada entrada que identifique el dispositivo o proceso en particular del que procede la entrada. Consulte el campo `key` en `CreateDetectorModel`. Cuando el campo de entrada identificado por `key` reconoce un nuevo valor, se identifica un nuevo dispositivo y se crea un detector. Cada detector es una instancia del modelo de detector. El nuevo detector sigue respondiendo a las entradas procedentes de ese dispositivo hasta que actualice o elimine su modelo de detector.  
Si supervisa un único proceso (incluso con varios dispositivos o subprocesos enviando entradas), no especifica un campo `key` de identificación único. En este caso, el modelo crea un único detector (instancia) cuando llega la primera entrada.

**Cómo enviar mensajes como entradas a su modelo de detector**  
Existen varias formas de enviar un mensaje desde un dispositivo o proceso como entrada a un detector de AWS IoT Events que no requieren que realice un formateo adicional del mensaje. En este tutorial, utilizará la AWS IoT consola para escribir una regla de [AWS IoT Events acción](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html#iotevents-rule) para el motor de AWS IoT reglas al que reenvía los datos de sus mensajes. AWS IoT Events  
Para ello, identifique la entrada por su nombre y siga utilizando la AWS IoT consola para generar mensajes que se reenvíen como entradas. AWS IoT Events

**nota**  
En este tutorial utiliza la consola para crear los mismos `input` y `detector model` que se muestran en el ejemplo en [Tutoriales para casos de AWS IoT Events uso](iotevents-tutorials.md). Puede utilizar este ejemplo JSON como ayuda para seguir el tutorial.

**Topics**
+ [Requisitos previos para empezar AWS IoT Events](iotevents-getting-started-prereqs.md)
+ [Cree una entrada para los modelos en AWS IoT Events](create-input-overview.md)
+ [Cree un modelo de detector en AWS IoT Events](iotevents-detector-model.md)
+ [Envíe las entradas para probar el modelo de detector en AWS IoT Events](iotevents-iot-rules-engine.md)

# Requisitos previos para empezar AWS IoT Events
<a name="iotevents-getting-started-prereqs"></a>

Si no tienes una AWS cuenta, crea una. 

1. Sigue estos pasos [Con AWS IoT Events figuración](iotevents-start.md) para asegurarte de que la cuenta y los permisos estén configurados correctamente.

1. Cree dos temas de Amazon Simple Notification Service (Amazon SNS).

   En este tutorial (y en el ejemplo correspondiente) se supone que ha creado dos temas de Amazon SNS. Estos temas se muestran como: `arn:aws:sns:us-east-1:123456789012:underPressureAction` y`arn:aws:sns:us-east-1:123456789012:pressureClearedAction`. ARNs Sustituya estos valores por los temas ARNs de Amazon SNS que cree. Para obtener más información, consulte la [Guía para desarrolladores de Amazon Simple Notification Service](https://docs.aws.amazon.com/sns/latest/dg/).

   Como alternativa a la publicación de alertas para temas de Amazon SNS, puede hacer que los detectores envíen mensajes MQTT con un tema que usted especifique. Con esta opción, puede comprobar que su modelo de detector está creando instancias y que esas instancias envían alertas mediante la consola AWS IoT Core para suscribirse a los mensajes enviados a esos temas de MQTT y supervisarlos. También puede definir el nombre del tema de MQTT dinámicamente en tiempo de ejecución utilizando una entrada o variable creada en el modelo de detector. 

1. Elija una Región de AWS que sea compatible AWS IoT Events. Para obtener más información, consulte [AWS IoT Events](https://docs.aws.amazon.com/general/latest/gr/rande.html#iotevents_region) en la *Referencia general de AWS*. Para [obtener ayuda, consulte Cómo empezar con un servicio Consola de administración de AWS en la](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/start-service.html) *sección Cómo empezar con Consola de administración de AWS*.

# Cree una entrada para los modelos en AWS IoT Events
<a name="create-input-overview"></a>

Al construir las entradas para sus modelos, le recomendamos que reúna archivos que contengan cargas de mensajes de muestra que sus dispositivos o procesos envíen para informar de su estado. Disponer de estos archivos le ayudará a definir las entradas necesarias. 

Puede crear una entrada a través de varios métodos, que se describen en esta sección.

## Cree un archivo de entrada JSON
<a name="create-input-file"></a>

1. Para empezar, cree un archivo llamado `input.json` en su sistema de archivos local con el siguiente contenido:

   ```
   {
     "motorid": "Fulton-A32",
     "sensorData": {
       "pressure": 23,
       "temperature": 47
     }
   }
   ```

1. Ahora que tiene este archivo `input.json` de inicio, puede crear una entrada. Hay dos formas de crear una entrada. Puede crear una entrada mediante el panel de navegación de la [AWS IoT Events consola](https://console.aws.amazon.com/iotevents/). O bien, puede crear una entrada dentro del modelo de detector después de crearla.

## Cree y configure una entrada
<a name="create-input"></a>

Aprenda a crear una *entrada* para un modelo de alarma o un modelo de detector.

1. Inicie sesión en la [AWS IoT Events consola](https://console.aws.amazon.com/iotevents/) o seleccione la opción Crear una AWS IoT Events cuenta nueva.

1. En la AWS IoT Events consola, en la esquina superior izquierda, selecciona y expande el panel de navegación.

1. En el panel de navegación izquierdo, seleccione **Entradas**.

1. En la esquina derecha de la consola, seleccione **Crear entrada**.

1. Proporcione un único **InputName**.

1. *Opcional*: introduce una **descripción** para tu entrada.

1. Para **cargar un archivo JSON**, selecciona el `input.json` archivo para el que has creado en la descripción general[Cree un archivo de entrada JSON](#create-input-file). La **opción Elegir atributos de entrada** aparece junto con una lista de los atributos introducidos.

1. En **Elegir atributos de entrada**, seleccione los atributos que desee utilizar y luego **Crear**. En este ejemplo, seleccionamos **motorid** y **sensorData.pressure**. 

1. *Opcional*: añada las **etiquetas** pertinentes a la entrada.

**nota**  
También puede crear entradas adicionales dentro del modelo de detector de la [AWS IoT Events consola](https://console.aws.amazon.com/iotevents/). Para obtener más información, consulte [Cree una entrada dentro del modelo de detector en AWS IoT Events](iotevents-detector-input.md).

# Cree una entrada dentro del modelo de detector en AWS IoT Events
<a name="iotevents-detector-input"></a>

Las entradas del detector AWS IoT Events sirven de puente entre las fuentes de datos y los modelos de detectores. Las entradas del detector proporcionan los datos sin procesar que impulsan las capacidades de automatización y detección de eventos de AWS IoT Events. Aprenda a configurar las entradas de los detectores para ayudar a sus modelos a responder con precisión a los eventos y condiciones del mundo real en su ecosistema de IoT.

En esta sección se muestra cómo definir una *entrada* para que un modelo de detector reciba datos o mensajes de telemetría.

**Para definir una entrada para un modelo de detector**

1. Abra la [consola de AWS IoT Events](https://console.aws.amazon.com/iotevents/).

1. En la AWS IoT Events consola, elija **Crear modelo de detector**.

1. Elija **Crear nuevo**.

1. Elija **Create input (Crear entrada)**.

1. Para la entrada, introduzca una **InputName**, una **descripción** opcional y elija **Cargar archivo**. En el cuadro de diálogo que aparece, seleccione el `input.json` archivo para el que creó en la vista general[Cree un archivo de entrada JSON](create-input-overview.md#create-input-file). 

1. En **Elegir atributos de entrada**, seleccione los atributos que desee utilizar y luego **Crear**. En este ejemplo, seleccionamos **MotorID y **SensorData.PRESSURE****. 

# Cree un modelo de detector en AWS IoT Events
<a name="iotevents-detector-model"></a>

En este tema, define un *modelo de detector* (un modelo de su equipo o proceso) utilizando *estados*.

Para cada estado, debe definir una lógica condicional (booleana) que evalúe las entradas para detectar un evento significativo. Al detectar un evento, este cambia el estado y puede iniciar acciones adicionales. Estos eventos se conocen como eventos de transición.

En sus estados, también define eventos que pueden ejecutar acciones cada vez que el detector entra o sale de ese estado o cuando se recibe una entrada (se conocen como eventos `OnEnter`, `OnExit` y `OnInput`). Las acciones se ejecutan solo si la lógica condicional del evento da como resultado `true`.

**Para crear un modelo de detector**

1. Se ha creado el primer estado del detector para usted. Para modificarlo, seleccione el círculo con la etiqueta **State\$11** en el espacio de edición principal.

1. En el panel **Estado**, introduzca el **nombre del estado** y **OnEnter**elija **Añadir evento**. 

1. En la página **Añadir OnEnter evento**, introduzca el **nombre del evento** y la **condición del evento**. En este ejemplo, introduzca `true` para indicar que el evento siempre se inicia al introducir el estado. 

1. En **Acciones del evento**, seleccione **Añadir acción**.

1. En **Acciones del evento**, realice lo siguiente:

   1. Seleccione **Establecer variable**

   1.  En **Operación de la variable**, seleccione **Asignar valor**.

   1. En **Nombre de la variable**, introduzca el nombre de la variable que va a establecer.

   1. En **Valor de la variable**, introduzca el valor **0** (cero).

1. Seleccione **Save**. 

   Una variable, como la que ha definido, se puede establecer (darle un valor) en cualquier evento del modelo de detector. Solo se puede hacer referencia al valor de la variable (por ejemplo, en la lógica condicional de un evento) después de que el detector haya alcanzado un estado y ejecutado una acción donde esté definido o establecido.

1. En el panel **Estado**, seleccione la **X** situada junto a **Estado** para volver a la **Paleta de modelos de detectores**.

1. Para crear un segundo estado de detector, en la **Paleta de modelos de detectores**, seleccione **Estado** y arrástrelo al espacio de edición principal. Esto crea un estado titulado `untitled_state_1`.

1. Haga una pausa en el primer estado (**Normal**). Aparece una flecha en la circunferencia de estado.

1. Pulse y arrastre la flecha del primer estado al segundo estado. Aparece una línea dirigida del primer estado al segundo estado (denominada **Sin título**).

1. Seleccione la línea **Sin título**. En el panel **Evento de transición**, introduzca el **Nombre del evento** y una **Lógica de activación del evento**.

1. En el panel **Evento de transición**, seleccione **Añadir acción**.

1. En el panel **Añadir acciones de evento de transición**, seleccione **Añadir acción**. 

1.  En **Elegir una acción**, seleccione **Establecer variable**. 

   1. En **Operación de la variable**, seleccione **Asignar valor**.

   1. En **Nombre de la variable**, introduzca el nombre de la variable.

   1. En **Asignar valor**, escriba el valor, como `$variable.pressureThresholdBreached + 3`:

   1. Seleccione **Save**.

1. Seleccione el segundo estado **untitled\$1state\$11**.

1. En el panel **Estado**, introduzca el **Nombre del estado** y en **OnEnter**, seleccione **Añadir evento**.

1. En la página **Añadir OnEnter evento**, introduzca el **nombre del evento** y la **condición del evento**. Seleccione **Agregar acción**.

1. En **Seleccionar una acción**, seleccione **Enviar mensaje SNS**.

   1. En **Tema de SNS**, introduzca el ARN objetivo de su tema de Amazon SNS.

   1. Seleccione **Save**.

1. Siga añadiendo los eventos indicados en el ejemplo.

   1. Para **OnInput**, elija **Agregar evento** e introduzca y guarde la siguiente información del evento.

      ```
        Event name: Overpressurized
        Event condition: $input.PressureInput.sensorData.pressure > 70
        Event actions:
          Set variable:
            Variable operation: Assign value
            Variable name: pressureThresholdBreached
            Assign value: 3
      ```

   1. Para **OnInput**, elija **Agregar evento** e introduzca y guarde la siguiente información del evento.

      ```
        Event name: Pressure Okay
        Event condition: $input.PressureInput.sensorData.pressure <= 70
        Event actions:
          Set variable:
            Variable operation: Decrement
            Variable name: pressureThresholdBreached
      ```

   1. Para **OnExit**, elija **Añadir evento** e introduzca y guarde la siguiente información del evento con el ARN del tema de Amazon SNS que ha creado.

      ```
        Event name: Normal Pressure Restored
        Event condition: true
        Event actions:
          Send SNS message: 
            Target arn: arn:aws:sns:us-east-1:123456789012:pressureClearedAction
      ```

1. Haga una pausa en el segundo estado (**Peligroso**``). Aparece una flecha en la circunferencia del estado

1. Pulse y arrastre la flecha del segundo estado al primer estado. Aparece una línea dirigida con la etiqueta **Sin título**.

1. Seleccione la línea **Sin título** y en el panel **Evento de transición**, introduzca el **Nombre del evento** y la **Lógica de activación del evento** utilizando la siguiente información.

   ```
   {
     Event name: BackToNormal
     Event trigger logic: $input.PressureInput.sensorData.pressure <= 70 && $variable.pressureThresholdBreached <= 0
   }
   ```

   Para obtener más información sobre por qué probamos el valor `$input` y el valor `$variable` en la lógica de activación, consulte en la entrada la disponibilidad de los valores de las variables en [AWS IoT Events restricciones y limitaciones del modelo de detector](iotevents-restrictions-detector-model.md).

1. Seleccione el estado **Inicio**. Por defecto, este estado se generó cuando creó un modelo de detector). En el panel **Inicio**, seleccione el **Estado de destino** (por ejemplo, **Normal**).

1. A continuación, configure su modelo de detector para que escuche las entradas. En la esquina superior derecha, seleccione **Publicar**.

1. En la página **Publicar modelo de detector**, haga lo siguiente.

   1.  Introduzca el **Nombre del modelo de detector**, una **Descripción** y el nombre de un **Rol**. Este rol se crea para usted.

   1. Seleccione **Crear un detector para cada valor clave único**. Para crear su propio **Rol** y utilizarlo, siga los pasos que se indican en [Configuración de permisos para AWS IoT Events](iotevents-permissions.md) e introdúzcalo como **Rol** aquí.

1. En **Clave de creación del detector**, elija el nombre de uno de los atributos de la entrada que definió anteriormente. El atributo que elija como clave de creación del detector debe estar presente en cada entrada de mensaje y debe ser único para cada dispositivo que envíe mensajes. En este ejemplo se utiliza el atributo **motorid**.

1. Seleccione **Guardar y publicar**.

**nota**  
El número de detectores únicos creados para un modelo de detector determinado se basa en los mensajes de entrada enviados. Cuando se crea un modelo de detector, se selecciona una clave a partir de los atributos de entrada. Esta clave determina qué instancia de detector se utilizará. Si la clave no se ha visto antes (para este modelo de detector), se crea una nueva instancia de detector. Si se ha visto antes, se utiliza la instancia de detector existente correspondiente a este valor clave.

Puede hacer una copia de seguridad de la definición de su modelo de detector (en JSON), recrear o actualizar el modelo de detector, o utilizarlo como plantilla para crear otro modelo de detector.

Puede hacerlo desde la consola o utilizando el siguiente comando CLI. De ser necesario, cambie el nombre del modelo de detector para que coincida con el que utilizó al publicarlo en el paso anterior.

```
aws iotevents describe-detector-model  --detector-model-name motorDetectorModel > motorDetectorModel.json 
```

Esto crea un archivo (`motorDetectorModel.json`) que tiene un contenido similar al siguiente.

```
{
    "detectorModel": {
        "detectorModelConfiguration": {
            "status": "ACTIVE", 
            "lastUpdateTime": 1552072424.212, 
            "roleArn": "arn:aws:iam::123456789012:role/IoTEventsRole", 
            "creationTime": 1552072424.212, 
            "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": "Back to Normal", 
                                "actions": [], 
                                "condition": "$variable.pressureThresholdBreached <= 1 && $input.PressureInput.sensorData.pressure <= 70", 
                                "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-west-2:123456789012:MyIoTButtonSNSTopic"
                                        }
                                    }
                                ], 
                                "condition": "$variable.pressureThresholdBreached > 1"
                            }
                        ]
                    }, 
                    "onExit": {
                        "events": [
                            {
                                "eventName": "Normal Pressure Restored", 
                                "actions": [
                                    {
                                        "sns": {
                                            "targetArn": "arn:aws:sns:us-west-2:123456789012:IoTVirtualButtonTopic"
                                        }
                                    }
                                ], 
                                "condition": "true"
                            }
                        ]
                    }
                }
            ], 
            "initialStateName": "Normal"
        }
    }
}
```

# Envíe las entradas para probar el modelo de detector en AWS IoT Events
<a name="iotevents-iot-rules-engine"></a>

Hay varias formas de recibir datos de telemetría en AWS IoT Events (consulte[Acciones compatibles para recibir datos y activar acciones en AWS IoT Events](iotevents-supported-actions.md)). En este tema se muestra cómo crear una AWS IoT regla en la AWS IoT consola que reenvíe los mensajes como entradas al detector. AWS IoT Events Puede utilizar el cliente MQTT de la AWS IoT consola para enviar mensajes de prueba. Puede usar este método para obtener datos de telemetría para saber AWS IoT Events cuándo sus dispositivos pueden enviar mensajes MQTT mediante el intermediario de mensajes. AWS IoT 

**Para enviar entradas para probar el modelo de detector**

1. Abra la [consola de AWS IoT Core](https://console.aws.amazon.com/iot/). En el panel de navegación izquierdo, en **Administrar**, seleccione **Enrutamiento de mensajes** y luego **Reglas**.

1. Seleccione **Crear regla** en la esquina superior derecha.

1. En la página **Crear una regla**, siga los pasos que se indican a continuación:

   1. **Paso 1. Especificar las propiedades de la regla**. Complete los siguientes campos:
      + **Nombre de la regla.** Escriba un nombre para su regla, como `MyIoTEventsRule`.
**nota**  
No utilice espacios.
      + **Descripción de la regla**. Es opcional.
      + Elija **Siguiente**.

   1. **Paso 2. Configurar la instrucción SQL**. Complete los siguientes campos:
      + **Versión de SQL**. Seleccione la opción apropiada en la lista.
      + **Sentencia SQL.** Escriba **SELECT \$1, topic(2) as motorid FROM 'motors/\$1/status'**. 

      Elija **Siguiente**.

   1. **Paso 3. Añadir acciones de la regla**. En la sección **Acciones de la regla**, complete lo siguiente:
      + **Acción 1. Seleccione IoT Events.** Se muestran los siguientes campos:

        1. **Nombre de la entrada**. Seleccione la opción apropiada en la lista. Si la entrada no aparece, seleccione **Actualizar**.

           Para crear una entrada nueva, seleccione **Crear entrada de IoT Events**. Complete los siguientes campos:
           + **Nombre de la entrada**. Escriba `PressureInput`.
           + **Descripción**. Es opcional.
           + **Cargar un archivo JSON**. Cargue una copia de su archivo JSON. Si no tuviera un archivo, hay un enlace a un archivo de muestra en esta pantalla. El código incluye:

             ```
             {
               "motorid": "Fulton-A32",
               "sensorData": {
                 "pressure": 23,
                 "temperature": 47
               }
             }
             ```
           + **Elegir atributos de entrada**. Seleccione las opciones apropiadas.
           + **Etiquetas**. Es opcional.

           Seleccione **Crear**.

           Vuelva a la pantalla **Crear regla** y actualice el campo **Nombre de la entrada**. Seleccione la entrada que acaba de crear.

        1. **Modo Lote**. Es opcional. Si la carga es una matriz de mensajes, seleccione esta opción.

        1. **ID de mensaje**. Esto es opcional, pero recomendable.

        1. **Rol de IAM**. Seleccione el rol apropiado en la lista. Si el rol no figura en la lista, seleccione **Crear nuevo rol**.

           Escriba el **Nombre del rol** y seleccione **Crear**.

        Para añadir otra regla, seleccione **Añadir regla**.
      + **Acción de error**. Esta sección es opcional. Para añadir una acción, seleccione **Añadir acción de error** y seleccione la acción apropiada en la lista. 

        Complete los campos que aparezcan.
      + Elija **Siguiente**.

   1. **Paso 4. Revisar y crear.** Revise la información en pantalla y seleccione **Crear**.

1. En el panel de navegación izquierdo, en **Prueba**, seleccione **Cliente de prueba MQTT**.

1. Elija **Publicar en un tema**. Complete los siguientes campos:
   + **Nombre del tema**. Introduzca un nombre para identificar el mensaje, por ejemplo, `motors/Fulton-A32/status`.
   + **Carga útil del mensaje**. Introduzca lo siguiente:

     ```
     {
       "messageId": 100,
       "sensorData": {
         "pressure": 39
       }
     }
     ```
**nota**  
Cambie el `messageId` cada vez que publique un nuevo mensaje.

1. Para **Publicar**, mantenga el tema igual, pero cambie la `"pressure"` en la carga por un valor superior al valor umbral que especificó en el modelo de detector (por ejemplo **85**).

1. Seleccione **Publicar**.

 La instancia de detector que ha creado genera y le envía un mensaje de Amazon SNS. Continúe enviando mensajes con lecturas de presión por encima o por debajo del umbral de presión (70 en este ejemplo) para ver el detector en funcionamiento. 

En este ejemplo, debe enviar tres mensajes con lecturas de presión por debajo del umbral para volver al estado **Normal** y recibir un mensaje de Amazon SNS que indique que la condición de sobrepresión ha desaparecido. Una vez de nuevo en el estado **Normal**, un mensaje con una lectura de presión por encima del límite hace que el detector pase al estado **Peligroso** y envíe un mensaje de Amazon SNS indicando esa condición.

Ahora que ha creado un modelo de detector y entrada sencillos, pruebe lo siguiente.
+ Consulte más ejemplos de modelos de detectores (plantillas) en la consola.
+ Siga los pasos [Cree un AWS IoT Events detector para dos estados mediante CLI](iotevents-simple-example.md) que se indican para crear un modelo de entrada y detector utilizando el AWS CLI
+ Conozca los detalles de las [Expresiones para filtrar, transformar y procesar datos de eventos](iotevents-expressions.md) utilizadas en los eventos. 
+ Información sobre [Acciones compatibles para recibir datos y activar acciones en AWS IoT Events](iotevents-supported-actions.md).
+ Si algo no funciona, consulte [Solución de problemas AWS IoT Events](iotevents-troubleshooting.md).