

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.

# Tutorial: Formatieren einer Benachrichtigung mithilfe einer AWS Lambda Funktion
<a name="iot-lambda-rule"></a>

Dieses Tutorial zeigt, wie Sie MQTT-Nachrichtendaten an eine AWS Lambda Aktion senden, um sie zu formatieren und an einen anderen AWS Dienst zu senden. In diesem Tutorial verwendet die AWS Lambda Aktion das AWS SDK, um die formatierte Nachricht an das Amazon SNS SNS-Thema zu senden, das Sie in der Anleitung zur Vorgehensweise erstellt haben. [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md)

Im Tutorial zum Thema wie man [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md) wurde das JSON-Dokument, das sich aus der Abfrageanweisung der Regel ergab, als Hauptteil der Textnachricht gesendet. Das Ergebnis war eine Textnachricht, die in etwa so aussah wie in diesem Beispiel:

```
{"device_id":"32","reported_temperature":38,"max_temperature":30}
```

In diesem Tutorial verwenden Sie eine AWS Lambda Regelaktion, um eine AWS Lambda Funktion aufzurufen, die die Daten aus der Regelabfrageanweisung in ein benutzerfreundlicheres Format formatiert, wie in diesem Beispiel:

```
Device 32 reports a temperature of 38, which exceeds the limit of 30.
```

Die AWS Lambda Funktion, die Sie in diesem Tutorial erstellen, formatiert die Nachrichtenzeichenfolge mithilfe der Daten aus der Regelabfrageanweisung und ruft die [SNS-Veröffentlichungsfunktion](https://boto3.amazonaws.com/v1/documentation/api/latest/reference/services/sns.html#SNS.Client.publish) des AWS SDK auf, um die Benachrichtigung zu erstellen.

**Was Sie in diesem Tutorial lernen werden**
+ Wie erstellt und testet man eine Funktion AWS Lambda 
+ So verwenden Sie das AWS SDK in einer AWS Lambda Funktion zur Veröffentlichung einer Amazon SNS SNS-Benachrichtigung
+ Wie man einfache SQL-Abfragen und Funktionen in einer Regelabfrageanweisung verwendet
+ Wie benutzt man den MQTT-Client, um eine Regel zu testen AWS IoT 

Für dieses Tutorial brauchen Sie ungefähr 45 Minuten.

**Topics**
+ [Schritt 1: Erstellen Sie eine AWS Lambda Funktion, die eine Textnachricht sendet](#iot-lambda-rule-create-lambda)
+ [Schritt 2: Erstellen Sie eine AWS IoT Regel mit einer AWS Lambda Regelaktion](#iot-lambda-rule-create-rule)
+ [Schritt 3: Testen Sie die AWS IoT Regel und die AWS Lambda Regelaktion](#iot-lambda-rule-test-rule)
+ [Schritt 4: Überprüfen Sie die Ergebnisse und die nächsten Schritte](#iot-lambda-rule-next-steps)

**Stellen Sie vor Beginn dieses Tutorials sicher, dass Sie über Folgendes verfügen:**
+ 

**[Einrichten AWS-Konto](setting-up.md)**  
Sie benötigen Ihre AWS-Konto AWS IoT AND-Konsole, um dieses Tutorial abzuschließen.
+ 

**Überprüft [MQTT-Nachrichten mit dem AWS IoT MQTT-Client anzeigen](view-mqtt-messages.md)**  
Stellen Sie sicher, dass Sie den MQTT-Client verwenden können, um ein Thema zu abonnieren und zu veröffentlichen. In diesem Verfahren werden Sie den MQTT-Client verwenden, um Ihre neue Regel zu testen.
+ 

**Sie haben die anderen Regel-Tutorials in diesem Abschnitt abgeschlossen**  
Für dieses Tutorial ist das Thema SNS-Benachrichtigung erforderlich, das Sie im Tutorial zur [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md) Vorgehensweise erstellt haben. Außerdem wird davon ausgegangen, dass Sie die anderen regelbezogenen Tutorials in diesem Abschnitt abgeschlossen haben.
+ 

**[AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html) Übersicht überprüft**  
Wenn Sie Lambda noch nicht verwendet AWS Lambda haben, lesen Sie [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)und [Erste Schritte mit Lambda, um sich mit](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) den Begriffen und Konzepten vertraut zu machen.

## Schritt 1: Erstellen Sie eine AWS Lambda Funktion, die eine Textnachricht sendet
<a name="iot-lambda-rule-create-lambda"></a>

Die AWS Lambda Funktion in diesem Tutorial empfängt das Ergebnis der Regelabfrageanweisung, fügt die Elemente in eine Textzeichenfolge ein und sendet die resultierende Zeichenfolge als Nachricht in einer Benachrichtigung an Amazon SNS.

Im Gegensatz zum Tutorial zur Vorgehensweise[Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md), in dem eine AWS IoT Regelaktion zum Senden der Benachrichtigung verwendet wurde, sendet dieses Tutorial die Benachrichtigung von der Lambda-Funktion mithilfe einer Funktion des AWS SDK. Das eigentliche Amazon SNS-Benachrichtigungsthema, das in diesem Tutorial verwendet wird, ist jedoch dasselbe, das Sie im Tutorial zum Thema wie man [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md) verwendet haben.

**Um eine AWS Lambda Funktion zu erstellen, die eine Textnachricht sendet**

1. Erstellen Sie eine neue AWS Lambda Funktion.

   1. Wählen Sie in der [AWS Lambda Konsole](https://console.aws.amazon.com//lambda/home) die Option **Create function (Funktion erstellen)** aus.

   1. Wählen Sie unter **Funktion erstellen** die Option **Blueprint verwenden** aus.

      Suchen Sie nach dem **hello-world-python** Blueprint, wählen Sie ihn aus und wählen Sie dann **Konfigurieren** aus.

   1. Unter **Grundlegende Informationen**:

      1. Geben Sie unter **Funktionsname** den Namen dieser Funktion ein, **format-high-temp-notification**. 

      1. Wählen Sie **unter Ausführungsrolle** die Option **Neue Rolle aus AWS Richtlinienvorlagen erstellen** aus.

      1. Geben Sie im Feld Rollenname den Namen der neuen Rolle ein, **format-high-temp-notification-role**.

      1. Suchen Sie unter **Richtlinienvorlagen — *optional*** nach der ** Amazon SNS-Veröffentlichungsrichtlinie** und wählen Sie diese aus.

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

1. Ändern Sie den Blueprint-Code, um eine Amazon SNS-Benachrichtigung zu formatieren und zu senden.

   1. Nachdem Sie Ihre Funktion erstellt haben, sollte die **format-high-temp-notification**Detailseite angezeigt werden. Wenn Sie dies nicht tun, öffnen Sie es auf der Seite [Lambda **Funktionen**](https://console.aws.amazon.com//lambda/home#/functions).

   1. Wählen Sie auf der **format-high-temp-notification**Detailseite die Registerkarte **Konfiguration** und scrollen Sie zum Bereich **Funktionscode**.

   1. Wählen Sie im Fenster **Funktionscode** im Bereich **Umgebung** die Python-Datei `lambda_function.py` aus.

   1. Löschen Sie im Fenster **Funktionscode** den gesamten ursprünglichen Programmcode aus dem Blueprint und ersetzen Sie ihn durch diesen Code.

      ```
      import boto3
      #
      #   expects event parameter to contain:
      #   {
      #       "device_id": "32",
      #       "reported_temperature": 38,
      #       "max_temperature": 30,
      #       "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
      #   }
      # 
      #   sends a plain text string to be used in a text message
      #
      #      "Device {0} reports a temperature of {1}, which exceeds the limit of {2}."
      #   
      #   where:
      #       {0} is the device_id value
      #       {1} is the reported_temperature value
      #       {2} is the max_temperature value
      #
      def lambda_handler(event, context):
      
          # Create an SNS client to send notification
          sns = boto3.client('sns')
      
          # Format text message from data
          message_text = "Device {0} reports a temperature of {1}, which exceeds the limit of {2}.".format(
                  str(event['device_id']),
                  str(event['reported_temperature']),
                  str(event['max_temperature'])
              )
      
          # Publish the formatted message
          response = sns.publish(
                  TopicArn = event['notify_topic_arn'],
                  Message = message_text
              )
      
          return response
      ```

   1. Wählen Sie **Bereitstellen**.

1. Suchen Sie in einem neuen Fenster den Amazon-Ressourcennamen (ARN) Ihres Amazon-SNS-Themas aus dem Tutorial zum Thema wie man [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md).

   1. Öffnen Sie in einem neuen Fenster die [Themenseite der Amazon SNS-Konsole](https://console.aws.amazon.com//sns/v3/home#/topics). 

   1. Suchen Sie auf der Seite **Themen** das Benachrichtigungsthema **high\$1temp\$1notice** in der Liste der Amazon SNS-Themen.

   1. Suchen Sie den **ARN** des Benachrichtigungsthemas **high\$1temp\$1notice**, das Sie im nächsten Schritt verwenden möchten.

1. Erstellen Sie einen Testfall für Ihre Lambda-Funktion.

   1. Wählen Sie auf der Seite [https://console.aws.amazon.com//lambda/home#/functions](https://console.aws.amazon.com//lambda/home#/functions) der Konsole auf der **format-high-temp-notification**Detailseite in der oberen rechten Ecke der Seite die Option **Testereignis auswählen** aus (auch wenn es deaktiviert aussieht) und wählen Sie dann **Testereignisse konfigurieren** aus.

   1. Wählen Sie unter **Testereignis konfigurieren** die Option **Neues Testereignis erstellen**.

   1. Geben Sie unter **Event name (Ereignisname)** **SampleRuleOutput** ein.

   1. Fügen Sie im JSON-Editor unter dem **Ereignisnamen** dieses JSON-Beispieldokument ein. Dies ist ein Beispiel dafür, was Ihre AWS IoT Regel an die Lambda-Funktion sendet.

      ```
      {
        "device_id": "32",
        "reported_temperature": 38,
        "max_temperature": 30,
        "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
      }
      ```

   1. Sehen Sie sich das Fenster an, das den **ARN** des Benachrichtigungsthemas **high\$1temp\$1notice** enthält, und kopieren Sie den ARN-Wert.

   1. Ersetzen Sie den `notify_topic_arn` Wert im JSON-Editor durch den ARN aus Ihrem Benachrichtigungsthema.

      Lassen Sie dieses Fenster geöffnet, damit Sie diesen ARN-Wert erneut verwenden können, wenn Sie die AWS IoT Regel erstellen.

   1. Wählen Sie **Erstellen** aus.

1. Testen Sie die Funktion mit Beispieldaten.

   1. **Vergewissern Sie sich, dass auf der **format-high-temp-notification**Detailseite in der oberen rechten Ecke der Seite neben der **SampleRuleOutput**Schaltfläche Testen angezeigt wird.** Wenn nicht, wählen Sie es aus der Liste der verfügbaren Testereignisse aus.

   1. Um die Ausgabenachricht der Beispielregel an Ihre Funktion zu senden, wählen Sie **Test**.

Wenn sowohl die Funktion als auch die Benachrichtigung funktioniert haben, erhalten Sie eine Textnachricht auf dem Telefon, das die Benachrichtigung abonniert hat.

Wenn Sie am Telefon keine Textnachricht erhalten haben, überprüfen Sie das Ergebnis des Vorgangs. Überprüfen Sie im Bereich **Funktionscode** auf der Registerkarte **Ausführungsergebnisse** die Antwort auf aufgetretene Fehler. Fahren Sie erst mit dem nächsten Schritt fort, wenn Ihre Funktion die Benachrichtigung an Ihr Telefon senden kann.

## Schritt 2: Erstellen Sie eine AWS IoT Regel mit einer AWS Lambda Regelaktion
<a name="iot-lambda-rule-create-rule"></a>

In diesem Schritt verwenden Sie die Regelabfrageanweisung, um die Daten vom imaginären Wettersensorgerät zu formatieren, um sie an eine Lambda-Funktion zu senden, die eine Textnachricht formatiert und sendet.

Ein Beispiel für eine von den Wettergeräten empfangene Nachrichtennutzlast sieht wie folgt aus:

```
{
  "temperature": 28,
  "humidity": 80,
  "barometer": 1013,
  "wind": {
    "velocity": 22,
    "bearing": 255
  }
}
```

In dieser Regel verwenden Sie die Regelabfrageanweisung, um eine Nachrichtennutzlast für die Lambda-Funktion zu erstellen, die wie folgt aussieht:

```
{
  "device_id": "32",
  "reported_temperature": 38,
  "max_temperature": 30,
  "notify_topic_arn": "arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice"
}
```

Dies enthält alle Informationen, die die Lambda-Funktion benötigt, um die richtige Textnachricht zu formatieren und zu senden.

**Um die AWS IoT Regel zum Aufrufen einer Lambda-Funktion zu erstellen**

1. Öffnen Sie den [**Regel-Hub** der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/rulehub).

1. Um mit der Erstellung Ihrer neuen Regel unter **Regeln** zu beginnen, wählen Sie **Erstellen**.

1. Gehen Sie im oberen Teil von **Regel erstellen** wie folgt vor:

   1. Geben Sie im Feld **Name** den Namen der Regel ein, **wx\$1friendly\$1text**.

      Denken Sie daran, dass ein Regelname in Ihrer Region AWS-Konto und in Ihrer Region eindeutig sein muss und keine Leerzeichen enthalten darf. Wir haben in diesem Namen einen Unterstrich verwendet, um die beiden Wörter im Namen der Regel voneinander zu trennen.

   1.  Beschreiben Sie die Regel im Feld **Beschreibung**. 

      Eine aussagekräftige Beschreibung macht es einfacher, sich daran zu erinnern, was diese Regel bewirkt und warum Sie sie erstellt haben. Die Beschreibung kann so lang wie nötig sein, also seien Sie so detailliert wie möglich. 

1. In der **Regelabfrageanweisung** von **Regel erstellen**:

   1.  Wählen Sie unter **SQL-Version verwenden** die Option **2016-03-23** aus. 

   1. Geben Sie im Bearbeitungsfeld **Regelabfrageanweisung** die folgende Anweisung ein: 

      ```
      SELECT 
        cast(topic(2) AS DECIMAL) as device_id, 
        temperature as reported_temperature,
        30 as max_temperature,
        'arn:aws:sns:us-east-1:57EXAMPLE833:high_temp_notice' as notify_topic_arn
      FROM 'device/+/data' WHERE temperature > 30
      ```

      Diese Aussage:
      + Lauscht auf MQTT-Nachrichten mit einem Thema, das dem `device/+/data` Themenfilter entspricht und deren `temperature` Wert größer als 30 ist. 
      + Wählt das zweite Element aus der Themenzeichenfolge aus, konvertiert es in eine Dezimalzahl und weist es dann dem `device_id` Feld zu.
      + Wählt den Wert des `temperature` Felds aus der Nachrichtennutzlast aus und weist ihn dem `reported_temperature` Feld zu. 
      + Erstellt einen konstanten Wert, `30`, um den Grenzwert darzustellen, und weist ihn dem `max_temperature` Feld zu. 
      + Erstellt einen konstanten Wert für das `notify_topic_arn` Feld.

   1. Sehen Sie sich das Fenster an, das den **ARN** des Benachrichtigungsthemas **high\$1temp\$1notice** enthält, und kopieren Sie den ARN-Wert.

   1. Ersetzen Sie den ARN-Wert (*arn:aws:sns:us-east-1:57EXAMPLE833:high\$1temp\$1notice*) im Editor für Regelabfrageanweisungen durch den ARN Ihres Benachrichtigungsthemas.

1. Gehen Sie im Feld **Eine oder mehrere Aktionen festlegen** wie folgt vor:

   1. Um die Liste der Regelaktionen für diese Regel zu öffnen, wählen Sie **Aktion hinzufügen**.

   1. Wählen Sie unter **Aktion auswählen** die Option **Nachricht an eine Lambda-Funktion senden** aus.

   1. Um die Konfigurationsseite der ausgewählten Aktion zu öffnen, wählen Sie unten in der Aktionsliste die Option **Aktion konfigurieren** aus.

1. Gehen Sie in **Aktion konfigurieren** wie folgt vor:

   1. Wählen Sie unter **Funktionsname** die Option **Auswählen** aus.

   1. Wählen Sie **format-high-temp-notification**.

   1. Wählen Sie unten im Bereich **Aktion konfigurieren** die Option **Aktion hinzufügen** aus.

   1. Um die Regel zu erstellen, wählen Sie unten im Bereich **Eine Regel erstellen** die Option **Regel erstellen** aus.

## Schritt 3: Testen Sie die AWS IoT Regel und die AWS Lambda Regelaktion
<a name="iot-lambda-rule-test-rule"></a>

Um Ihre neue Regel zu testen, verwenden Sie den MQTT-Client, um die von dieser Regel verwendeten MQTT-Nachrichten zu veröffentlichen und zu abonnieren.

Öffnen Sie den [MQTT-Client in der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/test) in einem neuen Fenster. Jetzt können Sie die Regel bearbeiten, ohne die Konfiguration Ihres MQTT-Clients zu verlieren. Wenn Sie den MQTT-Client verlassen, um zu einer anderen Seite in der Konsole zu wechseln, verlieren Sie Ihre Abonnements oder Nachrichtenprotokolle.

**Um den MQTT-Client zum Testen Ihrer Regel verwenden.**

1. Abonnieren Sie im [MQTT-Client in der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/test) die Eingabethemen, in diesem Fall `device/+/data`.

   1. Wählen Sie im MQTT-Client unter **Abonnements** die Option **Thema abonnieren** aus.

   1. Geben Sie im **Abonnementthema** das Thema des Eingabethemenfilters **device/\$1/data** ein.

   1. Belassen Sie die übrigen Felder auf ihren Standardeinstellungen.

   1. Wählen Sie **Thema abonnieren** aus.

      In der Spalte **Abonnements** wird **device/\$1/data** unter **In einem Thema veröffentlichen** angezeigt. 

1. Veröffentlichen Sie eine Nachricht zum Eingabethema mit einer bestimmten Geräte-ID, **device/32/data**. Sie können keine Beiträge in MQTT-Themen veröffentlichen, die Platzhalterzeichen enthalten.

   1. Wählen Sie im MQTT-Client unter **Abonnements** die Option **In einem Thema veröffentlichen**.

   1. Geben Sie im Feld **Veröffentlichen** den Namen des Eingabethemas **device/32/data** ein.

   1. Kopieren Sie die hier gezeigten Beispieldaten und fügen Sie die Beispieldaten in das Bearbeitungsfeld unter dem Themennamen ein.

      ```
      {
        "temperature": 38,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Wählen Sie **In Thema veröffentlichen** aus, um Ihre MQTT-Nachricht in zu veröffentlichen.

1. Bestätigen Sie, dass die Textnachricht gesendet wurde.

   1. Im MQTT-Client befindet sich unter **Abonnements** ein grüner Punkt neben dem Thema, das Sie zuvor abonniert haben.

      Der grüne Punkt zeigt an, dass eine oder mehrere neue Nachrichten eingegangen sind, seit Sie sie das letzte Mal angesehen haben.

   1. Wählen Sie unter **Abonnements** die Option **Gerät/\$1/Daten** aus, um zu überprüfen, ob die Nutzlast der Nachricht mit dem übereinstimmt, was Sie gerade veröffentlicht haben, und wie folgt aussieht:

      ```
      {
        "temperature": 38,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Überprüfen Sie das Telefon, mit dem Sie das SNS-Thema abonniert haben, und vergewissern Sie sich, dass der Inhalt der Nutzlast der Nachricht so aussieht:

      ```
      Device 32 reports a temperature of 38, which exceeds the limit of 30.
      ```

      Wenn Sie das Thema-ID-Element im Nachrichtenthema ändern, denken Sie daran, dass die Umwandlung des `topic(2)` Werts in einen numerischen Wert nur funktioniert, wenn dieses Element im Nachrichtenthema nur numerische Zeichen enthält.

1. Versuchen Sie, eine MQTT-Nachricht zu senden, in der die Temperatur den Grenzwert nicht überschreitet.

   1. Wählen Sie im MQTT-Client unter **Abonnements** die Option **In einem Thema veröffentlichen**.

   1. Geben Sie im Feld **Veröffentlichen** den Namen des Eingabethemas **device/33/data** ein.

   1. Kopieren Sie die hier gezeigten Beispieldaten und fügen Sie die Beispieldaten in das Bearbeitungsfeld unter dem Themennamen ein.

      ```
      {
        "temperature": 28,
        "humidity": 80,
        "barometer": 1013,
        "wind": {
          "velocity": 22,
          "bearing": 255
        }
      }
      ```

   1. Um Ihre MQTT-Nachricht zu senden, wählen Sie **Im Thema veröffentlichen**.

   Sie sollten die Nachricht sehen, die Sie im **device/\$1/data** Abonnement gesendet haben. Da der Temperaturwert jedoch unter der Höchsttemperatur in der Regelabfrageanweisung liegt, sollten Sie keine Textnachricht erhalten.

   Wenn Sie nicht das richtige Verhalten feststellen, lesen Sie die Tipps zur Fehlerbehebung.

### Problembehandlung bei Ihrer AWS Lambda Regel und Benachrichtigung
<a name="iot-lambda-rule-troubleshoot"></a>

Hier sind einige Dinge, die Sie überprüfen sollten, falls Sie nicht die erwarteten Ergebnisse sehen.
+ 

**Sie haben ein Fehlerbanner**  
Wenn bei der Veröffentlichung der Eingabemeldung ein Fehler aufgetreten ist, korrigieren Sie diesen Fehler zuerst. Die folgenden Schritte können Ihnen helfen, diesen Fehler zu korrigieren.
+ 

**Sie sehen die Eingabenachricht nicht im MQTT-Client**  
Jedes Mal, wenn Sie Ihre Eingabenachricht zum `device/32/data` Thema veröffentlichen, sollte diese Nachricht im MQTT-Client erscheinen, wenn Sie den `device/+/data` Themenfilter wie im Verfahren beschrieben abonniert haben.

**Zu überprüfende Dinge**
  + 

**Überprüfen Sie den Themenfilter, den Sie abonniert haben**  
Wenn Sie das Thema der Eingabenachricht wie im Verfahren beschrieben abonniert haben, sollte Ihnen bei jeder Veröffentlichung eine Kopie der Eingabenachricht angezeigt werden.

    Wenn Sie die Nachricht nicht sehen, überprüfen Sie den Themennamen, den Sie abonniert haben, und vergleichen Sie ihn mit dem Thema, zu dem Sie sie veröffentlicht haben. Bei Themennamen wird Groß- und Kleinschreibung beachtet, und das Thema, das Sie abonniert haben, muss mit dem Thema identisch sein, zu dem Sie die Nachrichtennutzlast veröffentlicht haben.
  + 

**Überprüfen Sie die Funktion zum Veröffentlichen von Nachrichten**  
Wählen Sie im MQTT-Client unter **Abonnements** die Option **Gerät/\$1/Daten** aus, überprüfen Sie das Thema der Veröffentlichungsnachricht und wählen Sie dann **Im Thema veröffentlichen** aus. Sie sollten sehen, dass die Nutzlast der Nachricht aus dem Bearbeitungsfeld unter dem Thema in der Nachrichtenliste erscheinen. 
+ 

**Sie erhalten keine SMS-Nachricht**  
Damit Ihre Regel funktioniert, muss sie über die richtige Richtlinie verfügen, die sie autorisiert, eine Nachricht zu empfangen und eine SNS-Benachrichtigung zu senden, und sie muss die Nachricht empfangen.

**Zu überprüfende Dinge**
  + 

**Überprüfen Sie Ihren MQTT-Client und die Regel, die Sie erstellt haben AWS-Region**  
Die Konsole, in der Sie den MQTT-Client ausführen, muss sich in derselben AWS Region befinden wie die von Ihnen erstellte Regel.
  + 

**Überprüfen Sie, ob der Temperaturwert in der Nachrichtennutzlast den Testschwellenwert überschreitet**  
Wenn der Temperaturwert kleiner oder gleich 30 ist, wie in der Regelabfrageanweisung definiert, führt die Regel keine ihrer Aktionen aus.
  + 

**Überprüfen Sie das Thema der Eingabemeldung in der Regelabfrageanweisung**  
Damit die Regel funktioniert, muss sie eine Nachricht mit dem Themennamen erhalten, der dem Themenfilter in der FROM-Klausel der Regelabfrageanweisung entspricht.

    Überprüfen Sie die Schreibweise des Themenfilters in der Regelabfrageanweisung mit der des Themas im MQTT-Client. Bei Themennamen wird Groß- und Kleinschreibung beachtet, und das Thema der Nachricht muss mit dem Themenfilter in der Regelabfrageanweisung übereinstimmen.
  + 

**Überprüfen Sie den Inhalt der Nutzlast der Input-Nachricht**  
Damit die Regel funktioniert, muss sie das Datenfeld in der Nachrichtennutzlast finden, das in der SELECT-Anweisung deklariert ist.

    Überprüfen Sie die Schreibweise des `temperature` Felds in der Regelabfrageanweisung mit der Schreibweise der Nachrichtennutzlast im MQTT-Client. Bei Feldnamen wird zwischen Groß- und Kleinschreibung unterschieden, und das `temperature` Feld in der Regelabfrageanweisung muss mit dem `temperature` Feld in der Nachrichtennutzlast identisch sein.

    Stellen Sie sicher, dass das JSON-Dokument in der Nachrichtennutzlast korrekt formatiert ist. Wenn das JSON Fehler enthält, z. B. ein fehlendes Komma, kann die Regel es nicht lesen.
  + 

**Überprüfen Sie die Amazon-SNS-Benachrichtigung**  
Unter [Schritt 1: Erstellen Sie ein Amazon SNS SNS-Thema, das eine SMS-Textnachricht sendet](iot-sns-rule.md#iot-sns-rule-create-sns-topic), lesen Sie Schritt 3, in dem beschrieben wird, wie Sie die Amazon SNS-Benachrichtigung testen und die Benachrichtigung testen, um sicherzustellen, dass die Benachrichtigung funktioniert.
  + 

**Überprüfen Sie die Lambda-Funktion**  
Unter [Schritt 1: Erstellen Sie eine AWS Lambda Funktion, die eine Textnachricht sendet](#iot-lambda-rule-create-lambda), lesen Sie Schritt 5, in dem beschrieben wird, wie Sie die Lambda-Funktion anhand von Testdaten testen und die Lambda-Funktion testen.
  + 

**Überprüfen Sie die Rolle, die von der Regel verwendet wird**  
Die Regelaktion muss berechtigt sein, das ursprüngliche Thema zu empfangen und das neue Thema zu veröffentlichen. 

    Die Richtlinien, mit denen die Regel autorisiert wird, Nachrichtendaten zu empfangen und erneut zu veröffentlichen, sind spezifisch für die verwendeten Themen. Wenn Sie das Thema ändern, das für die erneute Veröffentlichung der Nachrichtendaten verwendet wird, müssen Sie die Rolle der Regelaktion aktualisieren, damit ihre Richtlinie dem aktuellen Thema entspricht.

    Wenn Sie vermuten, dass dies das Problem ist, bearbeiten Sie die Aktion Regel erneut veröffentlichen und erstellen Sie eine neue Rolle. Neue Rollen, die durch die Regelaktion erstellt wurden, erhalten die erforderlichen Autorisierungen, um diese Aktionen auszuführen.

## Schritt 4: Überprüfen Sie die Ergebnisse und die nächsten Schritte
<a name="iot-lambda-rule-next-steps"></a>

**In diesem Tutorial:**
+ Sie haben eine AWS IoT Regel zum Aufrufen einer Lambda-Funktion erstellt, die eine Amazon SNS SNS-Benachrichtigung gesendet hat, die Ihre benutzerdefinierte Nachrichtennutzlast verwendet hat.
+ Sie haben eine einfache SQL-Abfrage und Funktionen in einer Regelabfrageanweisung verwendet, um eine neue Nachrichtennutzlast für Ihre Lambda-Funktion zu erstellen.
+ Sie haben den MQTT-Client verwendet, um Ihre Regel zu testen. AWS IoT 

**Nächste Schritte**  
Nachdem Sie einige Textnachrichten mit dieser Regel gesendet haben, versuchen Sie, damit zu experimentieren, um zu sehen, wie sich Änderungen einiger Aspekte des Tutorials auf die Nachricht auswirken und wann sie gesendet wird. Hier sind einige Ideen, die Ihnen den Einstieg erleichtern sollen.
+ Ändern Sie das Thema *device\$1id* der Eingangsnachricht und beobachten Sie die Auswirkungen auf den Inhalt der Textnachricht.
+ Ändern Sie die in der Regelabfrageanweisung ausgewählten Felder, aktualisieren Sie die Lambda-Funktion, um sie in einer neuen Nachricht zu verwenden, und beobachten Sie die Auswirkungen im Inhalt der Textnachricht.
+ Ändern Sie den Test in der Regelabfrageanweisung so, dass er auf eine Mindesttemperatur statt auf eine Höchsttemperatur testet. Aktualisieren Sie die Lambda-Funktion, um eine neue Nachricht zu formatieren, und denken Sie daran, den Namen von `max_temperature` zu ändern.
+ Weitere Informationen zum Auffinden von Fehlern, die bei der Entwicklung und Verwendung von AWS IoT Regeln auftreten können, finden Sie unter[Überwachung AWS IoT](monitoring_overview.md).