

Hinweis zum Ende des Supports: Am 20. Mai 2026 AWS endet der Support für AWS IoT Events. Nach dem 20. Mai 2026 können Sie nicht mehr auf die AWS IoT Events Konsole oder AWS IoT Events die Ressourcen zugreifen. Weitere Informationen finden Sie unter [AWS IoT Events Ende des Supports](https://docs.aws.amazon.com/iotevents/latest/developerguide/iotevents-end-of-support.html).

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# Erste Schritte mit der AWS IoT Events Konsole
<a name="iotevents-getting-started"></a>

In diesem Abschnitt erfahren Sie, wie Sie mit der [AWS IoT Events Konsole](https://console.aws.amazon.com/iotevents/) ein Eingabe- und ein Detektormodell erstellen. Sie modellieren zwei Zustände eines Motors: einen Normalzustand und einen Überdruckzustand. Wenn der gemessene Druck im Motor einen bestimmten Schwellenwert überschreitet, geht das Modell vom Normalzustand in den Überdruckzustand über. Dann sendet es eine Amazon SNS SNS-Nachricht, um einen Techniker über den Zustand zu informieren. Wenn der Druck bei drei aufeinanderfolgenden Druckmessungen wieder unter den Schwellenwert fällt, kehrt das Modell in den Normalzustand zurück und sendet eine weitere Amazon SNS SNS-Nachricht als Bestätigung.

Wir prüfen, ob drei aufeinanderfolgende Messwerte unter dem Druckschwellenwert liegen, um ein mögliches Stottern bei Überdruck oder normalen Meldungen im Falle einer nichtlinearen Erholungsphase oder einer anomalen Druckmessung zu vermeiden.

Auf der Konsole finden Sie auch mehrere vorgefertigte Modellvorlagen für Melder, die Sie anpassen können. Sie können die Konsole auch verwenden, um Meldermodelle zu importieren, die von anderen geschrieben wurden, oder um Ihre Meldermodelle zu exportieren und sie in verschiedenen AWS Regionen zu verwenden. Wenn Sie ein Meldermodell importieren, stellen Sie sicher, dass Sie die erforderlichen Eingaben erstellen oder sie für die neue Region neu erstellen, und aktualisieren Sie alle ARNs verwendeten Rollen.

Verwenden Sie die AWS IoT Events Konsole, um mehr über Folgendes zu erfahren.

**Definieren Sie Eingaben**  
Um Ihre Geräte und Prozesse zu überwachen, müssen sie über eine Möglichkeit verfügen, Telemetriedaten in AWS IoT Events zu übertragen. Dies geschieht, indem Nachrichten als *Eingaben* an gesendet AWS IoT Events werden. Hierfür gibt es mehrere Möglichkeiten:  
+ Benutze die [ BatchPutMessage](https://docs.aws.amazon.com/iotevents/latest/apireference/API_iotevents-data_BatchPutMessage.html)Operation.
+ Schreiben Sie in AWS IoT Core eine [AWS IoT Events Aktionsregel](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html#iotevents-rule) für die AWS IoT Regel-Engine, die Ihre Nachrichtendaten weiterleitet. AWS IoT Events Sie müssen die Eingabe anhand des Namens identifizieren.
+ Verwenden Sie in AWS IoT Analytics die [ CreateDataset](https://docs.aws.amazon.com/iotanalytics/latest/userguide/automate.html#aws-iot-analytics-automate-create-dataset)Operation, um einen Datensatz mit zu erstellen`contentDeliveryRules`. Diese Regeln spezifizieren die AWS IoT Events Eingabe, an die der Inhalt des Datensatzes automatisch gesendet wird.
Bevor Ihre Geräte Daten auf diese Weise senden können, müssen Sie einen oder mehrere Eingänge definieren. Geben Sie dazu jeder Eingabe einen Namen und geben Sie an, welche Felder in den eingehenden Nachrichtendaten von der Eingabe überwacht werden.

**Erstellen Sie ein Detektormodell**  
Definieren Sie mithilfe von *Zuständen* ein *Detektormodell* (ein Modell Ihrer Ausrüstung oder Ihres Prozesses). Definieren Sie für jeden Status eine bedingte (boolesche) Logik, die die eingehenden Eingaben auswertet, um signifikante Ereignisse zu erkennen. Wenn das Detektormodell ein Ereignis erkennt, kann es den Status ändern oder mithilfe anderer Dienste benutzerdefinierte oder vordefinierte Aktionen auslösen. AWS Sie können zusätzliche Ereignisse definieren, die Aktionen auslösen, wenn Sie einen Status betreten oder verlassen und optional, wenn eine Bedingung erfüllt ist.   
In diesem Tutorial senden Sie eine Amazon SNS SNS-Nachricht als Aktion, wenn das Modell in einen bestimmten Status eintritt oder diesen verlässt.

**Überwachen Sie ein Gerät oder einen Prozess**  
Wenn Sie mehrere Geräte oder Prozesse überwachen, geben Sie in jeder Eingabe ein Feld an, das das jeweilige Gerät oder den Prozess identifiziert, von dem die Eingabe stammt. Das `key` Feld finden Sie in`CreateDetectorModel`. Wenn das von identifizierte Eingabefeld einen neuen Wert `key` erkennt, wird ein neues Gerät identifiziert und ein Detektor erstellt. Jeder Detektor ist ein Exemplar des Detektormodells. Der neue Detektor reagiert weiterhin auf Eingaben von diesem Gerät, bis sein Detektormodell aktualisiert oder gelöscht wird.  
Wenn Sie einen einzelnen Prozess überwachen (auch wenn mehrere Geräte oder Unterprozesse Eingaben senden), geben Sie kein eindeutiges `key` Identifikationsfeld an. In diesem Fall erzeugt das Modell einen einzelnen Detektor (Instanz), wenn die erste Eingabe eingeht.

**Senden Sie Nachrichten als Eingaben an Ihr Detektormodell**  
Es gibt mehrere Möglichkeiten, eine Nachricht von einem Gerät oder Prozess als Eingabe in einen AWS IoT Events Detektor zu senden, ohne dass Sie die Nachricht zusätzlich formatieren müssen. In diesem Tutorial verwenden Sie die AWS IoT Konsole, um eine [AWS IoT Events Aktionsregel](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rule-actions.html#iotevents-rule) für die AWS IoT Regel-Engine zu schreiben, in AWS IoT Events die Ihre Nachrichtendaten weitergeleitet werden.  
Identifizieren Sie dazu die Eingabe anhand des Namens und verwenden Sie weiterhin die AWS IoT Konsole, um Nachrichten zu generieren, an die sie als Eingaben weitergeleitet AWS IoT Events werden.

**Anmerkung**  
In diesem Tutorial wird die Konsole verwendet, um dasselbe `input` zu erstellen. Dies `detector model` wird im Beispiel unter gezeigt[Tutorials für AWS IoT Events Anwendungsfälle](iotevents-tutorials.md). Sie können dieses JSON-Beispiel verwenden, um dem Tutorial zu folgen.

**Topics**
+ [Voraussetzungen für den Einstieg AWS IoT Events](iotevents-getting-started-prereqs.md)
+ [Erstellen Sie eine Eingabe für Modelle in AWS IoT Events](create-input-overview.md)
+ [Erstellen Sie ein Detektormodell in AWS IoT Events](iotevents-detector-model.md)
+ [Senden Sie Eingaben zum Testen des Detektormodells in AWS IoT Events](iotevents-iot-rules-engine.md)

# Voraussetzungen für den Einstieg AWS IoT Events
<a name="iotevents-getting-started-prereqs"></a>

Wenn Sie noch kein AWS Konto haben, erstellen Sie eines. 

1. Folgen Sie den Anweisungen in[Einrichten AWS IoT Events](iotevents-start.md), um sicherzustellen, dass das Konto ordnungsgemäß eingerichtet und die erforderlichen Berechtigungen erteilt wurden.

1. Erstellen Sie zwei Amazon Simple Notification Service (Amazon SNS) -Themen.

   In diesem Tutorial (und dem entsprechenden Beispiel) wird davon ausgegangen, dass Sie zwei Amazon SNS SNS-Themen erstellt haben. Die ARNs dieser Themen werden wie folgt angezeigt: `arn:aws:sns:us-east-1:123456789012:underPressureAction` und`arn:aws:sns:us-east-1:123456789012:pressureClearedAction`. Ersetzen Sie diese Werte durch die ARNs von Ihnen Amazon SNS SNS-Themen. Weitere Informationen finden Sie im [Amazon Simple Notification Service-Entwicklerhandbuch](https://docs.aws.amazon.com/sns/latest/dg/).

   Als Alternative zur Veröffentlichung von Benachrichtigungen zu Amazon SNS SNS-Themen können Sie die Detektoren MQTT-Nachrichten mit einem von Ihnen angegebenen Thema senden lassen. Mit dieser Option können Sie überprüfen, ob Ihr Detektormodell Instances erstellt und ob diese Instances Alerts senden, indem Sie die AWS IoT Core-Konsole verwenden, um Nachrichten zu abonnieren und zu überwachen, die zu diesen MQTT-Themen gesendet werden. Sie können den Namen des MQTT-Themas auch dynamisch zur Laufzeit definieren, indem Sie eine Eingabe oder Variable verwenden, die im Detektormodell erstellt wurde. 

1. Wählen Sie einen AWS-Region , der unterstützt AWS IoT Events. Weitere Informationen finden Sie unter [AWS IoT Events](https://docs.aws.amazon.com/general/latest/gr/rande.html#iotevents_region) im *Allgemeine AWS-Referenz*. Hilfe finden Sie unter [Erste Schritte mit einem Dienst im AWS-Managementkonsole](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/start-service.html) im Abschnitt *Erste Schritte mit dem AWS-Managementkonsole*.

# Erstellen Sie eine Eingabe für Modelle in AWS IoT Events
<a name="create-input-overview"></a>

Wir empfehlen, bei der Erstellung der Eingaben für Ihre Modelle Dateien zusammenzustellen, die Beispielnachrichten enthalten, die Ihre Geräte oder Prozesse zur Meldung ihres Zustands senden. Diese Dateien helfen Ihnen dabei, die erforderlichen Eingaben zu definieren. 

Sie können eine Eingabe mit mehreren Methoden erstellen, die in diesem Abschnitt beschrieben werden.

## Erstellen Sie eine JSON-Eingabedatei
<a name="create-input-file"></a>

1. Erstellen Sie zunächst eine Datei mit dem Namen `input.json` auf Ihrem lokalen Dateisystem mit dem folgenden Inhalt:

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

1. Nachdem Sie diese `input.json` Starterdatei haben, können Sie eine Eingabe erstellen. Es gibt zwei Möglichkeiten, eine Eingabe zu erstellen. Sie können eine Eingabe mithilfe des Navigationsbereichs in der [AWS IoT Events Konsole](https://console.aws.amazon.com/iotevents/) erstellen. Sie können auch eine Eingabe innerhalb des Detektormodells erstellen, nachdem es erstellt wurde.

## Erstellen und konfigurieren Sie eine Eingabe
<a name="create-input"></a>

Erfahren Sie, wie Sie eine *Eingabe* für ein Alarmmodell oder ein Meldermodell erstellen.

1. Loggen Sie sich in die [AWS IoT Events Konsole](https://console.aws.amazon.com/iotevents/) ein oder wählen Sie die Option Neues AWS IoT Events Konto erstellen.

1. Wählen Sie in der AWS IoT Events Konsole in der oberen linken Ecke den Navigationsbereich aus und erweitern Sie ihn.

1. Wählen Sie im linken Navigationsbereich **Eingaben** aus.

1. Wählen Sie in der rechten Ecke der Konsole die Option **Eingabe erstellen** aus.

1. Geben Sie ein Unikat an **InputName**.

1. *Optional* — geben Sie eine **Beschreibung** für Ihre Eingabe ein.

1. Um **eine JSON-Datei hochzuladen**, wählen Sie die `input.json` Datei aus, die Sie in der Übersicht für erstellt haben[Erstellen Sie eine JSON-Eingabedatei](#create-input-file). Die **Option Eingabeattribute auswählen** wird mit einer Liste der von Ihnen eingegebenen Attribute angezeigt.

1. **Wählen Sie unter Eingabeattribute** auswählen die zu verwendenden Attribute aus und klicken Sie auf **Erstellen**. In diesem Beispiel wählen wir **motorid** und **sensorData.Pressure** aus. 

1. *Optional* — Fügen Sie der Eingabe relevante **Tags** hinzu.

**Anmerkung**  
Sie können auch zusätzliche Eingaben innerhalb des Meldermodells in der [AWS IoT Events Konsole](https://console.aws.amazon.com/iotevents/) erstellen. Weitere Informationen finden Sie unter [Erstellen Sie eine Eingabe innerhalb des Detektormodells in AWS IoT Events](iotevents-detector-input.md).

# Erstellen Sie eine Eingabe innerhalb des Detektormodells in AWS IoT Events
<a name="iotevents-detector-input"></a>

Die Detektoreingänge AWS IoT Events dienen als Brücke zwischen Ihren Datenquellen und Detektormodellen. Die Detektoreingänge liefern die Rohdaten, die die Ereigniserkennungs- und Automatisierungsfunktionen von unterstützen AWS IoT Events. Erfahren Sie, wie Sie Detektoreingänge konfigurieren, damit Ihre Modelle präzise auf reale Ereignisse und Bedingungen in Ihrem IoT-Ökosystem reagieren können.

In diesem Abschnitt wird gezeigt, wie Sie einen *Eingang* für ein Detektormodell definieren, um Telemetriedaten oder Nachrichten zu empfangen.

**Um eine Eingabe für ein Detektormodell zu definieren**

1. Öffnen Sie die [AWS IoT Events -Konsole](https://console.aws.amazon.com/iotevents/).

1. Wählen Sie in der AWS IoT Events Konsole die Option **Detektormodell erstellen** aus.

1. Wählen Sie **Neu erstellen**.

1. Wählen Sie **Create input (Eingabe erstellen)**.

1. Geben Sie für die Eingabe eine **InputName**optionale **Beschreibung** ein und wählen Sie **Datei hochladen**. Wählen Sie im daraufhin angezeigten Dialogfeld die `input.json` Datei aus, für die Sie in der Übersicht erstellt haben[Erstellen Sie eine JSON-Eingabedatei](create-input-overview.md#create-input-file). 

1. **Wählen Sie unter Eingabeattribute** auswählen die zu verwendenden Attribute aus und klicken Sie auf **Erstellen**. In diesem Beispiel wählen wir **MotorID** und **SensorData.Pressure** aus. 

# Erstellen Sie ein Detektormodell in AWS IoT Events
<a name="iotevents-detector-model"></a>

In diesem Thema definieren Sie mithilfe von *Zuständen* ein *Detektormodell* (ein Modell Ihrer Ausrüstung oder Ihres Prozesses).

Für jeden Status definieren Sie eine bedingte (boolesche) Logik, die die eingehenden Eingaben auswertet, um ein signifikantes Ereignis zu erkennen. Wenn ein Ereignis erkannt wird, ändert es den Status und kann zusätzliche Aktionen einleiten. Diese Ereignisse werden als Übergangsereignisse bezeichnet.

In Ihren Zuständen definieren Sie auch Ereignisse, die Aktionen ausführen können, wenn der Melder in diesen Zustand eintritt oder ihn verlässt oder wenn eine Eingabe eingeht (diese Ereignisse werden als `OnEnter` `OnInput` AND-Ereignisse bezeichnet). `OnExit` Die Aktionen werden nur ausgeführt, wenn die Bedingungslogik des Ereignisses Folgendes ergibt. `true`

**So erstellen Sie ein Detektormodell**

1. Der erste Melderstatus wurde für Sie erstellt. Um ihn zu ändern, wählen Sie den Kreis mit der Bezeichnung **State\$11** im Hauptbearbeitungsbereich aus.

1. Geben Sie im Bereich „**Status**“ den **Namen des Bundesstaates** ein und wählen Sie „**OnEnter**Ereignis **hinzufügen**“. 

1. Geben Sie auf der Seite „** OnEnter Ereignis hinzufügen**“ einen **Namen für das Ereignis** und die **Bedingung für das Ereignis** ein. Geben Sie in diesem Beispiel ein, `true` um anzugeben, dass das Ereignis immer ausgelöst wird, wenn der Status eingegeben wird. 

1. Wählen Sie unter **Ereignisaktionen** die Option **Aktion hinzufügen** aus.

1. Gehen Sie unter **Ereignisaktionen** wie folgt vor:

   1. Wählen Sie „**Variable festlegen**“

   1.  Wählen Sie für **den Variablenbetrieb** die Option **Wert zuweisen** aus.

   1. Geben Sie **unter Variablenname** den Namen der Variablen ein, die festgelegt werden soll.

   1. Geben Sie für **Variablenwert** den Wert **0** (Null) ein.

1. Wählen Sie **Speichern**. 

   Eine Variable, wie die, die Sie definiert haben, kann auf jeden Fall im Detektormodell festgelegt werden (mit einem Wert). Auf den Wert der Variablen kann erst verwiesen werden (z. B. in der bedingten Logik eines Ereignisses), wenn der Detektor einen Status erreicht hat und eine Aktion ausgeführt hat, in der er definiert oder gesetzt ist.

1. Wählen Sie im **Statusbereich** das **X** neben **Status**, um zur **Modellpalette Detector** zurückzukehren.

1. Um einen zweiten Detektorstatus zu erstellen, wählen Sie in der **Modellpalette Detektor** die Option **Status** und ziehen Sie ihn in den Hauptbearbeitungsbereich. Dadurch wird ein Zustand mit dem Titel erstellt`untitled_state_1`.

1. Halten Sie im ersten Status (**Normal**) an. Am Rand des Bundesstaats erscheint ein Pfeil.

1. Klicken Sie auf den Pfeil und ziehen Sie ihn vom ersten Status in den zweiten Status. Eine gerichtete Linie vom ersten zum zweiten Status (mit der Bezeichnung **Unbenannt**) wird angezeigt.

1. Wählen Sie die Linie **Ohne Titel** aus. Geben Sie im Bereich „**Übergangsereignis**“ einen **Namen für das Ereignis** und eine **Logik für das Ereignis** ein.

1. Wählen Sie im Bereich „**Übergangsereignis**“ die Option **Aktion hinzufügen** aus.

1. Wählen **Sie im Bereich „Aktionen für Übergangsereignis** hinzufügen“ die Option **Aktion hinzufügen** aus. 

1.  **Wählen Sie für Aktion** auswählen die Option **Variable festlegen** aus. 

   1. Wählen Sie für **Variablenoperation** die Option **Wert zuweisen** aus.

   1. Geben Sie **unter Variablenname** den Namen der Variablen ein.

   1. Geben **Sie für Wert zuweisen** einen Wert ein, z. B.: `$variable.pressureThresholdBreached + 3`

   1. Wählen Sie **Speichern**.

1. Wählen Sie den zweiten Status **untitled\$1state\$11** aus.

1. ****Geben Sie im Bereich „**Status“ den **Namen** des Bundesstaates** ein und wählen Sie für „Bei Eingabe“ die Option „Ereignis hinzufügen“ aus.****

1. Geben Sie auf der Seite „** OnEnter Ereignis hinzufügen**“ den **Namen des Ereignisses** und die **Bedingung für das Ereignis** ein. Wählen Sie **Aktion hinzufügen** aus.

1. **Wählen Sie für Aktion auswählen** die Option **SNS-Nachricht senden** aus.

   1. Geben Sie **unter SNS-Thema** den Ziel-ARN Ihres Amazon SNS SNS-Themas ein.

   1. Wählen Sie **Speichern**.

1. Fahren Sie mit dem Hinzufügen der Ereignisse im Beispiel fort.

   1. Wählen Sie für **OnInput****Ereignis hinzufügen** und geben Sie die folgenden Ereignisinformationen ein und speichern Sie sie.

      ```
        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. Wählen Sie für **OnInput**„**Ereignis hinzufügen**“ und geben Sie die folgenden Ereignisinformationen ein und speichern Sie sie.

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

   1. Wählen Sie für **OnExit****Ereignis hinzufügen** und geben Sie die folgenden Ereignisinformationen ein und speichern Sie sie unter Verwendung des ARN des Amazon SNS SNS-Themas, das Sie erstellt haben.

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

1. Halten Sie im zweiten Status (**Gefährlich**``) an. Am Rand des Bundesstaats erscheint ein Pfeil

1. Klicken Sie auf den Pfeil und ziehen Sie ihn vom zweiten Status in den ersten Status. Eine gerichtete Linie mit der Bezeichnung **Unbenannt** wird angezeigt.

1. Wählen Sie die Zeile **„Unbenannt“** und geben Sie im Bereich „**Übergangsereignis**“ anhand der folgenden **Informationen einen Namen** für das **Ereignis und eine Logik** für das Ereignis ein.

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

   Weitere Informationen darüber, warum wir den `$input` Wert und den `$variable` Wert in der Triggerlogik testen, finden Sie im Eintrag zur Verfügbarkeit von Variablenwerten unter. [AWS IoT Events Einschränkungen und Einschränkungen des Detektormodells](iotevents-restrictions-detector-model.md)

1. Wählen Sie den **Startstatus** aus. Standardmäßig wurde dieser Status erstellt, als Sie ein Detektormodell erstellt haben). Wählen Sie im **Startbereich** den **Zielstatus** aus (z. B. **Normal**).

1. Als Nächstes konfigurieren Sie Ihr Meldermodell so, dass es auf Eingaben wartet. **Wählen Sie in der oberen rechten Ecke Veröffentlichen.**

1. Gehen Sie auf der Seite **Meldermodell veröffentlichen** wie folgt vor.

   1.  Geben Sie einen **Modellnamen für den Detektor**, eine **Beschreibung** und den Namen einer **Rolle** ein. Diese Rolle wurde für Sie erstellt.

   1. Wählen Sie **für jeden eindeutigen Schlüsselwert einen Detektor erstellen** aus. Um Ihre eigene **Rolle** zu erstellen und zu verwenden, folgen Sie den Schritten unter [Berechtigungen einrichten für AWS IoT Events](iotevents-permissions.md) und geben Sie sie hier als **Rolle** ein.

1. Wählen Sie **unter Detector creation key** den Namen eines der Attribute der Eingabe, die Sie zuvor definiert haben. Das Attribut, das Sie als Schlüssel für die Erstellung des Melders wählen, muss in jeder Nachrichteneingabe vorhanden sein und für jedes Gerät, das Nachrichten sendet, eindeutig sein. In diesem Beispiel wird das **motorid-Attribut** verwendet.

1. Wählen Sie **Save and publish (Speichern und veröffentlichen)**.

**Anmerkung**  
Die Anzahl der eindeutigen Melder, die für ein bestimmtes Detektormodell erstellt wurden, basiert auf den gesendeten Eingangsmeldungen. Wenn ein Detektormodell erstellt wird, wird ein Schlüssel aus den Eingabeattributen ausgewählt. Dieser Schlüssel bestimmt, welche Detektorinstanz verwendet werden soll. Wenn der Schlüssel noch nie gesehen wurde (für dieses Detektormodell), wird eine neue Detektorinstanz erstellt. Wenn der Schlüssel schon einmal gesehen wurde, verwenden wir die bestehende Detektorinstanz, die diesem Schlüsselwert entspricht.

Sie können eine Sicherungskopie Ihrer Detektormodelldefinition (in JSON) erstellen, das Detektormodell neu erstellen oder aktualisieren oder als Vorlage verwenden, um ein anderes Detektormodell zu erstellen.

Sie können dies von der Konsole aus oder mit dem folgenden CLI-Befehl tun. Ändern Sie bei Bedarf den Namen des Detektormodells so, dass er dem entspricht, den Sie bei der Veröffentlichung im vorherigen Schritt verwendet haben.

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

Dadurch wird eine Datei (`motorDetectorModel.json`) erstellt, deren Inhalt dem folgenden ähnelt.

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

# Senden Sie Eingaben zum Testen des Detektormodells in AWS IoT Events
<a name="iotevents-iot-rules-engine"></a>

Es gibt mehrere Möglichkeiten, Telemetriedaten zu empfangen AWS IoT Events (siehe[Unterstützte Aktionen zum Empfangen von Daten und Auslösen von Aktionen in AWS IoT Events](iotevents-supported-actions.md)). In diesem Thema erfahren Sie, wie Sie in der AWS IoT Konsole eine AWS IoT Regel erstellen, die Nachrichten als Eingaben an Ihren AWS IoT Events Detektor weiterleitet. Sie können den MQTT-Client der AWS IoT Konsole verwenden, um Testnachrichten zu senden. Sie können diese Methode verwenden, um Telemetriedaten darüber abzurufen, AWS IoT Events wann Ihre Geräte MQTT-Nachrichten über den AWS IoT Message Broker senden können.

**Um Eingaben zu senden, um das Detektormodell zu testen**

1. Öffnen Sie die [AWS IoT Core -Konsole](https://console.aws.amazon.com/iot/). Wählen Sie im linken Navigationsbereich unter **Verwalten** die Option **Nachrichtenweiterleitung** und anschließend **Regeln** aus.

1. Wählen **Sie oben rechts Regel erstellen** aus.

1. Führen Sie auf der Seite **Regel erstellen** die folgenden Schritte aus:

   1. **Schritt 1. Geben Sie die Eigenschaften der Regel** an. Füllen Sie die folgenden Felder aus:
      + **Name der Regel.** Geben Sie einen Namen für Ihre Regel ein, z. `MyIoTEventsRule` B.
**Anmerkung**  
Verwenden Sie keine Leerzeichen.
      + **Beschreibung der Regel**. Das ist optional.
      + Wählen Sie **Weiter** aus.

   1. **Schritt 2. Konfigurieren Sie die SQL-Anweisung**. Füllen Sie die folgenden Felder aus:
      + **SQL-Version**. Wählen Sie die entsprechende Option aus der Liste aus.
      + **SQL-Anweisung**. Geben Sie **SELECT \$1, topic(2) as motorid FROM 'motors/\$1/status'** ein. 

      Wählen Sie **Weiter** aus.

   1. **Schritt 3. Regelaktionen anhängen** Gehen Sie im Abschnitt **Regelaktionen** wie folgt vor:
      + **Aktion 1. Wählen Sie IoT Events aus.** Die folgenden Felder werden angezeigt:

        1. **Geben Sie den Namen ein**. Wählen Sie die entsprechende Option aus der Liste aus. Wenn Ihre Eingabe nicht angezeigt wird, wählen Sie **Aktualisieren**.

           Um eine neue Eingabe zu erstellen, wählen Sie **Create IoT Events input** aus. Füllen Sie die folgenden Felder aus:
           + **Geben Sie den Namen ein**. Geben Sie `PressureInput` ein.
           + **Beschreibung**. Das ist optional.
           + **Laden Sie eine JSON-Datei** hoch. Laden Sie eine Kopie Ihrer JSON-Datei hoch. Auf diesem Bildschirm befindet sich ein Link zu einer Beispieldatei, falls Sie keine Datei haben. Der Code beinhaltet:

             ```
             {
               "motorid": "Fulton-A32",
               "sensorData": {
                 "pressure": 23,
                 "temperature": 47
               }
             }
             ```
           + **Wählen Sie Eingabeattribute**. Wählen Sie die entsprechende (n) Option (en) aus.
           + **Tags**. Dies ist optional.

           Wählen Sie **Erstellen** aus.

           Kehren **Sie zum Bildschirm Regel erstellen** zurück und aktualisieren Sie das Feld **Eingabename**. Wählen Sie die Eingabe aus, die Sie gerade erstellt haben.

        1. **Batch-Modus**. Das ist optional. Wenn es sich bei der Payload um ein Array von Nachrichten handelt, wählen Sie diese Option.

        1. **Nachrichten-ID.** Dies ist zwar optional, wird aber empfohlen.

        1. **IAM role (IAM-Rolle**. Wählen Sie die entsprechende Rolle aus der Liste aus. Wenn die Rolle nicht aufgeführt ist, wählen Sie **Neue Rolle erstellen** aus.

           Geben Sie einen **Rollennamen** ein und wählen Sie **Erstellen** aus.

        Um eine weitere Regel hinzuzufügen, wählen Sie **Regelaktion hinzufügen**
      + **Fehleraktion**. Dieser Abschnitt ist optional. Um eine Aktion hinzuzufügen, wählen Sie **Fehleraktion hinzufügen** und wählen Sie die entsprechende Aktion aus der Liste aus. 

        Füllen Sie die angezeigten Felder aus.
      + Wählen Sie **Weiter** aus.

   1. **Schritt 4. Überprüfen und erstellen.** Überprüfen Sie die Informationen auf dem Bildschirm und wählen Sie **Erstellen**.

1. Wählen Sie im linken Navigationsbereich unter **Test** die Option **MQTT-Testclient** aus.

1. Wählen Sie **Publish to topic (In Thema veröffentlichen)** aus. Füllen Sie die folgenden Felder aus:
   + **Name des Themas**. Geben Sie einen Namen ein, um die Nachricht zu identifizieren, z. `motors/Fulton-A32/status` B.
   + **Nutzlast der Nachricht**. Geben Sie Folgendes ein:

     ```
     {
       "messageId": 100,
       "sensorData": {
         "pressure": 39
       }
     }
     ```
**Anmerkung**  
Ändern Sie die `messageId` jedes Mal, wenn Sie eine neue Nachricht veröffentlichen.

1. Behalten Sie für **Publish** das gleiche Thema bei, ändern Sie das `"pressure"` in der Payload jedoch auf einen Wert, der über dem Schwellenwert liegt, den Sie im Detektormodell angegeben haben (z. B.**85**).

1. Wählen Sie **Publish**.

 Die von Ihnen erstellte Detector-Instance generiert und sendet Ihnen eine Amazon SNS SNS-Nachricht. Senden Sie weiterhin Nachrichten mit Druckwerten über oder unter dem Druckgrenzwert (70 in diesem Beispiel), um zu sehen, wie der Detektor in Betrieb ist. 

In diesem Beispiel müssen Sie drei Nachrichten mit Druckwerten unter dem Schwellenwert senden, um in den **Normalzustand** zurückzukehren und eine Amazon SNS SNS-Meldung zu erhalten, die darauf hinweist, dass der Überdruckzustand behoben ist. Sobald der Melder wieder im **Normalzustand** ist, wechselt der Detektor durch eine Meldung mit einem Druckwert über dem Grenzwert in den Status **Gefährlich** und sendet eine Amazon SNS SNS-Meldung, die auf diesen Zustand hinweist.

Nachdem Sie nun ein einfaches Eingabe- und Meldermodell erstellt haben, versuchen Sie Folgendes.
+ Weitere Beispiele (Vorlagen) für Detektormodelle finden Sie auf der Konsole.
+ Folgen Sie den Schritten unter[Erstellen Sie mit CLI einen AWS IoT Events Detektor für zwei Zustände](iotevents-simple-example.md), um ein Eingabe- und Detektormodell mit dem zu erstellen AWS CLI
+ Erfahren Sie mehr über die in den Ereignissen [Ausdrücke zum Filtern, Transformieren und Verarbeiten von Ereignisdaten](iotevents-expressions.md) verwendeten. 
+ Erfahren Sie mehr über [Unterstützte Aktionen zum Empfangen von Daten und Auslösen von Aktionen in AWS IoT Events](iotevents-supported-actions.md).
+ Wenn etwas nicht funktioniert, finden Sie weitere Informationen unter[Problembehebung AWS IoT Events](iotevents-troubleshooting.md).