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.
# Mit dem AWS IoT Gerät Lösungen entwickeln SDKs
Die Tutorials in diesem Abschnitt führen Sie durch die Schritte zur Entwicklung einer IoT-Lösung, die mithilfe von in einer Produktionsumgebung eingesetzt werden kann AWS IoT.
Diese Tutorials können mehr Zeit in Anspruch nehmen als die Anleitungen im Abschnitt über, [Demos mit dem AWS IoT Device Client erstellen](iot-tutorials-dc-intro.md) da sie das AWS IoT Gerät verwenden SDKs und die angewandten Konzepte ausführlicher erläutern, um Ihnen bei der Entwicklung sicherer und zuverlässiger Lösungen zu helfen.
## Fangen Sie an, Lösungen mit dem AWS IoT Gerät zu entwickeln SDKs
Diese Tutorials führen Sie durch verschiedene AWS IoT Szenarien. Gegebenenfalls verwenden die Tutorials das AWS IoT Gerät SDKs.
**Topics**
+ [Fangen Sie an, Lösungen mit dem AWS IoT Gerät zu entwickeln SDKs](#iot-sdk-tutorial-overview)
+ [Tutorial: Ein Gerät AWS IoT Core mithilfe des AWS IoT Geräte-SDK verbinden](sdk-tutorials.md)
+ [AWS IoT Regeln erstellen, um Gerätedaten an andere Dienste weiterzuleiten](iot-rules-tutorial.md)
+ [Beibehalten des Gerätestatus mit Geräteschatten, während das Gerät offline ist](iot-shadows-tutorial.md)
+ [Tutorial: Erstellen eines benutzerdefinierten Autorisierers für AWS IoT Core](custom-auth-tutorial.md)
+ [Tutorial: Überwachung der Bodenfeuchte mit einem AWS IoT Raspberry Pi](iot-moisture-tutorial.md)
# Tutorial: Ein Gerät AWS IoT Core mithilfe des AWS IoT Geräte-SDK verbinden
In diesem Tutorial wird gezeigt, wie Sie ein Gerät anschließen, AWS IoT Core damit es Daten an und von dort senden und empfangen kann AWS IoT. Nachdem Sie dieses Tutorial abgeschlossen haben, wird Ihr Gerät so konfiguriert, dass es eine Verbindung herstellt, AWS IoT Core und Sie werden verstehen, wie Geräte miteinander kommunizieren AWS IoT.
**Topics**
+ [Voraussetzungen](#sdk-tutorials-prereq)
+ [Bereiten Sie Ihr Gerät vor für AWS IoT](#sdk-tutorials-prepare)
+ [Ansehen des MQTT-Protokolls](#sdk-tutorials-mqtt-review)
+ [Ansehen der Beispiel-App „pubsub.py“ des Device SDK](#sdk-tutorials-explore-sample)
+ [Connect dein Gerät und kommuniziere mit AWS IoT Core](#sdk-tutorials-experiment)
+ [Überprüfen Sie die Ergebnisse.](#sdk-tutorials-conclusion)
+ [Tutorial: Verwenden des AWS IoT Device SDK for Embedded C](iot-embedded-c-sdk.md)
## Voraussetzungen
Stellen Sie vor Beginn dieses Tutorials sicher, dass Sie über Folgendes verfügen:
+
**[Erste Schritte mit AWS IoT Core Tutorials](iot-gs.md) abgeschlossen haben.**
Wählen Sie im Abschnitt des besagten Tutorials, in dem Sie [Konfigurieren Ihres Geräts](configure-device.md) müssen, die Option [Verbinden eines Raspberry Pi oder eines anderes Gerätes](connecting-to-existing-device.md) für Ihr Gerät und verwenden Sie die Python-Sprachoptionen, um Ihr Gerät zu konfigurieren.
**Anmerkung**
Lassen Sie das im besagten Tutorial verwendete Terminalfenster geöffnet, da Sie es auch in diesem Tutorial verwenden.
+
**Ein Gerät, auf dem das AWS IoT Device SDK v2 für Python ausgeführt werden kann.**
Dieses Tutorial zeigt anhand AWS IoT Core von Python-Codebeispielen, für die ein relativ leistungsfähiges Gerät erforderlich ist, eine Verbindung zu einem Gerät herstellen. Wenn Sie mit ressourcenbeschränkten Geräten arbeiten, funktionieren diese Codebeispiele möglicherweise nicht. In diesem Fall haben Sie möglicherweise mehr Erfolg mit dem [Tutorial: Verwenden des AWS IoT Device SDK for Embedded C](iot-embedded-c-sdk.md) Tutorial.
+
**Sie haben die erforderlichen Informationen erhalten, um eine Verbindung mit dem Gerät herzustellen**
Um Ihr Gerät zu verbinden AWS IoT, benötigen Sie Informationen zum Namen des Objekts, zum Hostnamen und zur Portnummer.
**Anmerkung**
Sie können auch eine benutzerdefinierte Authentifizierung verwenden, um Geräte mit zu verbinden AWS IoT Core. Die Verbindungsdaten, die Sie an Ihre Autorisierungs-Lambda-Funktion übergeben, hängen vom verwendeten Protokoll ab.
+ **Name der Sache**: Der Name der AWS IoT Sache, zu der Sie eine Verbindung herstellen möchten. Sie müssen sich als Ihr Gerät als AWS IoT Ding registriert haben. Weitere Informationen finden Sie unter [Geräte verwalten mit AWS IoT](iot-thing-management.md).
+ **Hostname**: Der Hostname für den kontospezifischen IoT-Endpunkt.
+ **Portnummer**: Die Portnummer, zu der eine Verbindung hergestellt werden soll.
Sie können die `configureEndpoint` Methode im AWS IoT Python-SDK verwenden, um den Hostnamen und die Portnummer zu konfigurieren.
```
myAWSIoTMQTTClient.configureEndpoint("random.iot.region.amazonaws.com", 8883)
```
## Bereiten Sie Ihr Gerät vor für AWS IoT
In [Erste Schritte mit AWS IoT Core Tutorials](iot-gs.md) haben Sie Ihr Gerät und Ihr AWS -Konto vorbereitet, sodass sie kommunizieren können. In diesem Abschnitt werden die Aspekte dieser Vorbereitung beschrieben, die für jede Geräteverbindung mit gelten AWS IoT Core.
Damit ein Gerät sich mit AWS IoT Core verbinden kann:
1. Benötigen Sie ein **AWS-Konto**.
Das Verfahren unter [Einrichten AWS-Konto](setting-up.md) beschreibt, wie Sie eine erstellen, AWS-Konto falls Sie noch keine haben.
1. In diesem Konto müssen Sie die folgenden **AWS IoT Ressourcen** für das Gerät in Ihrer Region AWS-Konto und Ihrer Region definiert haben.
Das Verfahren unter [AWS IoT Ressourcen erstellen](create-iot-resources.md) beschreibt, wie Sie diese Ressourcen für das Gerät in Ihrem AWS-Konto und Ihrer Region erstellen.
+ Ein **Gerätezertifikat**, das bei AWS IoT registriert und zur Authentifizierung des Geräts aktiviert wurde.
Das Zertifikat wird häufig mit einem **AWS IoT -Objekt** erstellt und an dieses angehängt. Ein Dingobjekt ist zwar nicht erforderlich, damit ein Gerät eine Verbindung herstellen kann AWS IoT, es stellt dem Gerät jedoch zusätzliche AWS IoT Funktionen zur Verfügung.
+ Eine dem Gerätezertifikat beigefügte **Richtlinie**, die es autorisiert, eine Verbindung herzustellen AWS IoT Core und alle gewünschten Aktionen auszuführen.
1. Eine **Internetverbindung**, die auf die Endpunkte des Geräts Ihres AWS-Konto s zugreifen kann.
Die Geräteendpunkte werden unter beschrieben [AWS IoT Gerätedaten und Dienstendpunkte](iot-connect-devices.md#iot-connect-device-endpoints) und können auf der [Einstellungsseite der AWS IoT](https://console.aws.amazon.com/iot/home#/settings) Konsole eingesehen werden.
1. **Kommunikationssoftware**, wie sie vom AWS IoT Gerät SDKs bereitgestellt wird. In diesem Tutorial wird das [AWS IoT Device SDK v2 für Python](https://github.com/aws/aws-iot-device-sdk-python-v2#aws-iot-device-sdk-v2-for-python) verwendet.
## Ansehen des MQTT-Protokolls
Bevor wir über die Beispiel-App sprechen, ist ein Verständnis des MQTT-Protokolls hilfreich. Das MQTT-Protokoll bietet einige Vorteile gegenüber anderen Netzwerk-Kommunikationsprotokollen wie HTTP, was es zu einer beliebten Wahl für IoT-Geräte macht. In diesem Abschnitt werden die wichtigsten Aspekte von MQTT beschrieben, die für dieses Tutorial gelten. Weitere Informationen über den Vergleich zwischen MQTT und HTTP finden Sie unter [Wählen Sie ein Anwendungsprotokoll für Ihre Gerätekommunikation](protocols.md#protocol-selection).
**MQTT verwendet ein publish/subscribe Kommunikationsmodell**
Das MQTT-Protokoll verwendet ein publish/subscribe Kommunikationsmodell mit seinem Host. Dieses Modell unterscheidet sich von dem request/response Modell, das HTTP verwendet. Bei MQTT richten Geräte beim Host eine Sitzung ein, die durch eine eindeutige Client-ID identifiziert ist. Zum Senden von Daten veröffentlichen die Geräte durch Themen identifizierte Nachrichten an einen Message Broker auf dem Host. Zum Empfangen von Nachrichten vom Message Broker abonnieren Geräte Themen, indem sie Themenfilter in Subscriber-Anfragen an den Message Broker senden.
**MQTT unterstützt persistente Sitzungen**
Der Message Broker empfängt Nachrichten von Geräten und veröffentlicht Nachrichten an Geräte, die diese abonniert haben. Mit [persistenten Sitzungen](mqtt.md#mqtt-persistent-sessions) – Sitzungen, die auch dann aktiv bleiben, wenn das initiierende Gerät getrennt ist – können Geräte Nachrichten abrufen, die während der Unterbrechung der Verbindung veröffentlicht wurden. Auf der Geräteseite unterstützt MQTT Quality-of-Service-Levels ([QoS](mqtt.md#mqtt-qos)), die sicherstellen, dass der Host vom Gerät gesendete Nachrichten empfängt.
## Ansehen der Beispiel-App „pubsub.py“ des Device SDK
In diesem Abschnitt wird die Beispiel-App `pubsub.py` aus dem **AWS IoT Device SDK v2 für Python** beschrieben, die in diesem Tutorial verwendet wird. Hier werden wir uns ansehen, wie es eine Verbindung AWS IoT Core zum Veröffentlichen und Abonnieren von MQTT-Nachrichten herstellt. Im nächsten Abschnitt finden Sie einige Übungen, anhand derer Sie herausfinden können, wie ein Gerät eine Verbindung herstellt und mit ihm kommuniziert. AWS IoT Core
**Die `pubsub.py` Beispiel-App demonstriert diese Aspekte einer MQTT-Verbindung mit: AWS IoT Core**
+ [Kommunikationsprotokolle](#sdk-tutorials-explore-protocols)
+ [Persistente Sitzungen](#sdk-tutorials-explore-persistent)
+ [Quality of Service (Servicequalität)](#sdk-tutorials-explore-qos)
+ [Nachrichten veröffentlichen](#sdk-tutorials-explore-publish)
+ [Nachrichten abonnieren](#sdk-tutorials-explore-subscribe)
+ [Trennen und erneutes Anschließen des Geräts](#sdk-tutorials-explore-connect)
### Kommunikationsprotokolle
Das `pubsub.py`-Beispiel zeigt eine MQTT-Verbindung mit den Protokollen MQTT und MQTT über WSS. Die [AWS Common Runtime (AWS CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) -Bibliothek bietet Unterstützung für Low-Level-Kommunikationsprotokolle und ist im AWS IoT Device SDK v2 für Python enthalten.
#### MQTT
Das `pubsub.py` Beispiel ruft `mtls_from_path` (hier gezeigt) auf, [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py)um AWS IoT Core mithilfe des MQTT-Protokolls eine Verbindung herzustellen. `mtls_from_path`verwendet X.509-Zertifikate und TLS v1.2 zur Authentifizierung des Geräts. Die AWS CRT-Bibliothek verarbeitet die untergeordneten Details dieser Verbindung.
```
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
`endpoint`
Ihr AWS-Konto IoT-Geräte-Endpunkt
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`cert_filepath`
Der Pfad zur Zertifikatsdatei des Geräts
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`pri_key_filepath`
Der Pfad zur privaten Schlüsseldatei des Geräts, die mit der zugehörigen Zertifikatsdatei erstellt wurde
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`ca_filepath`
Der Pfad zur Root-CA-Datei Nur erforderlich, wenn der MQTT-Server ein Zertifikat verwendet, das sich noch nicht in Ihrem Trust Store befindet.
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`client_bootstrap`
Das Common-Runtime-Objekt, das Socket-Kommunikationsaktivitäten verarbeitet
In der Beispiel-App wird dieses Objekt vor dem Aufruf zum `mqtt_connection_builder.mtls_from_path` instanziiert.
`on_connection_interrupted``on_connection_resumed`
Die Callback-Funktionen, die aufgerufen werden, wenn die Verbindung des Geräts unterbrochen und wieder aufgenommen wird
`client_id`
Die ID, die dieses Gerät eindeutig in der AWS-Region identifiziert
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`clean_session`
Wahl der Option, eine neue persistente Sitzung zu starten oder, falls vorhanden, eine Verbindung zu einer bestehenden Sitzung wiederherzustellen
`keep_alive_secs`
Der Keep-Alive-Wert in Sekunden, der in der `CONNECT`-Anfrage gesendet werden soll. In diesem Intervall wird automatisch ein Ping gesendet. Wenn der Server nach dem 1,5-fachen dieses Werts keinen Ping empfängt, wird davon ausgegangen, dass die Verbindung unterbrochen wurde.
#### MQTT über WSS
Das `pubsub.py`-Beispiel ruft `websockets_with_default_aws_signing` (hier gezeigt) in [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) auf, zur Herstellung einer Verbindung mit AWS IoT Core mithilfe des MQTT-Protokolls über WSS. `websockets_with_default_aws_signing` erstellt mithilfe von [Signature V4](https://docs.aws.amazon.com/general/latest/gr/signature-version-4.html) eine MQTT-Verbindung über WSS zur Authentifizierung des Geräts her.
```
mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
endpoint=args.endpoint,
client_bootstrap=client_bootstrap,
region=args.signing_region,
credentials_provider=credentials_provider,
websocket_proxy_options=proxy_options,
ca_filepath=args.ca_file,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
`endpoint`
Ihr AWS-Konto IoT-Geräte-Endpunkt
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`client_bootstrap`
Das Common-Runtime-Objekt, das Socket-Kommunikationsaktivitäten verarbeitet
In der Beispiel-App wird dieses Objekt vor dem Aufruf zum `mqtt_connection_builder.websockets_with_default_aws_signing` instanziiert.
`region`
Die AWS Signaturregion, die von der Signature V4-Authentifizierung verwendet wird. In `pubsub.py` übergibt sie den in der Befehlszeile eingegebenen Parameter.
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`credentials_provider`
Die zur Authentifizierung bereitgestellten AWS Anmeldeinformationen
In der Beispiel-App wird dieses Objekt vor dem Aufruf zu `mqtt_connection_builder.websockets_with_default_aws_signing` instanziiert.
`websocket_proxy_options`
HTTP-Proxyoptionen, wenn Sie einen Proxyhost verwenden
In der Beispiel-App wird dieser Wert vor dem Aufruf zu `mqtt_connection_builder.websockets_with_default_aws_signing` initialisiert.
`ca_filepath`
Der Pfad zur Root-CA-Datei Nur erforderlich, wenn der MQTT-Server ein Zertifikat verwendet, das sich noch nicht in Ihrem Trust Store befindet.
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`on_connection_interrupted``on_connection_resumed`
Die Callback-Funktionen, die aufgerufen werden, wenn die Verbindung des Geräts unterbrochen und wieder aufgenommen wird
`client_id`
Die ID, die dieses Gerät eindeutig in der AWS-Region identifiziert.
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`clean_session`
Wahl der Option, eine neue persistente Sitzung zu starten oder, falls vorhanden, eine Verbindung zu einer bestehenden Sitzung wiederherzustellen
`keep_alive_secs`
Der Keep-Alive-Wert in Sekunden, der in der `CONNECT`-Anfrage gesendet werden soll. In diesem Intervall wird automatisch ein Ping gesendet. Wenn der Server nach dem 1,5-fachen dieses Werts keinen Ping empfängt, wird davon ausgegangen, dass die Verbindung unterbrochen wurde.
#### HTTPS
Was ist mit HTTPS? AWS IoT Core unterstützt Geräte, die HTTPS-Anfragen veröffentlichen. Aus Sicht der Programmierung senden Geräte HTTPS-Anfragen an AWS IoT Core , so wie jede andere Anwendung es tun würde. Ein Beispiel für ein Python-Programm, das eine HTTP-Nachricht von einem Gerät sendet, finden Sie im [HTTPS-Codebeispiel](http.md#codeexample) mit der `requests` Python-Bibliothek. In diesem Beispiel wird eine Nachricht AWS IoT Core über HTTPS an gesendet, sodass sie als MQTT-Nachricht AWS IoT Core interpretiert wird.
AWS IoT Core Unterstützt zwar HTTPS-Anfragen von Geräten, aber überprüfen Sie unbedingt die Informationen darüber, [Wählen Sie ein Anwendungsprotokoll für Ihre Gerätekommunikation](protocols.md#protocol-selection) damit Sie eine fundierte Entscheidung darüber treffen können, welches Protokoll Sie für Ihre Gerätekommunikation verwenden möchten.
### Persistente Sitzungen
In der Beispiel-App bedeutet die Einstellung des `clean_session`-Parameters auf `False`, dass die Verbindung dauerhaft sein soll. In der Praxis bedeutet dies, dass die durch diesen Aufruf geöffnete Verbindung erneut eine Verbindung zu einer bestehenden persistenten Sitzung herstellt, sofern eine besteht. Andernfalls wird eine neue persistente Sitzung erstellt und eine Verbindung zu ihr hergestellt.
Bei einer persistenten Sitzung werden Nachrichten, die an das Gerät gesendet werden, vom Message Broker gespeichert, solange das Gerät nicht verbunden ist. Wenn ein Gerät die Verbindung zu einer persistenten Sitzung wieder aufnimmt, sendet der Message Broker alle von dem Gerät abonnierten gespeicherten Nachrichten an das Gerät.
Ohne eine persistente Sitzung empfängt das Gerät keine Nachrichten, die gesendet werden, während das Gerät nicht verbunden ist. Welche Option Sie verwenden, hängt von Ihrer App ab und davon, ob Nachrichten, die auftreten, während ein Gerät nicht angeschlossen ist, übermittelt werden müssen. Weitere Informationen finden Sie unter [Persistente MQTT-Sitzungen](mqtt.md#mqtt-persistent-sessions).
### Quality of Service (Servicequalität)
Wenn das Gerät Nachrichten veröffentlicht und abonniert, kann die bevorzugte Dienstqualität (QoS) festgelegt werden. AWS IoT unterstützt die QoS-Stufen 0 und 1 für Veröffentlichungs- und Abonnementvorgänge. Weitere Informationen zu QoS-Stufen finden Sie AWS IoT unter[MQTT QoS-(Quality of Service)-Optionen](mqtt.md#mqtt-qos).
Die AWS CRT-Laufzeit für Python definiert diese Konstanten für die QoS-Stufen, die sie unterstützt:
**Servicequalitätsstufen von Python**
| QoS-Stufe von MQTT | Vom SDK verwendeter symbolischer Python-Wert | Description |
| --- | --- | --- |
| QoS Stufe 0 | mqtt.QoS.AT\$1MOST\$1ONCE | Es wird nur ein Versuch zum Senden der Nachricht unternommen, unabhängig davon, ob sie empfangen wird oder nicht. Die Nachricht wird möglicherweise überhaupt nicht gesendet, z. B. wenn das Gerät nicht angeschlossen ist oder ein Netzwerkfehler vorliegt. |
| QoS-Stufe 1 | mqtt.QoS.AT\$1LEAST\$1ONCE | Die Nachricht wird wiederholt gesendet, bis eine PUBACK-Bestätigung eingeht. |
In der Beispiel-App werden die Veröffentlichungs- und Abonnementanfragen mit einer QoS-Stufe von 1 (`mqtt.QoS.AT_LEAST_ONCE`) gestellt.
+
**QoS beim Veröffentlichen**
Wenn ein Gerät eine Nachricht mit QoS Stufe 1 veröffentlicht, sendet es die Nachricht wiederholt, bis es eine `PUBACK`-Antwort vom Message Broker erhält. Wenn das Gerät nicht verbunden ist, wird die Nachricht in die Warteschlange gestellt, damit sie nach dem erneuten Herstellen der Verbindung gesendet werden kann.
+
**QoS beim Abonnieren**
Wenn ein Gerät eine Nachricht mit QoS Stufe 1 abonniert, speichert der Message Broker die Nachrichten, die das Gerät abonniert hat, bis sie an das Gerät gesendet werden können. Der Message Broker sendet die Nachrichten so oft, bis er eine `PUBACK`-Antwort vom Gerät erhält.
### Nachrichten veröffentlichen
Nach dem erfolgreichen Herstellen einer Verbindung zu AWS IoT Core können Geräte Nachrichten veröffentlichen. Das `pubsub.py`-Beispiel tut dies, indem es die `publish`-Operation des `mqtt_connection`-Objekts aufruft.
```
mqtt_connection.publish(
topic=args.topic,
payload=message,
qos=mqtt.QoS.AT_LEAST_ONCE
)
```
`topic`
Der Themenname der Nachricht, der die Nachricht identifiziert
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`payload`
Die als Zeichenfolge formatierte Nachrichten-Payload (z. B. ein JSON-Dokument)
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
Ein JSON-Dokument ist ein gängiges Payload-Format, das auch von anderen AWS IoT Diensten erkannt wird. Das Datenformat der Nachrichten-Payload kann jedoch alles sein, worauf sich Herausgeber und Abonnenten einigen. Andere AWS IoT -Dienste erkennen jedoch für die meisten Operationen nur JSON und in einigen Fällen auch CBOR an.
`qos`
Die QoS-Stufe für diese Nachricht
### Nachrichten abonnieren
Um Nachrichten von AWS IoT und anderen Diensten und Geräten zu empfangen, abonnieren Geräte diese Nachrichten anhand ihres Themennamens. Geräte können einzelne Nachrichten abonnieren, indem sie einen [Themennamen](topics.md#topicnames) angeben, und eine Gruppe von Nachrichten, indem sie einen [Themenfilter](topics.md#topicfilters) angeben, der Platzhalterzeichen enthalten kann. Das `pubsub.py`-Beispiel verwendet den hier gezeigten Code, um Nachrichten zu abonnieren und die Callback-Funktionen zu registrieren, um die Nachricht nach dem Empfang zu verarbeiten.
```
subscribe_future, packet_id = mqtt_connection.subscribe(
topic=args.topic,
qos=mqtt.QoS.AT_LEAST_ONCE,
callback=on_message_received
)
subscribe_result = subscribe_future.result()
```
`topic`
Das zu abonnierende Thema. Dies kann ein Themenname oder ein Themenfilter sein.
In der Beispiel-App wird dieser Wert von der Befehlszeile aus übergeben.
`qos`
Ob der Message Broker diese Nachrichten speichern soll, während das Gerät nicht angeschlossen ist.
Ein Wert von `mqtt.QoS.AT_LEAST_ONCE` (QoS Stufe 1) erfordert die Angabe einer persistenten Sitzung (`clean_session=False`), wenn die Verbindung hergestellt wird.
`callback`
Die Funktion, die aufgerufen werden soll, um die abonnierte Nachricht zu verarbeiten.
Die `mqtt_connection.subscribe`-Funktion gibt eine Future- und eine Paket-ID zurück. Wenn die Anfrage nach einem Abonnement erfolgreich initiiert wurde, ist die zurückgegebene Paket-ID größer als 0. Um sicherzustellen, dass das Abonnement vom Message Broker empfangen und registriert wurde, müssen Sie warten, bis das Ergebnis des asynchronen Vorgangs zurückgegeben wird, wie im Codebeispiel gezeigt.
**Die Callback-Funktion**
Der Callback im `pubsub.py`-Beispiel verarbeitet die abonnierten Nachrichten so, wie das Gerät sie empfängt.
```
def on_message_received(topic, payload, **kwargs):
print("Received message from topic '{}': {}".format(topic, payload))
global received_count
received_count += 1
if received_count == args.count:
received_all_event.set()
```
`topic`
Das Thema der Nachricht
Dies ist der spezifische Themenname der empfangenen Nachricht, auch wenn Sie einen Themenfilter abonniert haben.
`payload`
Die Nutzdaten der Nachricht
Das Format dafür ist anwendungsspezifisch.
`kwargs`
Mögliche zusätzliche Argumente, wie unter [https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe](https://awslabs.github.io/aws-crt-python/api/mqtt.html#awscrt.mqtt.Connection.subscribe) beschrieben.
Im `pubsub.py`-Beispiel zeigt nur `on_message_received` das Thema und seine Payload an. Außerdem werden die eingegangenen Nachrichten gezählt, um das Programm zu beenden, nachdem das Limit erreicht wurde.
Ihre App würde das Thema und die Payload auswerten, um zu bestimmen, welche Aktionen ausgeführt werden sollen.
### Trennen und erneutes Anschließen des Geräts
Das `pubsub.py`-Beispiel enthält Callback-Funktionen, die aufgerufen werden, wenn das Gerät getrennt wird und wenn die Verbindung wiederhergestellt wird. Welche Aktionen Ihr Gerät bei diesen Ereignissen ausführt, ist anwendungsspezifisch.
Wenn ein Gerät zum ersten Mal eine Verbindung herstellt, muss es Themen abonnieren, um empfangen zu können. Wenn die Sitzung eines Geräts beim erneuten Herstellen der Verbindung vorhanden ist, werden seine Abonnements wiederhergestellt, und alle gespeicherten Nachrichten aus diesen Abonnements werden nach dem erneuten Herstellen der Verbindung an das Gerät gesendet.
Wenn die Sitzung eines Geräts beim erneuten Herstellen der Verbindung nicht mehr besteht, muss das Gerät seine Abonnements erneut abonnieren. Persistente Sitzungen haben eine begrenzte Lebensdauer und können ablaufen, wenn das Gerät zu lange keine Verbindung hat.
## Connect dein Gerät und kommuniziere mit AWS IoT Core
In diesem Abschnitt finden Sie einige Übungen, mit denen Sie die verschiedenen Aspekte der Verbindung Ihres Geräts mit AWS IoT Core kennenlernen können. Für diese Übungen verwenden Sie den [MQTT-Testclient](https://console.aws.amazon.com/iot/home#/test) in der AWS IoT -Konsole, um zu sehen, was Ihr Gerät veröffentlicht, und um Nachrichten auf Ihrem Gerät zu veröffentlichen. Diese Übungen verwenden das [https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/master/samples/pubsub.py)-Beispiel aus dem [AWS IoT -Device SDK v2 für Python](https://github.com/aws/aws-iot-device-sdk-python-v2/tree/master/samples#sample-apps-for-the-aws-iot-device-sdk-v2-for-python) und bauen auf Ihren Erfahrungen mit [Erste Schritte mit AWS IoT Core Tutorials](iot-gs.md)-Tutorials auf.
**Topics**
+ [Abonnieren von Themenfiltern mit Platzhaltern](#sdk-tutorials-experiment-wild)
+ [Abonnements mit Themenfiltern verarbeiten](#sdk-tutorials-experiment-process)
+ [Veröffentlichen von Nachrichten vom Gerät.](#sdk-tutorials-experiment-publish)
Für diese Übungen beginnen Sie mit dem `pubsub.py`-Beispielprogramm.
**Anmerkung**
Bei diesen Übungen wird davon ausgegangen, dass Sie die [Erste Schritte mit AWS IoT Core Tutorials](iot-gs.md)-Tutorials abgeschlossen haben und das Terminalfenster für das Gerät aus diesem Tutorial verwenden.
### Abonnieren von Themenfiltern mit Platzhaltern
In dieser Übung ändern Sie die Befehlszeile, die verwendet wird, um `pubsub.py` zum Abonnieren eines Themenfilters mit Platzhaltern aufzurufen, und verarbeiten die empfangenen Nachrichten auf der Grundlage des Themas der Nachricht.
#### Ablauf der Übung
Stellen Sie sich für diese Übung vor, dass das Gerät über eine Temperatursteuerung und eine Lichtsteuerung verfügt. Es verwendet diese Themennamen, um die Nachrichten zu diesen Themen zu identifizieren.
1. Bevor Sie mit der Übung beginnen, versuchen Sie, diesen Befehl aus den [Erste Schritte mit AWS IoT Core Tutorials](iot-gs.md)-Tutorials auf dem Gerät auszuführen, um sicherzustellen, dass alles für die Übung bereit ist.
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic topic_1 --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Sie sollten dieselbe Ausgabe wie im [Tutorial Erste Schritte](connecting-to-existing-device.md#gs-device-node-app-run) sehen.
1. Ändern Sie für diese Übung diese Befehlszeilen-Parameter.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/sdk-tutorials.html)
Wenn Sie diese Änderungen an der ersten Befehlszeile vornehmen, wird diese Befehlszeile angezeigt. Geben Sie diesen Befehl in das Terminalfenster Ihres Geräts ein.
```
python3 pubsub.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
Das Programm sollte wie folgt aussehen:
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-24d7cdcc-cc01-458c-8488-2d05849691e1'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
```
Wenn Sie so etwas auf Ihrem Terminal sehen, ist Ihr Gerät bereit und wartet auf Nachrichten, bei denen die Themennamen mit `device` beginnen und mit `/detail` enden. Lassen Sie uns das also testen.
1. Hier sind ein paar Nachrichten, die Ihr Gerät möglicherweise empfängt.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/sdk-tutorials.html)
1. Senden Sie mit dem MQTT-Testclient in der AWS IoT Konsole die im vorherigen Schritt beschriebenen Nachrichten an Ihr Gerät.
1. Öffnen Sie den [MQTT-Testclient](https://console.aws.amazon.com/iot/home#/test) in der AWS IoT Konsole.
1. Geben Sie unter **Abonnieren eines Themas** im Feld **Abonnementthema** den Themenfilter **device/\$1/details** ein und wählen Sie anschließend **Thema Abonnieren** aus.
1. Wählen Sie in der Spalte **Abonnements** des MQTT-Testclients **Gerät/\$1/Details** aus.
1. Gehen Sie für jedes der Themen in der vorherigen Tabelle im MQTT-Testclient wie folgt vor:
1. Geben Sie unter **Veröffentlichen** den Wert aus der Spalte **Themenname** in der Tabelle ein.
1. Geben Sie in das Feld Nachrichten-Payload unter dem Themennamen den Wert aus der Spalte **Nachrichten-Payload** in der Tabelle ein.
1. Sehen Sie sich das Terminalfenster an, in dem `pubsub.py` läuft, und wählen Sie im MQTT-Testclient die Option **Für Thema veröffentlichen**.
Sie sollten im Terminalfenster sehen, dass die Nachricht von `pubsub.py` empfangen wurde.
#### Ergebnis der Übung
Damit hat `pubsub.py` die Nachrichten mithilfe eines Themenfilters mit Platzhaltern abonniert, sie empfangen und im Terminalfenster angezeigt. Beachten Sie, dass Sie einen einzelnen Themenfilter abonniert haben und die Callback-Funktion aufgerufen wurde, um Nachrichten mit zwei unterschiedlichen Themen zu verarbeiten.
### Abonnements mit Themenfiltern verarbeiten
Aufbauend auf der vorherigen Übung ändern Sie die `pubsub.py` Beispiel-App, um die Nachrichtenthemen auszuwerten und die abonnierten Nachrichten auf der Grundlage des Themas zu verarbeiten.
#### Ablauf der Übung
**Um das Thema der Nachricht zu bewerten,**
1. Kopieren Sie `pubsub.py` in `pubsub2.py`.
1. Öffnen Sie `pubsub2.py` in Ihrem bevorzugten Texteditor oder IDE.
1. Suchen Sie in `pubsub2.py` nach der `on_message_received`-Funktion.
1. Fügen Sie in `on_message_received` den folgenden Code nach der Zeile ein, die mit `print("Received message` beginnt, und vor der Zeile, die mit `global received_count` beginnt.
```
topic_parsed = False
if "/" in topic:
parsed_topic = topic.split("/")
if len(parsed_topic) == 3:
# this topic has the correct format
if (parsed_topic[0] == 'device') and (parsed_topic[2] == 'details'):
# this is a topic we care about, so check the 2nd element
if (parsed_topic[1] == 'temp'):
print("Received temperature request: {}".format(payload))
topic_parsed = True
if (parsed_topic[1] == 'light'):
print("Received light request: {}".format(payload))
topic_parsed = True
if not topic_parsed:
print("Unrecognized message topic.")
```
1. Speichern Sie Ihre Änderungen und führen Sie das geänderte Programm mithilfe dieser Befehlszeile aus.
```
python3 pubsub2.py --message "" --count 2 --topic device/+/details --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
1. Öffnen Sie in der AWS IoT Konsole den [MQTT-Testclient](https://console.aws.amazon.com/iot/home#/test).
1. Geben Sie unter **Abonnieren eines Themas** im Feld **Abonnementthema** den Themenfilter **device/\$1/details** ein und wählen Sie anschließend **Thema Abonnieren** aus.
1. Wählen Sie in der Spalte **Abonnements** des MQTT-Testclients die Option **Gerät/\$1/Details** aus.
1. Gehen Sie für jedes der Themen in dieser Tabelle im MQTT-Testclient wie folgt vor:
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/sdk-tutorials.html)
1. Geben Sie unter **Veröffentlichen** den Wert aus der Spalte **Themenname** in der Tabelle ein.
1. Geben Sie in das Feld Nachrichten-Payload unter dem Themennamen den Wert aus der Spalte **Nachrichten-Payload** in der Tabelle ein.
1. Sehen Sie sich das Terminalfenster an, in dem `pubsub.py` läuft, und wählen Sie im MQTT-Testclient die Option **Für Thema veröffentlichen**.
Sie sollten im Terminalfenster sehen, dass die Nachricht von `pubsub.py` empfangen wurde.
Sie sollten in Ihrem Terminalfenster etwas Ähnliches sehen.
```
Connecting to a3qexamplesffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-af794be0-7542-45a0-b0af-0b0ea7474517'...
Connected!
Subscribing to topic 'device/+/details'...
Subscribed with QoS.AT_LEAST_ONCE
Waiting for all messages to be received...
Received message from topic 'device/light/details': b'{ "desiredLight": 100, "currentLight": 50 }'
Received light request: b'{ "desiredLight": 100, "currentLight": 50 }'
Received message from topic 'device/temp/details': b'{ "desiredTemp": 20, "currentTemp": 15 }'
Received temperature request: b'{ "desiredTemp": 20, "currentTemp": 15 }'
2 message(s) received.
Disconnecting...
Disconnected!
```
#### Ergebnis der Übung
In dieser Übung haben Sie Code hinzugefügt, damit die Beispiel-App mehrere Nachrichten in der Callback-Funktion erkennt und verarbeitet. Damit könnte Ihr Gerät Nachrichten empfangen und darauf reagieren.
Ihr Gerät kann auch mehrere Nachrichten empfangen und verarbeiten, indem es verschiedene Nachrichten separat abonniert und jedem Abonnement eine eigene Callback-Funktion zuweist.
### Veröffentlichen von Nachrichten vom Gerät.
Sie können die Beispiel-App pubsub.py verwenden, um Nachrichten von Ihrem Gerät aus zu veröffentlichen. Nachrichten werden zwar so veröffentlicht, wie sie sind, aber die Nachrichten können nicht als JSON-Dokumente gelesen werden. In dieser Übung wird die Beispiel-App so modifiziert, dass sie JSON-Dokumente in der Nachrichten-Payload veröffentlichen kann, die dann gelesen werden können. AWS IoT Core
#### Ablauf der Übung
In dieser Übung wird die folgende Nachricht zusammen mit dem `device/data`-Thema gesendet.
```
{
"timestamp": 1601048303,
"sensorId": 28,
"sensorData": [
{
"sensorName": "Wind speed",
"sensorValue": 34.2211224
}
]
}
```
**So bereiten Sie Ihren MQTT-Testclient für die Überwachung der Nachrichten aus dieser Übung vor**
1. Geben Sie unter **Abonnieren eines Themas** im Feld **Abonnementthema** den Themenfilter **device/data** ein und wählen Sie anschließend **Thema Abonnieren** aus.
1. Wählen Sie in der Spalte **Abonnements** des MQTT-Testclients die Option **Gerät/Daten** aus.
1. Lassen Sie das Fenster des MQTT-Testclients geöffnet, um auf Nachrichten von Ihrem Gerät zu warten.
**Um JSON-Dokumente mit der Beispiel-App „pubsub.py“ zu senden,**
1. Kopieren Sie auf dem Gerät `pubsub.py` nach `pubsub3.py`.
1. Bearbeiten Sie `pubsub3.py`, um die Formatierung der zu veröffentlichenden Nachrichten zu ändern.
1. Öffnen Sie `pubsub3.py` in einem Texteditor.
1. Suchen Sie diese Codezeile:
`message = "{} [{}]".format(message_string, publish_count)`
1. Ändern Sie sie in:
`message = "{}".format(message_string)`
1. Suchen Sie diese Codezeile:
`message_json = json.dumps(message)`
1. Ändern Sie sie in:
`message = "{}".json.dumps(json.loads(message))`
1. Speichern Sie Ihre Änderungen.
1. Führen Sie auf dem Gerät diesen Befehl aus, um die Nachricht zweimal zu senden.
```
python3 pubsub3.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --topic device/data --count 2 --message '{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}' --endpoint your-iot-endpoint
```
1. Prüfen Sie im MQTT-Testclient, ob er das JSON-Dokument in der Nachrichten-Payload wie folgt interpretiert und formatiert hat:
![\[Das Bild zeigt, wie eine JSON-Nachrichtennutzlast im MQTT-Client der Konsole angezeigt wird. AWS IoT\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/images/mqtt-test-client-output.png)
`pubsub3.py` abonniert standardmäßig auch die Nachrichten, die es sendet. Sie sollten sehen können, dass es die Nachrichten im Ausgabefenster der App empfangen hat. Das Terminalfenster sollte etwa folgendermaßen aussehen.
```
Connecting to a3qEXAMPLEsffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-5cff18ae-1e92-4c38-a9d4-7b9771afc52f'...
Connected!
Subscribing to topic 'device/data'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 2 message(s)
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
Publishing message to topic 'device/data': {"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}
Received message from topic 'device/data': b'{"timestamp":1601048303,"sensorId":28,"sensorData":[{"sensorName":"Wind speed","sensorValue":34.2211224}]}'
2 message(s) received.
Disconnecting...
Disconnected!
```
#### Ergebnis der Übung
Auf diese Weise kann Ihr Gerät Nachrichten generieren, an die Sie senden können, AWS IoT Core um die grundlegende Konnektivität zu testen, und Gerätemeldungen AWS IoT Core zur Verarbeitung bereitstellen. Sie könnten diese App beispielsweise verwenden, um Testdaten von Ihrem Gerät zu senden, um AWS IoT Regelaktionen zu testen.
## Überprüfen Sie die Ergebnisse.
Die Beispiele in diesem Tutorial haben Ihnen praktische Erfahrungen mit den Grundlagen der Kommunikation zwischen Geräten vermittelt AWS IoT Core— ein wesentlicher Bestandteil Ihrer AWS IoT Lösung. Wenn Ihre Geräte in der Lage sind AWS IoT Core, mit ihnen zu kommunizieren, können sie Nachrichten an AWS Dienste und andere Geräte weiterleiten, auf denen sie reagieren können. Ebenso können AWS Dienste und andere Geräte Informationen verarbeiten, die dazu führen, dass Nachrichten an Ihre Geräte zurückgesendet werden.
Wenn Sie bereit sind, AWS IoT Core weiter zu forschen, probieren Sie diese Tutorials aus:
+ [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md)
+ [Tutorial: Gerätedaten in einer DynamoDB-Tabelle speichern](iot-ddb-rule.md)
+ [Tutorial: Formatieren einer Benachrichtigung mithilfe einer AWS Lambda Funktion](iot-lambda-rule.md)
# Tutorial: Verwenden des AWS IoT Device SDK for Embedded C
In diesem Abschnitt wird beschrieben, wie Sie den ausführen AWS IoT Device SDK for Embedded C.
**Topics**
+ [Schritt 1: Installieren Sie das AWS IoT Device SDK for Embedded C](#install-embedded-c-sdk)
+ [Schritt 2: Konfigurieren der Beispielanwendung](#iot-c-sdk-app-config)
+ [Schritt 3: So laden Sie die Beispielanwendung herunter und führen sie aus](#iot-c-sdk-app-run)
## Schritt 1: Installieren Sie das AWS IoT Device SDK for Embedded C
Das AWS IoT Device SDK for Embedded C richtet sich im Allgemeinen an Geräte mit eingeschränkten Ressourcen, die eine optimierte Laufzeit in C-Sprache benötigen. Sie können das SDK auf jedem Betriebssystem verwenden und es auf jedem Prozessortyp hosten (z. B. MCUs und MPUs). Wenn Sie mehr Speicher- und Verarbeitungsressourcen zur Verfügung haben, empfehlen wir, dass Sie eines der AWS IoT Geräte- und Mobilgeräte der höheren Ordnung verwenden SDKs (z. B. C\$1\$1 JavaScript, Java und Python).
Im Allgemeinen AWS IoT Device SDK for Embedded C ist das für Systeme vorgesehen, die eingebettete Betriebssysteme verwenden MCUs oder MPUs Low-End-Betriebssysteme verwenden. Für das Programmierbeispiel in diesem Abschnitt gehen wir davon aus, dass Ihr Gerät Linux verwendet.
**Example**
1. Laden Sie das von AWS IoT Device SDK for Embedded C [GitHub](https://github.com/aws/aws-iot-device-sdk-embedded-C)auf Ihr Gerät herunter.
```
git clone https://github.com/aws/aws-iot-device-sdk-embedded-c.git --recurse-submodules
```
Dadurch wird ein Verzeichnis mit dem Namen `aws-iot-device-sdk-embedded-c` im aktuellen Verzeichnis erstellt.
1. Navigieren Sie zu diesem Verzeichnis und machen Sie sich mit der neuesten Version vertraut. Bitte sehen Sie sich [Github an. com/aws/aws-iot-device-sdk-embedded-C/tags](https://github.com/aws/aws-iot-device-sdk-embedded-C/tags)für das neueste Release-Tag.
```
cd aws-iot-device-sdk-embedded-c
git checkout latest-release-tag
```
1. Installieren Sie die OpenSSL-Version 1.1.0 oder höher. Die OpenSSL-Entwicklungsbibliotheken werden in der Regel „libssl-dev“ oder „openssl-devel“ genannt, wenn sie über einen Paketmanager installiert werden.
```
sudo apt-get install libssl-dev
```
## Schritt 2: Konfigurieren der Beispielanwendung
Das AWS IoT Device SDK for Embedded C beinhaltet Beispielanwendungen, die Sie ausprobieren können. Der Einfachheit halber wird in diesem Tutorial die `mqtt_demo_mutual_auth` Anwendung verwendet, die veranschaulicht, wie Sie eine Verbindung zum AWS IoT Core Message Broker herstellen und MQTT-Themen abonnieren und veröffentlichen.
1. Kopieren Sie das Zertifikat und den privaten Schlüssel, den Sie in [Erste Schritte mit AWS IoT Core Tutorials](iot-gs.md) erstellt haben, in das Verzeichnis `build/bin/certificates`.
**Anmerkung**
Geräte- und CA-Stammzertifikate laufen ab oder können widerrufen werden. Wenn diese Zertifikate ablaufen oder widerrufen werden, müssen Sie ein neues CA-Zertifikat oder einen privaten Schlüssel und ein Gerätezertifikat auf Ihr Gerät kopieren.
1. Sie müssen das Beispiel mit Ihrem persönlichen AWS IoT Core Endpunkt, Ihrem privaten Schlüssel, Ihrem Zertifikat und Ihrem Root-CA-Zertifikat konfigurieren. Navigieren Sie zum `aws-iot-device-sdk-embedded-c/demos/mqtt/mqtt_demo_mutual_auth` Verzeichnis .
Wenn Sie das AWS CLI installiert haben, können Sie diesen Befehl verwenden, um die Endpunkt-URL Ihres Kontos zu finden.
```
aws iot describe-endpoint --endpoint-type iot:Data-ATS
```
Wenn Sie den nicht AWS CLI installiert haben, öffnen Sie Ihre [AWS IoT Konsole](https://console.aws.amazon.com/iot/home). Wählen Sie im Navigationsbereich **Verwalten** und dann **Objekte** aus. Wählen Sie das IoT-Objekt für Ihr Gerät und dann **Interagieren** aus. Ihr Endpunkt wird im Abschnitt **HTTPS** auf der Seite mit den Objektdetails angezeigt.
1. Öffnen Sie die Datei `demo_config.h` und aktualisieren Sie die Werte für Folgendes:
AWS\$1IOT\$1ENDPUNKT
Ihr persönlicher Endpunkt.
CLIENT\$1CERT\$1PATH
Der Dateipfad Ihres Zertifikats, zum Beispiel `certificates/device.pem.crt"`.
CLIENT\$1PRIVATE\$1KEY\$1PATH
Der Dateiname Ihres privaten Schlüssels, zum Beispiel `certificates/private.pem.key`.
Zum Beispiel:
```
// Get from demo_config.h
// =================================================
#define AWS_IOT_ENDPOINT "my-endpoint-ats.iot.us-east-1.amazonaws.com"
#define AWS_MQTT_PORT 8883
#define CLIENT_IDENTIFIER "testclient"
#define ROOT_CA_CERT_PATH "certificates/AmazonRootCA1.crt"
#define CLIENT_CERT_PATH "certificates/my-device-cert.pem.crt"
#define CLIENT_PRIVATE_KEY_PATH "certificates/my-device-private-key.pem.key"
// =================================================
```
1. Überprüfen Sie mit diesem Befehl, ob Sie es auf Ihrem Gerät CMake installiert haben.
```
cmake --version
```
Wenn die Versionsinformationen für den Compiler angezeigt werden, können Sie mit dem nächsten Abschnitt fortfahren.
Wenn Sie eine Fehlermeldung erhalten oder keine Informationen angezeigt werden, müssen Sie das CMake-Paket mit diesem Befehl installieren.
```
sudo apt-get install cmake
```
Führen Sie den **cmake --version** Befehl erneut aus und vergewissern Sie CMake sich, dass er installiert wurde und dass Sie bereit sind, fortzufahren.
1. Überprüfen Sie mithilfe dieses Befehls, ob die Entwicklungstools auf Ihrem Gerät installiert sind.
```
gcc --version
```
Wenn die Versionsinformationen für den Compiler angezeigt werden, können Sie mit dem nächsten Abschnitt fortfahren.
Wenn Sie eine Fehlermeldung erhalten oder keine Compilerinformationen angezeigt werden, müssen Sie das Paket `build-essential` mit diesem Befehl installieren.
```
sudo apt-get install build-essential
```
Führen Sie den Befehl **gcc --version** erneut aus und vergewissern Sie sich, dass die Build-Tools installiert wurden und Sie fortfahren können.
## Schritt 3: So laden Sie die Beispielanwendung herunter und führen sie aus
In diesem Verfahren wird erklärt, wie Sie die `mqtt_demo_mutual_auth` Anwendung auf Ihrem Gerät generieren und sie mithilfe von mit der [AWS IoT Konsole](https://console.aws.amazon.com/iot/home) verbinden. AWS IoT Device SDK for Embedded C
**Um die Beispielanwendungen auszuführen AWS IoT Device SDK for Embedded C**
1. Navigieren Sie zu `aws-iot-device-sdk-embedded-c` und erstellen Sie ein Build-Verzeichnis.
```
mkdir build && cd build
```
1. Geben Sie den folgenden CMake Befehl ein, um die zum Erstellen benötigten Makefiles zu generieren.
```
cmake ..
```
1. Geben Sie den folgenden Befehl ein, um die ausführbare App-Datei zu erstellen:
```
make
```
1. Führen Sie die App `mqtt_demo_mutual_auth` mit diesem Befehl aus.
```
cd bin
./mqtt_demo_mutual_auth
```
Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:
![\[Befehlszeilenausgabe zum Ausführen der AWS IoT Device SDK for Embedded C Beispielanwendung.\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/images/successful-run2.png)
Ihr Gerät ist jetzt AWS IoT mit dem verbunden AWS IoT Device SDK for Embedded C.
Sie können die AWS IoT Konsole auch verwenden, um die MQTT-Nachrichten anzuzeigen, die die Beispiel-App veröffentlicht. Weitere Informationen zur Verwendung des MQTT-Clients in der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home) finden Sie unter [MQTT-Nachrichten mit dem AWS IoT MQTT-Client anzeigen](view-mqtt-messages.md).
# AWS IoT Regeln erstellen, um Gerätedaten an andere Dienste weiterzuleiten
In diesen Tutorials erfahren Sie, wie Sie AWS IoT Regeln mithilfe einiger der gängigsten Regelaktionen erstellen und testen.
AWS IoT Regeln senden Daten von Ihren Geräten an andere AWS Dienste. Sie warten auf bestimmte MQTT-Nachrichten, formatieren die Daten in den Nachrichtennutzlasten und senden das Ergebnis an andere AWS Dienste.
Wir empfehlen Ihnen, diese in der Reihenfolge auszuprobieren, in der sie hier angezeigt werden, auch wenn Sie eine Regel erstellen möchten, die eine Lambda-Funktion oder etwas komplexeres verwendet. Die Tutorials werden in der Reihenfolge von einfach bis komplex präsentiert. Sie stellen schrittweise neue Konzepte vor, damit Sie sich mit den Konzepten vertraut machen können, die Sie zum Erstellen von Regelaktionen verwenden können, für die es kein spezielles Tutorial gibt.
**Anmerkung**
AWS IoT Regeln helfen Ihnen dabei, die Daten von Ihren IoT-Geräten an andere AWS Dienste zu senden. Um dies erfolgreich zu tun, benötigen Sie jedoch Grundkenntnisse der anderen Dienste, an die Sie Daten senden möchten. Diese Tutorials enthalten zwar die notwendigen Informationen, um die Aufgaben zu erledigen, aber es könnte hilfreich sein, mehr über die Dienste zu erfahren, an die Sie Daten senden möchten, bevor Sie sie in Ihrer Lösung verwenden. Eine ausführliche Erläuterung der anderen AWS Dienste würde den Rahmen dieser Tutorials sprengen.
**Überblick über Tutorial-Szenarien**
Das Szenario für diese Tutorials ist das eines Wettersensorgeräts, das seine Daten regelmäßig veröffentlicht. In diesem imaginären System gibt es viele solcher Sensorgeräte. Die Tutorials in diesem Abschnitt konzentrieren sich jedoch auf ein einzelnes Gerät und zeigen, wie Sie mehrere Sensoren unterbringen können.
Die Tutorials in diesem Abschnitt zeigen Ihnen, wie Sie AWS IoT Regeln verwenden, um die folgenden Aufgaben mit diesem imaginären System von Wettersensorgeräten zu erledigen.
+
**[Tutorial: Eine MQTT-Nachricht erneut veröffentlichen](iot-repub-rule.md)**
Dieses Tutorial zeigt, wie Sie eine von den Wettersensoren empfangene MQTT-Nachricht als Nachricht, die nur die Sensor-ID und den Temperaturwert enthält, erneut veröffentlichen. Es verwendet nur AWS IoT Core Dienste und demonstriert eine einfache SQL-Abfrage und wie Sie den MQTT-Client verwenden, um Ihre Regel zu testen.
+
**[Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md)**
Dieses Tutorial zeigt, wie Sie eine SNS-Nachricht senden, wenn ein Wert von einem Wettersensorgerät einen bestimmten Wert überschreitet. Es baut auf den im vorherigen Tutorial vorgestellten Konzepten auf und fügt hinzu, wie Sie mit einem anderen AWS Service, dem [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html) (Amazon SNS), arbeiten können.
Wenn Sie noch keine Erfahrung mit Amazon SNS haben, lesen Sie die Übungen [Erste Schritte](https://docs.aws.amazon.com//sns/latest/dg/sns-getting-started.html), bevor Sie mit dieser Anleitung beginnen.
+
**[Tutorial: Gerätedaten in einer DynamoDB-Tabelle speichern](iot-ddb-rule.md)**
Dieses Tutorial zeigt, wie Sie die Daten der Wettersensorgeräte in einer Datenbanktabelle speichern. Es verwendet die Regelabfrageanweisung und die Ersatzvorlagen, um die Nachrichtendaten für den Zieldienst [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html) zu formatieren.
Wenn Sie mit DynamoDB noch nicht vertraut sind, lesen Sie sich die Übungen [Erste Schritte](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html) durch, bevor Sie mit diesem Tutorial beginnen.
+
**[Tutorial: Formatieren einer Benachrichtigung mithilfe einer AWS Lambda Funktion](iot-lambda-rule.md)**
Dieses Tutorial zeigt, wie Sie eine Lambda-Funktion aufrufen, um die Gerätedaten neu zu formatieren und sie dann als Textnachricht zu senden. Es fügt ein Python-Skript und AWS SDK-Funktionen zu einer [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)Funktion hinzu, um sie mit den Nachrichtennutzdaten der Wettersensorgeräte zu formatieren und eine Textnachricht zu senden.
Wenn Sie Lambda noch nicht kennen, lesen Sie sich die Übungen [Erste Schritte](https://docs.aws.amazon.com//lambda/latest/dg/getting-started.html) durch, bevor Sie mit diesem Tutorial beginnen.
**AWS IoT Überblick über die Regeln**
In all diesen Tutorials werden AWS IoT Regeln erstellt.
Damit eine AWS IoT Regel die Daten von einem Gerät an einen anderen AWS Dienst sendet, verwendet sie:
+ Eine Anweisung zur Regelabfrage, die aus folgenden Elementen besteht:
+ Eine SQL SELECT-Klausel, die die Daten aus der Nachrichtennutzlast auswählt und formatiert
+ Ein Themenfilter (das FROM-Objekt in der Regelabfrageanweisung), der die zu verwendenden Nachrichten identifiziert
+ Eine optionale bedingte Anweisung (eine SQL WHERE-Klausel), die bestimmte Bedingungen festlegt, auf die reagiert werden soll
+ Mindestens eine Regelaktion
Geräte veröffentlichen Nachrichten zu MQTT-Themen. Der Themenfilter in der SQL SELECT-Anweisung identifiziert die MQTT-Themen, auf die die Regel angewendet werden soll. Die in der SQL SELECT-Anweisung angegebenen Felder formatieren die Daten aus der Nutzlast der eingehenden MQTT-Nachricht zur Verwendung durch die Aktionen der Regel. Eine vollständige Liste der Regelaktionen finden Sie unter [AWS IoT Regelaktionen](iot-rule-actions.md).
**Topics**
+ [Tutorial: Eine MQTT-Nachricht erneut veröffentlichen](iot-repub-rule.md)
+ [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md)
+ [Tutorial: Gerätedaten in einer DynamoDB-Tabelle speichern](iot-ddb-rule.md)
+ [Tutorial: Formatieren einer Benachrichtigung mithilfe einer AWS Lambda Funktion](iot-lambda-rule.md)
# Tutorial: Eine MQTT-Nachricht erneut veröffentlichen
Dieses Tutorial zeigt, wie Sie eine AWS IoT Regel erstellen, die eine MQTT-Nachricht veröffentlicht, wenn eine bestimmte MQTT-Nachricht empfangen wird. Die Nutzlast für eingehende Nachrichten kann durch die Regel geändert werden, bevor sie veröffentlicht wird. Auf diese Weise können Sie Nachrichten erstellen, die auf bestimmte Anwendungen zugeschnitten sind, ohne dass Sie Ihr Gerät oder dessen Firmware ändern müssen. Sie können auch den Filteraspekt einer Regel verwenden, um Nachrichten nur zu veröffentlichen, wenn eine bestimmte Bedingung erfüllt ist.
Die durch eine Regel erneut veröffentlichten Nachrichten verhalten sich wie Nachrichten, die von einem anderen AWS IoT Gerät oder Client gesendet wurden. Geräte können die erneut veröffentlichten Nachrichten genauso abonnieren, wie sie jedes andere MQTT-Nachrichtenthema abonnieren können.
**Was Sie in diesem Tutorial lernen werden:**
+ 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 30 Minuten.
**Topics**
+ [Lesen Sie die MQTT-Themen und AWS IoT -Regeln](#iot-repub-rule-mqtt)
+ [Schritt 1: Erstellen Sie eine AWS IoT Regel, um eine MQTT-Nachricht erneut zu veröffentlichen](#iot-repub-rule-define)
+ [Schritt 2: Testen Ihrer neuen Regel](#iot-repub-rule-test)
+ [Schritt 3: Überprüfen Sie die Ergebnisse und die nächsten Schritte](#iot-repub-rule-review)
**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.
## Lesen Sie die MQTT-Themen und AWS IoT -Regeln
Bevor wir über AWS IoT Regeln sprechen, ist es hilfreich, das MQTT-Protokoll zu verstehen. In IoT-Lösungen bietet das MQTT-Protokoll einige Vorteile gegenüber anderen Netzwerkkommunikationsprotokollen wie HTTP, was es zu einer beliebten Wahl für die Verwendung durch IoT-Geräte macht. In diesem Abschnitt werden die wichtigsten Aspekte von MQTT in Bezug auf dieses Tutorial beschrieben. Informationen darüber, wie MQTT im Vergleich zu HTTP abschneidet, finden Sie unter [Wählen Sie ein Anwendungsprotokoll für Ihre Gerätekommunikation](protocols.md#protocol-selection).
**MQTT-Protokoll**
Das MQTT-Protokoll verwendet ein publish/subscribe Kommunikationsmodell mit seinem Host. Um Daten zu senden, veröffentlichen Geräte Nachrichten, die anhand von Themen identifiziert sind, an den AWS IoT Message Broker. Um Nachrichten vom Message Broker zu empfangen, abonnieren Geräte die Themen, die sie erhalten, indem sie Themenfilter in Abonnementanfragen an den Message Broker senden. Die AWS IoT Regel-Engine empfängt MQTT-Nachrichten vom Message Broker.
**AWS IoT Regeln**
AWS IoT Regeln bestehen aus einer Regelabfrageanweisung und einer oder mehreren Regelaktionen. Wenn die AWS IoT Regel-Engine eine MQTT-Nachricht empfängt, reagieren diese Elemente wie folgt auf die Nachricht.
+
**Anweisung zur Regelabfrage**
Die Abfrageanweisung der Regel beschreibt die zu verwendenden MQTT-Themen, interpretiert die Daten aus der Nachrichtennutzlast und formatiert die Daten wie in einer SQL-Anweisung beschrieben, die den Anweisungen ähnelt, die in gängigen SQL-Datenbanken verwendet werden. Das Ergebnis der Abfrageanweisung sind die Daten, die an die Aktionen der Regel gesendet werden.
+
**Regelaktion**
Jede Regelaktion in einer Regel bezieht sich auf die Daten, die sich aus der Abfrageanweisung der Regel ergeben. AWS IoT unterstützt [viele Regelaktionen](iot-rule-actions.md). In diesem Tutorial konzentrieren Sie sich jedoch auf die [Erneut veröffentlichen](republish-rule-action.md) Regelaktion, bei der das Ergebnis der Abfrageanweisung als MQTT-Nachricht mit einem bestimmten Thema veröffentlicht wird.
## Schritt 1: Erstellen Sie eine AWS IoT Regel, um eine MQTT-Nachricht erneut zu veröffentlichen
Die AWS IoT Regel, die Sie in diesem Tutorial erstellen, abonniert die `device/device_id/data` MQTT-Themen, wobei die ID des Geräts *device\$1id* angegeben ist, das die Nachricht gesendet hat. Diese Themen werden durch einen [Themenfilter](topics.md#topicfilters) als `device/+/data` beschrieben, wobei es sich bei `+` um ein Platzhalterzeichen handelt, das einer beliebigen Zeichenfolge zwischen den beiden Schrägstrichen entspricht.
Wenn die Regel eine Nachricht von einem passenden Thema empfängt, veröffentlicht sie die `device_id` und `temperature` Werte erneut als neue MQTT-Nachricht mit dem `device/data/temp` Thema.
Die Nutzlast einer MQTT-Nachricht mit dem `device/22/data` Thema sieht beispielsweise so aus:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Die Regel verwendet den `temperature` Wert aus der Nachrichtennutzlast und den `device_id` aus dem Thema und veröffentlicht sie erneut als MQTT-Nachricht mit dem `device/data/temp` Thema und einer Nachrichtennutzlast, die wie folgt aussieht:
```
{
"device_id": "22",
"temperature": 28
}
```
Mit dieser Regel abonnieren Geräte, die nur die Geräte-ID und die Temperaturdaten benötigen, das `device/data/temp` Thema, um nur diese Informationen zu erhalten.
**Erstellen einer Regel, die eine MQTT-Nachricht erneut veröffentlicht**
1. Öffnen Sie [den **Regel-Hub** der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/rulehub).
1. Wählen Sie unter **Regeln** die Option **Erstellen** aus und beginnen Sie mit der Erstellung Ihrer neuen Regel.
1. Gehen Sie im oberen Teil von **Regel erstellen** wie folgt vor:
1. Geben Sie im Feld **Name** den Namen der Regel ein. Für dieses Tutorial nennen Sie es **republish\$1temp**.
Denken Sie daran, dass ein Regelname innerhalb Ihres Kontos und 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 hilft Ihnen dabei, 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 topic(2) as device_id, temperature FROM 'device/+/data'
```
Diese Aussage:
+ Hört auf MQTT-Nachrichten mit einem Thema, das dem `device/+/data` Themenfilter entspricht.
+ Wählt das zweite Element aus der Themenzeichenfolge aus und weist es dem `device_id` Feld zu.
+ Wählt das Wert `temperature` Feld aus der Nachrichtennutzlast aus und weist es dem `temperature` Feld zu.
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 zu einem AWS IoT Thema erneut veröffentlichen** aus.
1. Wählen Sie unten in der Aktionsliste die Option **Aktion konfigurieren** aus, um die Konfigurationsseite der ausgewählten Aktion zu öffnen.
1. Gehen Sie in **Aktion konfigurieren** wie folgt vor:
1. Geben Sie im Feld **Thema** **device/data/temp** ein. Dies ist das MQTT-Thema der Nachricht, die diese Regel veröffentlichen wird.
1. Wählen Sie unter **Qualität der Dienstleistung** die Option **0 aus. Die Nachricht wird null oder mehrere Mal zugestellt.**
1. Gehen **Sie unter Rolle auswählen oder erstellen, um AWS IoT Zugriff auf diese Aktion zu gewähren**, wie folgt vor:
1. Wählen Sie **Rolle erstellen** aus. Das Dialogfeld **Eine neue Rolle erstellen** wird geöffnet.
1. Geben Sie einen Namen ein, der die neue Rolle beschreibt. Verwenden Sie in diesem Tutorial **republish\$1role**.
Wenn Sie eine neue Rolle erstellen, werden die richtigen Richtlinien für die Ausführung der Regelaktion erstellt und der neuen Rolle zugeordnet. Wenn Sie das Thema dieser Regelaktion ändern oder diese Rolle in einer anderen Regelaktion verwenden, müssen Sie die Richtlinie für diese Rolle aktualisieren, um das neue Thema oder die neue Aktion zu autorisieren. Um eine bestehende Rolle zu aktualisieren, wählen Sie in diesem Abschnitt die Option **Rolle aktualisieren** aus.
1. Wählen Sie **Rolle erstellen** aus, um die Rolle zu erstellen und das Dialogfeld zu schließen.
1. Wählen Sie **Aktion hinzufügen**, um die Aktion zur Regel hinzuzufügen und zur Seite **Regel erstellen** zurückzukehren.
1. Die Aktion **Eine Nachricht in einem AWS IoT Thema erneut veröffentlichen** ist jetzt unter **Eine oder mehrere Aktionen festlegen** aufgeführt.
In der Kachel der neuen Aktion unter **Nachricht zu einem AWS IoT Thema erneut veröffentlichen** können Sie das Thema sehen, in dem die neue Aktion veröffentlicht wird.
Dies ist die einzige Regelaktion, die Sie zu dieser Regel hinzufügen werden.
1. Scrollen Sie in **Regel erstellen** ganz nach unten und wählen Sie **Regel erstellen** aus, um die Regel zu erstellen und diesen Schritt abzuschließen.
## Schritt 2: Testen Ihrer neuen Regel
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. Auf diese Weise können Sie die Regel bearbeiten, ohne die Konfiguration Ihres MQTT-Clients zu verlieren. Der MQTT-Client speichert keine Abonnements oder Nachrichtenprotokolle, wenn Sie ihn verlassen, um zu einer anderen Seite in der Konsole zu wechseln.
**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. Abonnieren Sie das Thema, das Ihre Regel veröffentlichen wird: `device/data/temp`.
1. Wählen Sie unter **Abonnements** erneut die Option **Thema abonnieren** aus, und geben Sie unter **Abonnementthema** das Thema der erneut veröffentlichten Nachricht **device/data/temp** ein.
1. Belassen Sie die übrigen Felder auf ihren Standardeinstellungen.
1. Wählen Sie **Thema abonnieren** aus.
In der Spalte **Abonnements** wird **device/data/temp** unter **Geräte/\$1/Daten** angezeigt.
1. Veröffentlichen Sie eine Nachricht zum Eingabethema mit einer bestimmten Geräte-ID, **device/22/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/22/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**.
1. Überprüfen Sie die gesendeten Nachrichten.
1. Im MQTT-Client befindet sich unter **Abonnements** ein grüner Punkt neben den beiden Themen, die Sie zuvor abonniert haben.
Die grünen Punkte zeigen 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": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Prüfen Sie unter **Abonnements **device/data/temp****, ob Ihre Payload für erneut veröffentlichte Nachrichten wie folgt aussieht:
```
{
"device_id": "22",
"temperature": 28
}
```
Beachten Sie, dass es sich bei dem `device_id` Wert um eine Zeichenfolge in Anführungszeichen handelt und der Wert `temperature` numerisch ist. Das liegt daran, dass die [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) Funktion die Zeichenfolge aus dem Themennamen der Eingabenachricht extrahiert hat, während der `temperature` Wert den numerischen Wert aus der Nutzlast der Eingabenachricht verwendet.
Wenn Sie den Wert zu einem numerischen `device_id` Wert machen möchten, ersetzen Sie `topic(2)` in der Anweisung zur Regelabfrage durch:
```
cast(topic(2) AS DECIMAL)
```
Beachten Sie, dass die Umwandlung des `topic(2)` Werts in einen numerischen Wert nur funktioniert, wenn dieser Teil des Themas nur numerische Zeichen enthält.
1. Wenn Sie feststellen, dass die richtige Nachricht zum **device/data/temp**Thema veröffentlicht wurde, hat Ihre Regel funktioniert. Weitere Informationen zur Aktion „Regel erneut veröffentlichen“ finden Sie im nächsten Abschnitt.
Wenn du nicht siehst, dass die richtige Nachricht entweder auf dem **Gerät/\$1/data** oder in den **device/data/temp**Themen veröffentlicht wurde, sieh dir die Tipps zur Fehlerbehebung an.
### Problembehebung bei der Regel „Nachricht erneut veröffentlichen“
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/22/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 sehen Ihre erneut veröffentlichte Nachricht nicht im MQTT-Client**
Damit Ihre Regel funktioniert, muss sie über die richtige Richtlinie verfügen, die sie autorisiert, eine Nachricht zu empfangen und erneut zu veröffentlichen, und sie muss die Nachricht empfangen.
**Zu überprüfende Dinge**
+
**Überprüfen Sie Ihren MQTT-Client und die AWS-Region Regel, die Sie erstellt haben**
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 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 das Thema der erneut veröffentlichten Nachricht in der Regelaktion**
Das Thema, zu dem die Regelaktion „Erneut veröffentlichen“ die neue Nachricht veröffentlicht, muss mit dem Thema übereinstimmen, das Sie im MQTT-Client abonniert haben.
Öffnen Sie die Regel, die Sie in der Konsole erstellt haben, und überprüfen Sie das Thema, zu dem die Regelaktion die Nachricht erneut veröffentlicht.
+
**Ü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 3: Überprüfen Sie die Ergebnisse und die nächsten Schritte
**In diesem Tutorial**
+ Sie haben eine einfache SQL-Abfrage und einige Funktionen in einer Regelabfrageanweisung verwendet, um eine neue MQTT-Nachricht zu erzeugen.
+ Sie haben eine Regel erstellt, die diese neue Nachricht erneut veröffentlicht hat.
+ Sie haben den MQTT-Client verwendet, um Ihre AWS IoT Regel zu testen.
**Nächste Schritte**
Nachdem Sie einige Nachrichten mit dieser Regel erneut veröffentlicht haben, probieren Sie sie aus, um zu sehen, wie sich Änderungen einiger Aspekte des Tutorials auf die erneut veröffentlichte Nachricht auswirken. Hier sind einige Ideen, die Ihnen den Einstieg erleichtern sollen.
+ Ändern Sie das Thema *device\$1id* der Eingabenachricht und beobachten Sie die Auswirkungen in der neu veröffentlichten Nachrichten-Payload.
+ Ändern Sie die in der Regelabfrageanweisung ausgewählten Felder und beobachten Sie die Auswirkungen auf die Nutzlast der erneut veröffentlichten Nachricht.
+ Probieren Sie das nächste Tutorial in dieser Serie und lernen Sie, wie man [Tutorial: Senden einer Amazon SNS-Benachrichtigung](iot-sns-rule.md).
Die in diesem Tutorial verwendete Aktion Regel erneut veröffentlichen kann Ihnen auch beim Debuggen von Regelabfrageanweisungen helfen. Sie können diese Aktion beispielsweise einer Regel hinzufügen, um zu sehen, wie ihre Regelabfrageanweisung die von ihren Regelaktionen verwendeten Daten formatiert.
# Tutorial: Senden einer Amazon SNS-Benachrichtigung
Dieses Tutorial zeigt, wie Sie eine AWS IoT Regel erstellen, die MQTT-Nachrichtendaten an ein Amazon SNS SNS-Thema sendet, sodass sie als SMS-Textnachricht gesendet werden können.
In diesem Tutorial erstellen Sie eine Regel, die Nachrichtendaten von einem Wettersensor an alle Abonnenten eines Amazon SNS-Themas sendet, wenn die Temperatur den in der Regel festgelegten Wert überschreitet. Die Regel erkennt, wenn die gemeldete Temperatur den in der Regel festgelegten Wert überschreitet, und erstellt dann eine neue Nachrichtennutzlast, die nur die Geräte-ID, die gemeldete Temperatur und den Temperaturgrenzwert, der überschritten wurde, enthält. Die Regel sendet die neue Nachrichtennutzlast als JSON-Dokument an ein SNS-Thema, wodurch alle Abonnenten des SNS-Themas benachrichtigt werden.
**Was Sie in diesem Tutorial lernen werden:**
+ So erstellen und testen Sie eine Amazon SNS-Benachrichtigung
+ So rufen Sie eine Amazon SNS SNS-Benachrichtigung von einer Regel aus auf AWS IoT
+ 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 30 Minuten.
**Topics**
+ [Schritt 1: Erstellen Sie ein Amazon SNS SNS-Thema, das eine SMS-Textnachricht sendet](#iot-sns-rule-create-sns-topic)
+ [Schritt 2: Erstellen Sie eine AWS IoT Regel zum Senden der Textnachricht](#iot-sns-rule-create-rule)
+ [Schritt 3: Testen Sie die AWS IoT Regel und die Amazon SNS SNS-Benachrichtigung](#iot-sns-rule-test-rule)
+ [Schritt 4: Überprüfen Sie die Ergebnisse und die nächsten Schritte](#iot-sns-rule-review-results)
**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.
+
**Der Amazon [Amazon Simple Notification Service](https://docs.aws.amazon.com//sns/latest/dg/welcome.html) wurde überprüft**
Wenn Sie Amazon SNS noch nicht verwendet haben, lesen Sie den Artikel [Zugriff für Amazon SNS einrichten](https://docs.aws.amazon.com//sns/latest/dg/sns-setting-up.html). Wenn Sie bereits andere AWS IoT Tutorials abgeschlossen haben, AWS-Konto sollten Sie bereits korrekt konfiguriert sein.
## Schritt 1: Erstellen Sie ein Amazon SNS SNS-Thema, das eine SMS-Textnachricht sendet
In diesem Verfahren wird erklärt, wie Sie das Amazon SNS SNS-Thema erstellen, an das Ihr Wettersensor Nachrichtendaten senden kann. Das Amazon SNS SNS-Thema benachrichtigt dann alle Abonnenten per SMS-Textnachricht über das Temperaturlimit, das überschritten wurde.
**Ein Amazon-SNS-Thema erstellen, das eine SMS-Textnachricht sendet**
1. **Erstellen Sie ein Amazon-SNS-Thema**.
1. Melden Sie sich bei der [Amazon-SNS-Konsole](https://console.aws.amazon.com//sns/home) an.
1. Wählen Sie im linken Navigationsbereich **Topics (Themen)**.
1. Wählen Sie auf der Seite **Topics (Themen)** **Create New Topic (Neues Thema erstellen)** aus.
1. Wählen Sie unter **Details** den **Standardtyp** aus. Standardmäßig erstellt die Konsole ein FIFO-Thema.
1. Geben Sie im Feld **Name** den Namen des SNS-Themas ein. Geben Sie für dieses Tutorial **high\$1temp\$1notice** ein.
1. Scrollen Sie zum Ende der Seite und wählen Sie **Create topic (Erstellen eines Themas)** aus.
In der Konsole wird die Seite **Details** geöffnet.
1. **Erstellen Sie ein Amazon-SNS-Abonnement.**
**Anmerkung**
Für die Telefonnummer, die Sie in diesem Abonnement verwenden, können Gebühren für Textnachrichten aufgrund der Nachrichten anfallen, die Sie in diesem Tutorial versenden.
1. Wählen Sie auf der Detailseite des Themas **high\$1temp\$1notice** die Option **Abonnement erstellen**.
1. Wählen Sie unter **Abonnement erstellen** im Abschnitt **Details** in der **Protokoll**-Liste die Option **SMS** aus.
1. Geben Sie im Feld **Endpunkt** die Nummer eines Telefons ein, das Textnachrichten empfangen kann. Achten Sie darauf, dass Sie es so eingeben, dass es mit einem `+` beginnt, die Landes- und Ortsvorwahl enthält und keine anderen Satzzeichen enthält.
1. Wählen Sie **Create subscription** (Abonnement erstellen) aus.
1. **Testen Sie die Amazon SNS-Benachrichtigung.**
1. Wählen Sie in der [Amazon SNS-Konsole](https://console.aws.amazon.com//sns/home) im linken Navigationsbereich **Themen**.
1. Um die Detailseite des Themas zu öffnen, wählen Sie unter **Themen** in der Liste der Themen den Eintrag **high\$1temp\$1notice** aus.
1. Um die Seite **Nachricht im Thema veröffentlichen** zu öffnen, wählen Sie auf der Detailseite von **high\$1temp\$1notice** die Option **Nachricht veröffentlichen** aus.
1. Geben Sie unter **Nachricht zum Thema veröffentlichen** im Abschnitt ** Nachrichtentext** im Feld **Nachrichtentext, der an den Endpunkt gesendet werden soll**, eine Kurznachricht ein.
1. Scrollen Sie auf der Seite nach unten und wählen Sie **Nachricht veröffentlichen**.
1. Vergewissern Sie sich auf dem Telefon mit der Nummer, die Sie zuvor bei der Erstellung des Abonnements verwendet haben, dass die Nachricht empfangen wurde.
Wenn Sie die Testnachricht nicht erhalten haben, überprüfen Sie die Telefonnummer und die Einstellungen Ihres Telefons.
Stellen Sie sicher, dass Sie Testnachrichten von der [Amazon SNS-Konsole](https://console.aws.amazon.com//sns/home) aus veröffentlichen können, bevor Sie mit dem Tutorial fortfahren.
## Schritt 2: Erstellen Sie eine AWS IoT Regel zum Senden der Textnachricht
Die AWS IoT Regel, die Sie in diesem Tutorial erstellen, abonniert die `device/device_id/data` MQTT-Themen, wobei die ID des Geräts angegeben `device_id` ist, das die Nachricht gesendet hat. Diese Themen werden in einem Themenfilter als `device/+/data` beschrieben, wobei es sich bei `+` um ein Platzhalterzeichen handelt, das einer beliebigen Zeichenfolge zwischen den beiden Schrägstrichen entspricht. Diese Regel testet auch den Wert des `temperature` Felds in der Nachrichtennutzlast.
Wenn die Regel eine Nachricht von einem passenden Thema empfängt, verwendet sie den `device_id` Themennamen, den `temperature` Wert aus der Nachrichtennutzlast, fügt einen konstanten Wert für das zu testende Limit hinzu und sendet diese Werte als JSON-Dokument an ein Amazon SNS-Benachrichtigungsthema.
Zum Beispiel verwendet eine MQTT-Nachricht vom Wettersensorgerät Nummer 32 das `device/32/data` Thema und hat eine Nachrichtennutzlast, die wie folgt aussieht:
```
{
"temperature": 38,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Die Regelabfrageanweisung der Regel nimmt den `temperature` Wert aus der Nachrichtennutzlast, den `device_id` aus dem Themennamen und fügt den konstanten `max_temperature` Wert hinzu, um eine Nachrichtennutzlast zu senden, die wie folgt aussieht, zum Amazonc SNS-Thema:
```
{
"device_id": "32",
"reported_temperature": 38,
"max_temperature": 30
}
```
**Um eine AWS IoT Regel zur Erkennung einer Temperaturüberschreitung zu erstellen und die Daten zu erstellen, die an das Amazon SNS SNS-Thema gesendet werden sollen**
1. Öffnen Sie [den **Regel-Hub** der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/rulehub).
1. Wenn dies Ihre erste Regel ist, wählen Sie **Erstellen** oder **Regel erstellen**.
1. In **Erstellen einer Regel**:
1. Geben Sie unter **Name** **temp\$1limit\$1notify** ein.
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 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 topic(2) as device_id,
temperature as reported_temperature,
30 as max_temperature
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 und weist es dem `device_id` Feld zu.
+ Wählt das Wert `temperature` Feld aus der Nachrichtennutzlast aus und weist es dem `reported_temperature` Feld zu.
+ Erstellt einen konstanten Wert `30`, der den Grenzwert darstellt, und weist ihn dem `max_temperature` Feld zu.
1. Um die Liste der Regelaktionen für diese Regel zu öffnen, wählen Sie unter **Eine oder mehrere Aktionen festlegen** die Option **Aktion hinzufügen** aus.
1. Wählen Sie unter **Aktion auswählen** die Option **Eine Nachricht als SNS-Push-Benachrichtigung 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 **SNS-Ziel** die Option **Auswählen** aus, suchen Sie Ihr SNS-Thema mit dem Namen **high\$1temp\$1notice** und wählen Sie **Auswählen** aus.
1. Wählen Sie unter **Nachrichtenformat** das Format **RAW**.
1. **Wählen Sie unter Rolle auswählen oder erstellen, um AWS IoT Zugriff auf diese Aktion zu gewähren**, die Option **Rolle erstellen** aus.
1. Geben Sie unter **Neue Rolle erstellen** im Feld **Name** einen eindeutigen Namen für die neue Rolle ein. Verwenden Sie für dieses Tutorial **sns\$1rule\$1role**.
1. Wählen Sie **Rolle erstellen** aus.
Wenn Sie dieses Tutorial wiederholen oder eine bestehende Rolle wiederverwenden, wählen Sie **Rolle aktualisieren**, bevor Sie fortfahren. Dadurch wird das Richtliniendokument der Rolle aktualisiert, sodass es mit dem SNS-Ziel funktioniert.
1. Wählen Sie **Aktion hinzufügen** und kehren Sie zur Seite **Regel erstellen** zurück.
In der Kachel der neuen Aktion unter **Eine Nachricht als SNS-Push-Benachrichtigung senden** finden Sie das SNS-Thema, das Ihre Regel aufrufen wird.
Dies ist die einzige Regelaktion, die Sie zu dieser Regel hinzufügen werden.
1. Um die Regel zu erstellen und diesen Schritt abzuschließen, scrollen Sie unter **Regel erstellen** nach unten und wählen Sie **Regel erstellen** aus.
## Schritt 3: Testen Sie die AWS IoT Regel und die Amazon SNS SNS-Benachrichtigung
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. Auf diese Weise 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, werden keine Abonnements oder Nachrichtenprotokolle gespeichert.
**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 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_id":"32","reported_temperature":38,"max_temperature":30}
```
Beachten Sie, dass es sich bei dem `device_id` Wert um eine Zeichenfolge in Anführungszeichen handelt und der Wert `temperature` numerisch ist. Das liegt daran, dass die [https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic](https://docs.aws.amazon.com//iot/latest/developerguide/iot-sql-functions.html#iot-function-topic) Funktion die Zeichenfolge aus dem Themennamen der Eingabenachricht extrahiert hat, während der `temperature` Wert den numerischen Wert aus der Nutzlast der Eingabenachricht verwendet.
Wenn Sie den Wert zu einem numerischen `device_id` Wert machen möchten, ersetzen Sie `topic(2)` in der Anweisung zur Regelabfrage durch:
```
cast(topic(2) AS DECIMAL)
```
Beachten Sie, dass die Umwandlung des `topic(2)` Werts in einen numerischen `DECIMAL` Wert nur funktioniert, wenn dieser Teil des Themas 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.
### Fehlerbehebung bei Ihrer SNS-Nachrichtenregel
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/22/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 das Thema der erneut veröffentlichten Nachricht in der Regelaktion**
Das Thema, zu dem die Regelaktion „Erneut veröffentlichen“ die neue Nachricht veröffentlicht, muss mit dem Thema übereinstimmen, das Sie im MQTT-Client abonniert haben.
Öffnen Sie die Regel, die Sie in der Konsole erstellt haben, und überprüfen Sie das Thema, zu dem die Regelaktion die Nachricht erneut veröffentlicht.
+
**Ü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
**In diesem Tutorial:**
+ Sie haben ein Amazon-SNS-Benachrichtigungsthema und ein Abonnement erstellt und getestet.
+ Sie haben eine einfache SQL-Abfrage und Funktionen in einer Regelabfrageanweisung verwendet, um eine neue Nachricht für Ihre Benachrichtigung zu erstellen.
+ Sie haben eine AWS IoT Regel zum Senden einer Amazon SNS SNS-Benachrichtigung erstellt, die Ihre benutzerdefinierte Nachrichtennutzlast verwendet hat.
+ 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 und beobachten Sie die Auswirkungen auf den Inhalt der Textnachricht.
+ Ändern Sie den Test in der Regelabfrageanweisung so, dass er auf eine Mindesttemperatur statt auf eine Höchsttemperatur testet. Denken Sie daran, den Namen von `max_temperature` zu ändern\$1
+ Fügen Sie eine Regelaktion zum erneuten Veröffentlichen hinzu, um eine MQTT-Nachricht zu senden, wenn eine SNS-Benachrichtigung gesendet wird.
+ Probieren Sie das nächste Tutorial in dieser Serie und lernen Sie, wie man [Tutorial: Gerätedaten in einer DynamoDB-Tabelle speichern](iot-ddb-rule.md).
# Tutorial: Gerätedaten in einer DynamoDB-Tabelle speichern
Dieses Tutorial zeigt, wie Sie eine AWS IoT Regel erstellen, die Nachrichtendaten an eine DynamoDB-Tabelle sendet.
In diesem Tutorial erstellen Sie eine Regel, die Nachrichtendaten von einem imaginären Wettersensorgerät an eine DynamoDB-Tabelle sendet. Die Regel formatiert die Daten vieler Wettersensoren so, dass sie zu einer einzigen Datenbanktabelle hinzugefügt werden können.
**Was Sie in diesem Tutorial lernen werden**
+ So erstellen Sie eine DynamoDB-Tabelle
+ So senden Sie Nachrichtendaten aus einer Regel an eine DynamoDB-Tabelle AWS IoT
+ Wie verwendet man Ersatzvorlagen in einer Regel AWS IoT
+ 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 30 Minuten.
**Topics**
+ [Schritt 1: Erstellen Sie die DynamoDB-Tabelle für dieses Tutorial](#iot-ddb-rule-ddb-table)
+ [Schritt 2: Erstellen Sie eine AWS IoT Regel zum Senden von Daten an die DynamoDB-Tabelle](#iot-ddb-rule-topic-rule)
+ [Schritt 3: Testen Sie die AWS IoT Regel und die DynamoDB-Tabelle](#iot-ddb-rule-test)
+ [Schritt 4: Überprüfen Sie die Ergebnisse und die nächsten Schritte](#iot-ddb-rule-review)
**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.
+
**Übersicht über [Amazon DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/Introduction.html) überprüft**
Wenn Sie DynamoDB noch nicht verwendet haben, lesen Sie [Erste Schritte mit DynamoDB](https://docs.aws.amazon.com//amazondynamodb/latest/developerguide/GettingStartedDynamoDB.html), um sich mit den grundlegenden Konzepten und Funktionen von DynamoDB vertraut zu machen.
## Schritt 1: Erstellen Sie die DynamoDB-Tabelle für dieses Tutorial
In diesem Tutorial erstellen Sie eine DynamoDB-Tabelle mit diesen Attributen, um die Daten der imaginären Wettersensorgeräte aufzuzeichnen:
+ `sample_time` ist ein Primärschlüssel und beschreibt den Zeitpunkt, zu dem die Probe aufgenommen wurde.
+ `device_id` ist ein Sortierschlüssel und beschreibt das Gerät, das die Probe bereitgestellt hat
+ `device_data` sind die vom Gerät empfangenen und durch die Regelabfrageanweisung formatierten Daten
**Erstellen einer DynamoDB-Tabelle für dieses Tutorial**
1. Öffnen Sie die [DynamoDB-Konsole](https://console.aws.amazon.com//dynamodb/home) und wählen Sie **Tabelle erstellen** aus.
1. Gehen Sie in **Tabelle erstellen** wie folgt vor:
1. Geben Sie unter **Tabellenname** den Tabellennamen **wx\$1data** ein.
1. Geben Sie im Feld **Partitionsschlüssel** **sample\$1time** ein, und wählen Sie **Number** in der Optionsliste neben dem Feld aus.
1. Geben Sie im Feld **Sortierschlüssel** **device\$1id** ein und wählen Sie **Number** in der Optionsliste neben dem Feld aus.
1. Wählen Sie unten auf der Seite **Erstellen** aus.
Sie definieren `device_data` später, wenn Sie die DynamoDB-Regelaktion konfigurieren.
## Schritt 2: Erstellen Sie eine AWS IoT Regel zum Senden von Daten an die DynamoDB-Tabelle
In diesem Schritt verwenden Sie die Regelabfrageanweisung, um die Daten der imaginären Wettersensorgeräte so zu formatieren, dass sie in die Datenbanktabelle geschrieben werden.
Ein Beispiel für eine Nachrichtennutzlast, die von einem Wettersensorgerät empfangen wurde, sieht wie folgt aus:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
Für den Datenbankeintrag verwenden Sie die Regelabfrageanweisung, um die Struktur der Nutzlast der Nachricht so zu reduzieren, dass sie wie folgt aussieht:
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind_velocity": 22,
"wind_bearing": 255
}
```
In dieser Regel verwenden Sie auch ein paar [Ersetzungsvorlagen](iot-substitution-templates.md). Ersatzvorlagen sind Ausdrücke, mit denen Sie dynamische Werte aus Funktionen und Nachrichtendaten einfügen können.
**Um die AWS IoT Regel zum Senden von Daten an die DynamoDB-Tabelle zu erstellen**
1. Öffnen Sie [den Regel-Hub der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/rulehub). Oder Sie können die AWS IoT Startseite innerhalb von öffnen AWS-Managementkonsole und zu **Nachrichtenweiterleitung>Regeln** navigieren.
1. Um mit der Erstellung Ihrer neuen Regel unter **Regeln** zu beginnen, wählen Sie **Regel erstellen** aus.
1. In den **Regeleigenschaften**:
1. Geben Sie in **Role Name (Rollenname)** **wx\$1data\$1ddb** ein.
Denken Sie daran, dass ein Regelname in Ihrer Region AWS-Konto und 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 in der **Regelbeschreibung**.
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. Wählen Sie **Next** (Weiter), um fortzufahren.
1. In **SQL-Anweisung**:
1. Wählen Sie in der **SQL-Version** **2016-03-23** aus.
1. Geben Sie im Bearbeitungsfeld für die **SQL-Anweisung** die folgende Anweisung ein:
```
SELECT temperature, humidity, barometer,
wind.velocity as wind_velocity,
wind.bearing as wind_bearing,
FROM 'device/+/data'
```
Diese Aussage:
+ Hört auf MQTT-Nachrichten mit einem Thema, das dem `device/+/data` Themenfilter entspricht.
+ Formatiert die Elemente des `wind` Attributs als einzelne Attribute.
+ Übergibt die `temperature`, `humidity`, und `barometer` Attribute unverändert.
1. Wählen Sie **Next** (Weiter), um fortzufahren.
1. In **Regelaktionen**:
1. Um die Liste der Regelaktionen für diese Regel zu öffnen, wählen Sie in **Aktion 1** die Option **DynamoDB**.
**Anmerkung**
Stellen Sie sicher, dass Sie DynamoDB und nicht Dynamo DBv2 als Regelaktion wählen.
1. Wählen Sie unter **Tabellenname** den Namen der DynamoDB-Tabelle aus, die Sie in einem vorherigen Schritt erstellt haben: **wx\$1data**
Die Felder **Partitionsschlüsseltyp** und **Sortierschlüsseltyp** werden mit den Werten aus Ihrer DynamoDB-Tabelle gefüllt.
1. Geben Sie im Feld **Partitionsschlüssel** den Wert **sample\$1time** ein.
1. Geben Sie unter **Partition key value (Partitions-Schlüsselwert)** **\$1\$1timestamp()\$1** ein.
Dies ist die erste der [Ersetzungsvorlagen](iot-substitution-templates.md), die Sie in dieser Regel verwenden werden. Anstatt einen Wert aus der Nachrichtennutzlast zu verwenden, wird der von der Zeitstempelfunktion zurückgegebene Wert verwendet. Weitere Informationen finden Sie unter [Zeitstempel](iot-sql-functions.md#iot-function-timestamp) im *AWS IoT Core Entwicklerhandbuch*.
1. Geben Sie unter **Sort key (Sortierschlüssel)** **device\$1id** ein.
1. Geben Sie unter **Sort key value (Schlüsselwert sortieren)** **\$1\$1cast(topic(2) AS DECIMAL)\$1** ein.
Dies ist der zweite der [Ersetzungsvorlagen](iot-substitution-templates.md) den Sie in dieser Regel verwenden werden. Es fügt den Wert des zweiten Elements in den Themennamen ein, bei dem es sich um die ID des Geräts handelt, nachdem es ihn in einen DEZIMALWERT umgewandelt hat, der dem numerischen Format des Schlüssels entspricht. Weitere Informationen zu Themen finden Sie unter [Thema](iot-sql-functions.md#iot-function-topic) im *AWS IoT Core Entwicklerhandbuch*. Weitere Informationen zum Casting finden Sie unter [Besetzung](iot-sql-functions.md#iot-sql-function-cast) im *AWS IoT Core Entwicklerhandbuch*.
1. Geben Sie in **Write message data to this column (Nachrichtendaten in diese Spalte schreiben)** **device\$1data** ein.
Dadurch wird die `device_data` Spalte in der DynamoDB-Tabelle erstellt.
1. Lassen Sie **Operation** leer.
1. Wählen Sie unter **IAM Role (IAM-Rolle)** die Option **Create a New Role (Neue Rolle erstellen)** aus.
1. Geben Sie im Dialogfeld **Rolle erstellen** als **Rollenname** **wx\$1ddb\$1role** ein. Diese neue Rolle enthält automatisch eine Richtlinie mit dem Präfix "aws-iot-rule", die es der **wx\$1data\$1ddb** Regel ermöglicht, Daten an die von Ihnen erstellte **wx\$1data** DynamoDB-Tabelle zu senden.
1. Wählen Sie unter **IAM Role (IAM-Rolle)** **wx\$1ddb\$1role** aus.
1. Wählen Sie unten auf der Seite **Next (Weiter)** aus.
1. **Wählen Sie unten auf der Seite **Überprüfen und erstellen** die Option Erstellen** aus, um die Regel zu erstellen.
## Schritt 3: Testen Sie die AWS IoT Regel und die DynamoDB-Tabelle
Um die neue Regel zu testen, verwenden Sie den MQTT-Client, um die in diesem Test 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. Auf diese Weise können Sie die Regel bearbeiten, ohne die Konfiguration Ihres MQTT-Clients zu verlieren. Der MQTT-Client speichert keine Abonnements oder Nachrichtenprotokolle, wenn Sie ihn verlassen, um zu einer anderen Seite in der Konsole zu wechseln. Sie sollten außerdem ein separates Konsolenfenster für den [DynamoDB-Tabellen-Hub in der AWS IoT Konsole öffnen, um die](https://console.aws.amazon.com//dynamodb/home#tables:) neuen Einträge zu sehen, die Ihre Regel sendet.
**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) das Eingabethema, `device/+/data`.
1. Wählen Sie im MQTT-Client die Option **Publish to a topic (In einem Thema veröffentlichen)** aus.
1. Geben Sie für **Themenfilter** das Thema des Eingabethemenfilters **device/\$1/data** ein.
1. Wählen Sie **Subscribe (Abonnieren)** aus.
1. Veröffentlichen Sie jetzt eine Nachricht zum Eingabethema mit einer bestimmten Geräte-ID, **device/22/data**. Sie können keine Beiträge in MQTT-Themen veröffentlichen, die Platzhalterzeichen enthalten.
1. Wählen Sie im MQTT-Client die Option **Publish to a topic (In einem Thema veröffentlichen)** aus.
1. Geben Sie bei **Themenname** den Namen des eingegebenen Themas ein, **device/22/data**.
1. Geben Sie für **Nachrichtennutzlast** die folgenden Beispieldaten ein.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Um die MQTT-Nachricht zu veröffentlichen, wählen Sie **Veröffentlichen**.
1. Wählen Sie nun im MQTT-Client **Ein Thema abonnieren** aus. Wählen Sie in der Spalte **Abonnieren** das **device/\$1/data** Abonnement aus. Vergewissern Sie sich, dass die Beispieldaten aus dem vorherigen Schritt dort angezeigt werden.
1. Prüfen Sie, ob die Zeile in der DynamoDB-Tabelle angezeigt wird, die Ihre Regel erstellt hat.
1. **Wählen Sie im [DynamoDB-Tabellen-Hub in der AWS IoT Konsole](https://console.aws.amazon.com//dynamodb/home#tables:) **wx\$1data** und dann die Registerkarte Elemente aus.**
Wenn Sie sich bereits auf der Registerkarte **Elemente** befinden, müssen Sie möglicherweise die Anzeige aktualisieren, indem Sie das Aktualisierungssymbol in der oberen rechten Ecke der Kopfzeile der Tabelle auswählen.
1. Beachten Sie, dass es sich bei den **sample\$1time**-Werten in der Tabelle um Links handelt, und öffnen Sie einen. Wenn Sie gerade Ihre erste Nachricht gesendet haben, ist dies die einzige in der Liste.
Dieser Link zeigt alle Daten in dieser Zeile der Tabelle an.
1. Erweitern Sie den Eintrag **device\$1data**, um die Daten anzuzeigen, die sich aus der Regelabfrageanweisung ergeben haben.
1. Erkunden Sie die verschiedenen Darstellungen der Daten, die in dieser Anzeige verfügbar sind. Sie können die Daten in dieser Anzeige auch bearbeiten.
1. Wenn Sie die Überprüfung dieser Datenzeile abgeschlossen haben, klicken Sie auf **Speichern**, um alle von Ihnen vorgenommenen Änderungen zu speichern, oder klicken Sie auf **Abbrechen**, um den Vorgang zu beenden, ohne die Änderungen zu speichern.
Wenn Sie nicht das richtige Verhalten feststellen, lesen Sie die Tipps zur Fehlerbehebung.
### Problembehandlung bei Ihrer DynamoDB-Regel
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/22/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 finden Ihre Daten nicht in der DynamoDB-Tabelle**
Als Erstes müssen Sie die Anzeige aktualisieren, indem Sie oben in der Kopfzeile der Tabelle das Aktualisierungssymbol auswählen. Wenn die Daten, nach denen Sie suchen, nicht angezeigt werden, überprüfen Sie Folgendes.
**Zu überprüfende Dinge**
+
**Überprüfen Sie Ihren MQTT-Client und die AWS-Region Regel, die Sie erstellt haben**
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 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 Schlüssel- und Feldnamen, die in der Regelaktion verwendet wurden**
Die in der Themenregel verwendeten Feldnamen müssen mit denen in der JSON-Nachrichtennutzlast der veröffentlichten Nachricht übereinstimmen.
Öffnen Sie die Regel, die Sie in der Konsole erstellt haben, und überprüfen Sie die Feldnamen in der Regelaktionskonfiguration mit denen, die im MQTT-Client verwendet werden.
+
**Ü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, die die Regel autorisieren, Nachrichtendaten zu empfangen und die DynamoDB-Tabelle zu aktualisieren, sind spezifisch für die verwendeten Themen. Wenn Sie das von der Regel verwendete Thema oder den Namen der DynamoDB-Tabelle ändern, müssen Sie die Rolle der Regelaktion aktualisieren, damit ihre Richtlinie entsprechend aktualisiert wird.
Wenn Sie vermuten, dass dies das Problem ist, bearbeiten Sie die Regelaktion 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
Nachdem Sie mit dieser Regel einige Nachrichten an die DynamoDB-Tabelle gesendet haben, versuchen Sie, damit zu experimentieren, um zu sehen, wie sich Änderungen einiger Aspekte aus dem Tutorial auf die in die Tabelle geschriebenen Daten auswirken. Hier sind einige Ideen, die Ihnen den Einstieg erleichtern sollen.
+ Ändern Sie das Thema *device\$1id* in der Eingabenachricht und beobachten Sie die Auswirkungen auf die Daten. Sie könnten dies verwenden, um den Empfang von Daten von mehreren Wettersensoren zu simulieren.
+ Ändern Sie die in der Regelabfrageanweisung ausgewählten Felder und beobachten Sie die Auswirkungen auf die Daten. Sie könnten dies verwenden, um die in der Tabelle gespeicherten Daten zu filtern.
+ Fügen Sie eine Regelaktion zum erneuten Veröffentlichen hinzu, um für jede Zeile, die der Tabelle hinzugefügt wird, eine MQTT-Nachricht zu senden. Sie könnten dies zum Debuggen verwenden.
Nachdem Sie dieses Tutorial abgeschlossen haben, besuchen Sie [Tutorial: Formatieren einer Benachrichtigung mithilfe einer AWS Lambda Funktion](iot-lambda-rule.md).
# Tutorial: Formatieren einer Benachrichtigung mithilfe einer AWS Lambda Funktion
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
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
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
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
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
**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).
# Beibehalten des Gerätestatus mit Geräteschatten, während das Gerät offline ist
In diesen Tutorials erfahren Sie, wie Sie den AWS IoT Device Shadow-Dienst verwenden, um die Statusinformationen eines Geräts zu speichern und zu aktualisieren. Das Schattendokument, bei dem es sich um ein JSON-Dokument handelt, zeigt die Änderung des Gerätestatus auf der Grundlage der von einem Gerät, einer lokalen App oder einem Dienst veröffentlichten Nachrichten. In diesem Tutorial zeigt das Schattendokument die Änderung der Farbe einer Glühbirne. In diesen Tutorials wird auch gezeigt, wie der Schatten diese Informationen auch dann speichert, wenn das Gerät nicht mit dem Internet verbunden ist, und die neuesten Statusinformationen an das Gerät zurückgibt, wenn es wieder online ist und diese Informationen anfordert.
Wir empfehlen Ihnen, diese Tutorials in der Reihenfolge anzusehen, in der sie hier gezeigt werden. Beginnen Sie dabei mit den AWS IoT -Ressourcen, die Sie erstellen müssen, und der erforderlichen Hardwarekonfiguration, damit Sie die Konzepte schrittweise erlernen können. Diese Tutorials zeigen, wie Sie ein Raspberry Pi-Gerät für die Verwendung mit konfigurieren und anschließen AWS IoT. Wenn Sie nicht über die erforderliche Hardware verfügen, können Sie diesen Tutorials folgen, indem Sie sie an ein Gerät Ihrer Wahl anpassen oder [ein virtuelles Gerät mit Amazon EC2 erstellen](creating-a-virtual-thing.md).
**Übersicht über Tutorial-Szenario**
Das Szenario für diese Tutorials ist eine lokale App oder ein Dienst, der die Farbe einer Glühbirne ändert und deren Daten in reservierten Schattenthemen veröffentlicht. Diese Tutorials ähneln der Geräteschatten-Funktionalität, die im [interaktiven Tutorial „Erste Schritte](interactive-demo.md)“ beschrieben wurde, und sind auf einem Raspberry Pi-Gerät implementiert. Die Tutorials in diesem Abschnitt konzentrieren sich auf einen einzelnen, klassischen Schatten und zeigen, wie Sie benannte Schatten oder mehrere Geräte unterbringen können.
In den folgenden Tutorials erfahren Sie, wie Sie den AWS IoT Device Shadow-Dienst verwenden.
+
**[Tutorial: Ihren Raspberry Pi für die Ausführung der Schattenanwendung vorbereiten](create-resources-shadow.md)**
Dieses Tutorial zeigt, wie Sie ein Raspberry Pi-Gerät für die Verbindung einrichten AWS IoT. Außerdem erstellen Sie ein AWS IoT Richtliniendokument und eine Ding-Ressource, laden die Zertifikate herunter und hängen dann die Richtlinie an diese Ding-Ressource an. Für dieses Tutorial brauchen Sie ungefähr 30 Minuten.
+
**[Tutorial: Installation des Geräte-SDK und Ausführen der Beispielanwendung für Geräteschatten](lightbulb-shadow-application.md)**
Dieses Tutorial zeigt, wie Sie die erforderlichen Tools, Software und das AWS IoT Geräte-SDK für Python installieren und anschließend die Shadow-Beispielanwendung ausführen. Dieses Tutorial baut auf den unter [Verbinden eines Raspberry Pi oder eines anderes Gerätes](connecting-to-existing-device.md) vorgestellten Konzepten auf und nimmt 20 Minuten in Anspruch.
+
**[Tutorial: Interaktion mit Geräteschatten mithilfe der Beispiel-App und des MQTT-Testclients](interact-lights-device-shadows.md)**
Dieses Tutorial zeigt, wie Sie mithilfe der `shadow.py` Beispiel-App und der **AWS IoT Konsole** die Interaktion zwischen AWS IoT Device Shadows und den Zustandsänderungen der Glühbirne beobachten. Das Tutorial zeigt auch, wie Sie MQTT-Nachrichten an die reservierten Geräteschattenthemen senden. Für dieses Tutorial brauchen Sie ungefähr 45 Minuten.
**AWS IoT Device Shadow-Übersicht**
Ein Device Shadow ist eine persistente, virtuelle Darstellung eines Geräts, das von einer [Dingressource](iot-thing-management.md) verwaltet wird, die Sie in der AWS IoT Registrierung erstellen. Das Shadow-Dokument ist ein JSON- oder JavaScript Notationsdokument, das zum Speichern und Abrufen der aktuellen Statusinformationen für ein Gerät verwendet wird. Sie können den Shadow verwenden, um den Status eines Geräts über MQTT-Themen oder HTTP-REST abzurufen und festzulegen APIs, unabhängig davon, ob das Gerät mit dem Internet verbunden ist.
Das Schattendokument enthält eine `state`-Eigenschaft, die die folgenden Aspekte des Gerätezustands beschreibt.
+ `desired`: Apps geben die gewünschten Status der Geräteeigenschaften an, indem sie das `desired`-Objekt aktualisieren.
+ `reported`: Geräte melden ihren aktuellen Status im `reported`-Objekt.
+ `delta`: AWS IoT meldet Unterschiede zwischen dem gewünschten und dem gemeldeten Status im `delta` Objekt.
Hier sehen Sie ein Beispiel für ein Schattenstatusdokument.
```
{
"state": {
"desired": {
"color": "green"
},
"reported": {
"color": "blue"
},
"delta": {
"color": "green"
}
}
}
```
Um das Shadow-Dokument eines Geräts zu aktualisieren, können Sie die [reservierten MQTT-Themen](reserved-topics.md#reserved-topics-shadow), den [Device Shadow-REST APIs](device-shadow-rest-api.md)`GET`, der die`UPDATE`, und `DELETE` -Operationen mit HTTP unterstützt, und die [AWS IoT CLI](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot-data/index.html) verwenden.
Nehmen wir im vorherigen Beispiel an, Sie möchten die `desired` Farbe in `yellow` ändern. Senden Sie dazu eine Anfrage an die [UpdateThingShadow](device-shadow-rest-api.md#API_UpdateThingShadow) API oder veröffentlichen Sie eine Nachricht zum Thema [Aktualisieren](device-shadow-mqtt.md#update-pub-sub-topic)`$aws/things/THING_NAME/shadow/update`.
```
{
"state": {
"desired": {
"color": yellow
}
}
}
```
Aktualisierungen betreffen lediglich die in der Anfrage angegebenen Felder. Veröffentlichen Sie nach erfolgreicher Aktualisierung von Device Shadow den neuen `desired` Status im `delta` Thema,`$aws/things/THING_NAME/shadow/delta`. AWS IoT Das Schattendokument sieht in diesem Fall so aus:
```
{
"state": {
"desired": {
"color": yellow
},
"reported": {
"color": green
},
"delta": {
"color": yellow
}
}
}
```
Der neue Status wird dann dem AWS IoT Device Shadow unter Verwendung des `Update` Themas `$aws/things/THING_NAME/shadow/update` mit der folgenden JSON-Nachricht gemeldet:
```
{
"state": {
"reported": {
"color": yellow
}
}
}
```
Wenn Sie die aktuellen Statusinformationen abrufen möchten, senden Sie eine Anfrage an die [GetThingShadow](device-shadow-rest-api.md#API_GetThingShadow) API oder veröffentlichen Sie eine MQTT-Nachricht im Thema [Get](device-shadow-mqtt.md#get-pub-sub-topic)`$aws/things/THING_NAME/shadow/get`.
Weitere Informationen zur Verwendung des Geräteschattendienstes finden Sie in [AWS IoT Device Shadow-Dienst](iot-device-shadows.md).
Weitere Informationen zur Verwendung von Geräteschatten in Geräten, Apps und Diensten finden Sie unter [Verwenden von Schatten in Geräten](device-shadow-comms-device.md) und [Verwenden von Schatten in Apps und Services](device-shadow-comms-app.md).
Informationen zur Interaktion mit AWS IoT Schatten finden Sie unter[Interaktion mit Schatten](device-shadow-data-flow.md).
Informationen zu den reservierten MQTT-Themen und zu HTTP-REST APIs finden Sie unter [MQTT-Themen für Geräteschatten](device-shadow-mqtt.md) und[Geräteschatten-REST-API](device-shadow-rest-api.md).
# Tutorial: Ihren Raspberry Pi für die Ausführung der Schattenanwendung vorbereiten
Dieses Tutorial zeigt, wie Sie ein Raspberry Pi-Gerät einrichten und konfigurieren und die AWS IoT Ressourcen erstellen, die ein Gerät benötigt, um eine Verbindung herzustellen und MQTT-Nachrichten auszutauschen.
**Anmerkung**
Wenn Sie [Erstellen Sie ein virtuelles Gerät mit Amazon EC2](creating-a-virtual-thing.md) planen, können Sie diese Seite überspringen und mit [Konfigurieren Ihres Geräts](configure-device.md) weitermachen. Sie werden diese Ressourcen erstellen, wenn Sie Ihr virtuelles Objekt erstellen. Wenn Sie anstelle des Raspberry Pi ein anderes Gerät verwenden möchten, können Sie versuchen, diese Anleitungen zu befolgen, indem Sie sie an ein Gerät Ihrer Wahl anpassen.
**In diesem Kurs lernen Sie Folgendes:**
+ Richten Sie ein Raspberry Pi-Gerät ein und konfigurieren Sie es für die Verwendung mit AWS IoT.
+ Erstellen Sie ein AWS IoT Richtliniendokument, das Ihr Gerät zur Interaktion mit AWS IoT Diensten autorisiert.
+ Erstellen Sie eine Ding-Ressource in AWS IoT den X.509-Gerätezertifikaten und hängen Sie dann das Richtliniendokument an.
Das Objekt ist die virtuelle Darstellung Ihres Geräts in der AWS IoT Registrierung. Das Zertifikat authentifiziert Ihr Gerät gegenüber AWS IoT Core, und das Richtliniendokument autorisiert Ihr Gerät zur Interaktion mit Core. AWS IoT
**So führen Sie dieses Tutorial aus**
Um die `shadow.py` Beispielanwendung für Geräteschatten auszuführen, benötigen Sie ein Raspberry Pi-Gerät, das eine Verbindung zu AWS IoT herstellt. Wir empfehlen, dass Sie dieses Tutorial in der Reihenfolge folgen, in der es hier vorgestellt wird. Beginnen Sie mit der Einrichtung des Raspberry Pi und seines Zubehörs, erstellen Sie dann eine Richtlinie und fügen Sie die Richtlinie einer von Ihnen erstellten Objekt-Ressource hinzu. Anschließend können Sie diesem Tutorial folgen, indem Sie die vom Raspberry Pi unterstützte grafische Benutzeroberfläche (GUI) verwenden, um die AWS IoT Konsole im Webbrowser des Geräts zu öffnen. Dadurch ist es auch einfacher, die Zertifikate direkt auf Ihren Raspberry Pi herunterzuladen, um eine Verbindung herzustellen. AWS IoT
**Stellen Sie vor Beginn dieses Tutorials sicher, dass Sie über Folgendes verfügen:**
+ Ein AWS-Konto. Wenn dies nicht der Fall ist, führen Sie die unter [Einrichten AWS-Konto](setting-up.md) beschriebenen Schritte aus, bevor Sie fortfahren. Sie benötigen Ihre AWS-Konto AWS IoT Handkonsole, um dieses Tutorial abzuschließen.
+ Der Raspberry Pi und das notwendige Zubehör. Sie benötigen:
+ Ein [Raspberry Pi 3 Modell B](https://www.raspberrypi.com/products/) oder ein neueres Modell. Dieses Tutorial funktioniert möglicherweise auf früheren Versionen des Raspberry Pi, aber wir haben es nicht getestet.
+ [Raspberry Pi OS (32-Bit)](https://www.raspberrypi.com/software/operating-systems/) oder höher. Wir empfehlen die neueste Version des Raspberry Pi OS zu verwenden. Frühere Versionen des Betriebssystems funktionieren möglicherweise, aber wir haben es nicht getestet.
+ Eine Ethernet- oder WLAN-Verbindung.
+ Tastatur, Maus, Monitor, Kabel und Netzteile.
Für dieses Tutorial brauchen Sie ungefähr 30 Minuten.
## Schritt 1: Einrichten und Konfigurieren des Raspberry Pi-Geräts
In diesem Abschnitt konfigurieren wir ein Raspberry Pi-Gerät für die Verwendung mit AWS IoT.
**Wichtig**
Die Anpassung dieser Anweisungen an andere Geräte und Betriebssysteme kann eine Herausforderung sein. Sie müssen Ihr Gerät gut genug verstehen, um diese Anweisungen interpretieren und auf Ihr Gerät anwenden zu können. Wenn Sie auf Schwierigkeiten stoßen, können Sie alternativ eine der anderen Geräteoptionen ausprobieren, z. B. [Erstellen Sie ein virtuelles Gerät mit Amazon EC2](creating-a-virtual-thing.md) oder[Verwenden Sie Ihren Windows- oder Linux-PC oder Mac als Gerät AWS IoT](using-laptop-as-device.md).
Sie müssen Ihren Raspberry Pi so konfigurieren, dass er das Betriebssystem (OS) starten, eine Verbindung zum Internet herstellen und Ihnen die Interaktion mit ihm über eine Befehlszeilenschnittstelle ermöglicht. Sie können auch die vom Raspberry Pi unterstützte grafische Benutzeroberfläche (GUI) verwenden, um die AWS IoT Konsole zu öffnen und den Rest dieses Tutorials auszuführen.
**So richten Sie den Raspberry Pi ein**
1. Setzen Sie die SD-Karte in den MicroSD-Kartensteckplatz im Raspberry Pi ein. Auf einigen SD-Karten ist ein Installationsmanager vorinstalliert, der Sie nach dem Booten der Karte mit einem Menü zur Installation des Betriebssystems auffordert. Sie können auch den Raspberry Pi-Imager verwenden, um das Betriebssystem auf Ihrer Karte zu installieren.
1. Schließen Sie ein HDMI TV oder einen HDMI-Monitor an das HDMI-Kabel an, das an den HDMI-Anschluss des Raspberry Pi angeschlossen ist.
1. Schließe Sie Tastatur und Maus an die USB-Anschlüsse des Raspberry Pi an und schließen Sie dann den Netzadapter an, um die Platine zu starten.
Wenn nach dem Start des Raspberry Pi der Installationsmanager auf der SD-Karte vorinstalliert war, erscheint ein Menü zur Installation des Betriebssystems. Wenn Sie Probleme bei der Installation des Betriebssystems haben, können Sie die folgenden Schritte ausführen. Weitere Informationen zum Einrichten von Raspberry Pi finden Sie unter [Einrichten Ihres Raspberry Pi](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/).
**Wenn Sie Probleme beim Einrichten des Raspberry Pi haben:**
+ Überprüfen Sie, ob Sie die SD-Karte eingelegt haben, bevor Sie das Board starten. Wenn Sie die SD-Karte nach dem Booten des Boards einstecken, wird das Installationsmenü möglicherweise nicht angezeigt.
+ Vergewissern Sie sich, dass das TV oder der Monitor eingeschaltet und der richtige Eingang ausgewählt ist.
+ Stellen Sie sicher, dass Sie Raspberry Pi-kompatible Software verwenden.
Nachdem Sie das Raspberry Pi-Betriebssystem installiert und konfiguriert haben, öffnen Sie den Webbrowser des Raspberry Pi und navigieren Sie zur AWS IoT Core Konsole, um mit den restlichen Schritten in diesem Tutorial fortzufahren.
Wenn Sie die AWS IoT Core Konsole öffnen können, ist Ihr Raspberry Pi bereit und Sie können fortfahren[Tutorial: Bereitstellen Ihres Geräts in AWS IoT](shadow-provision-cloud.md).
Wenn Sie Probleme haben oder zusätzliche Hilfe benötigen, finden Sie weitere Informationen unter [Hilfe für Ihren Raspberry Pi erhalten](https://projects.raspberrypi.org/en/projects/raspberry-pi-setting-up/5).
# Tutorial: Bereitstellen Ihres Geräts in AWS IoT
In diesem Abschnitt werden die AWS IoT Core Ressourcen erstellt, die in Ihrem Tutorial verwendet werden.
**Topics**
+ [Schritt 1: Erstellen Sie eine AWS IoT Richtlinie für den Device Shadow](#create-policy-shadow)
+ [Schritt 2: Erstellen Sie eine Objekt-Ressource und fügen Sie die Richtlinie dem Objekt hinzu](#create-thing-shadow)
+ [Schritt 3: Überprüfen Sie die Ergebnisse und die nächsten Schritte](#resources-shadow-review)
## Schritt 1: Erstellen Sie eine AWS IoT Richtlinie für den Device Shadow
X.509-Zertifikate authentifizieren Ihr Gerät mit. AWS IoT Core AWS IoT Dem Zertifikat sind Richtlinien beigefügt, die es dem Gerät ermöglichen, AWS IoT Operationen wie das Abonnieren oder Veröffentlichen von reservierten MQTT-Themen auszuführen, die vom Device Shadow-Dienst verwendet werden. Ihr Gerät legt sein Zertifikat vor, wenn es eine Verbindung herstellt und Nachrichten an sendet. AWS IoT Core
In diesem Verfahren erstellen Sie eine Richtlinie, die es Ihrem Gerät ermöglicht, die zur Ausführung des Beispielprogramms erforderlichen AWS IoT -Vorgänge auszuführen. Wir empfehlen, dass Sie eine Richtlinie erstellen, die nur Berechtigungen gewährt, die zum Ausführen einer Aufgabe erforderlich sind. Sie erstellen zuerst die AWS IoT Richtlinie und hängen sie dann an das Gerätezertifikat an, das Sie später erstellen werden.
**Um eine AWS IoT Richtlinie zu erstellen**
1. Wählen Sie im linken Menü **Sicher** und dann **Richtlinien** aus. Wenn in Ihrem Konto bereits Richtlinien vorhanden sind, wählen Sie **Erstellen** aus. Andernfalls wählen Sie auf der Seite **Sie haben noch keine Richtlinie erstellt** die Option **Richtlinie erstellen** aus.
1. Auf der Seite **Create a policy (Richtlinie erstellen)**:
1. Geben Sie im Feld **Name** einen Namen für die Richtlinie ein (z. B. **My\$1Device\$1Shadow\$1policy**). Verwenden Sie keine personenbezogenen Informationen in Ihren Richtliniennamen.
1. In dem Richtliniendokument beschreiben Sie die Aktionen „Verbinden“, „Abonnieren“, „Empfangen“ und „Veröffentlichen“, die dem Gerät die Erlaubnis geben, die reservierten MQTT-Themen zu veröffentlichen und zu abonnieren.
Kopieren Sie die folgende Beispielrichtlinie und fügen Sie sie in Ihr Richtliniendokument ein. `thingname`Ersetzen Sie es durch den Namen der Sache, die Sie erstellen werden (z. B.`My_light_bulb`), `region` durch die AWS IoT Region, in der Sie die Dienste nutzen, und `account` durch Ihre AWS-Konto Nummer. Weitere Informationen zu AWS IoT Richtlinien finden Sie unter[AWS IoT Core Richtlinien](iot-policies.md).
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/get/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/thingname/shadow/update/delta"
]
},
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/test-*"
}
]
}
```
## Schritt 2: Erstellen Sie eine Objekt-Ressource und fügen Sie die Richtlinie dem Objekt hinzu
Geräte, mit denen eine Verbindung besteht, AWS IoT können durch *Ding-Ressourcen* in der AWS IoT Registrierung dargestellt werden. Eine *Objekt-Ressource* steht für ein bestimmtes Gerät oder eine logische Einheit, z. B. die Glühbirne in diesem Tutorial.
Um zu erfahren, wie Sie ein Ding in erstellen AWS IoT, folgen Sie den unter beschriebenen Schritten[Dies erstellt ein Objekt](create-iot-resources.md#create-aws-thing). Hier sind einige wichtige Dinge, die Sie beachten sollten, wenn Sie die Schritte in diesem Tutorial befolgen:
1. Wählen Sie **Ein einzelnes Objekt erstellen** und geben Sie im Feld **Name** einen Namen für das Objekt ein, der `thingname` entspricht (z. B. `My_light_bulb`), den Sie bei der Erstellung der Richtlinie zuvor angegeben haben.
Es ist nicht möglich, einen Objektnamen nach dem Erstellen umzubenennen. Wenn Sie dem Objekt einen anderen Namen als `thingname` gegeben haben, erstellen Sie ein neues Objekt mit dem Namen `thingname` und löschen Sie das alte Objekt.
**Anmerkung**
Verwenden Sie keine personenbezogenen Informationen in Ihren Objektnamen. Der Name des Objekts kann in unverschlüsselten Mitteilungen und Berichten vorkommen.
1. Wir empfehlen, dass Sie alle Zertifikatsdateien auf der Seite **Zertifikat erstellt\$1** in ein Verzeichnis herunterladen, in dem Sie sie leicht finden können. Sie müssen diese Dateien installieren, um die Beispielanwendung ausführen zu können.
Wir empfehlen Ihnen, die Dateien in ein `certs` Unterverzeichnis in Ihrem `home` Verzeichnis auf dem Raspberry Pi herunterzuladen und sie jeweils mit einem einfacheren Namen zu benennen, wie in der folgenden Tabelle vorgeschlagen.
**Namen der Zertifikatsdateien**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/shadow-provision-cloud.html)
1. Nachdem Sie das Zertifikat aktiviert haben, mit dem Verbindungen hergestellt werden sollen AWS IoT, wählen Sie **Richtlinie anhängen** und stellen Sie sicher, dass Sie die Richtlinie, die Sie zuvor erstellt haben (z. B.**My\$1Device\$1Shadow\$1policy**), an das Ding anhängen.
Nachdem Sie ein Ding erstellt haben, können Sie sehen, dass Ihre Dingressource in der Liste der Dinge in der AWS IoT Konsole angezeigt wird.
## Schritt 3: Überprüfen Sie die Ergebnisse und die nächsten Schritte
**In diesem Kurs haben Sie Folgendes gelernt:**
+ Einrichten und Konfigurieren des Raspberry Pi-Geräts.
+ Erstellen Sie ein AWS IoT Richtliniendokument, das Ihr Gerät zur Interaktion mit AWS IoT Diensten autorisiert.
+ Erstellen einer Objekt-Ressource und des zugehörigen X.509-Gerätezertifikats und Anhängen des Richtliniendokuments.
**Nächste Schritte**
Sie können jetzt das AWS IoT Geräte-SDK für Python installieren, die `shadow.py` Beispielanwendung ausführen und Device Shadows verwenden, um den Status zu steuern. Weitere Informationen darüber, wie Sie dieses Tutorial ausführen, finden Sie unter [Tutorial: Installation des Geräte-SDK und Ausführen der Beispielanwendung für Geräteschatten](lightbulb-shadow-application.md).
# Tutorial: Installation des Geräte-SDK und Ausführen der Beispielanwendung für Geräteschatten
In diesem Abschnitt wird gezeigt, wie Sie die erforderliche Software und das AWS IoT Device SDK für Python installieren und die `shadow.py` Beispielanwendung ausführen können, um das Shadow-Dokument zu bearbeiten und den Status des Shadows zu kontrollieren.
**In diesem Kurs lernen Sie Folgendes:**
+ Verwenden Sie die installierte Software und AWS IoT das Geräte-SDK für Python, um die Beispiel-App auszuführen.
+ Lernen, wie die Eingabe eines Werts mithilfe der Beispiel-App den gewünschten Wert in der AWS IoT Konsole veröffentlicht.
+ Prüfen der `shadow.py` Beispiel-App an und wie sie das MQTT-Protokoll verwendet, um den Status des Schattens zu aktualisieren.
**Bevor Sie dieses Tutorial ausführen:**
Sie müssen Ihr Raspberry Pi-Gerät eingerichtet AWS-Konto, konfiguriert und eine AWS IoT Sache und Richtlinie erstellt haben, die dem Gerät die Erlaubnis geben, die MQTT-reservierten Themen des Device Shadow-Dienstes zu veröffentlichen und zu abonnieren. Weitere Informationen finden Sie unter [Tutorial: Ihren Raspberry Pi für die Ausführung der Schattenanwendung vorbereiten](create-resources-shadow.md).
Sie müssen auch Git, Python und das AWS IoT Device SDK für Python installiert haben. Dieses Tutorial baut auf den im Tutorial [Verbinden eines Raspberry Pi oder eines anderes Gerätes](connecting-to-existing-device.md) vorgestellten Konzepten auf. Wenn Sie dieses Tutorial noch nicht ausprobiert haben, empfehlen wir Ihnen, die in diesem Tutorial beschriebenen Schritte zu befolgen, um die Zertifikatsdateien und das Geräte-SDK zu installieren, und dann zu diesem Tutorial zurückzukehren, um die `shadow.py` Beispiel-App auszuführen.
**Topics**
+ [Schritt 1: shadow.py-Beispiel-App ausführen](#run-sample-application-shadows)
+ [Schritt 2: Geräte-SDK-Beispiel-App shadow.py prüfen](#review-shadow-sample-code)
+ [Schritt 3: Probleme mit der `shadow.py`-Beispiel-App beheben](#shadow-sample-app-troubleshoot)
+ [Schritt 4: Ergebnisse überprüfen und nächste Schritte](#sample-app-shadow-review)
Für dieses Tutorial brauchen Sie ungefähr 20 Minuten.
## Schritt 1: shadow.py-Beispiel-App ausführen
Bevor Sie die `shadow.py` Beispiel-App ausführen, benötigen Sie zusätzlich zu den Namen und dem Speicherort der installierten Zertifikatsdateien die folgenden Informationen.
**Werte für Anwendungsparameter**
| Parameter | Wo der Wert gefunden werden kann |
| --- | --- |
| your-iot-thing-name | Name der AWS IoT Sache, die Sie zuvor erstellt haben[Schritt 2: Erstellen Sie eine Objekt-Ressource und fügen Sie die Richtlinie dem Objekt hinzu](shadow-provision-cloud.md#create-thing-shadow). Um diesen Wert zu finden, wählen Sie in der [AWS IoT Konsole](https://console.aws.amazon.com/iot/home) **Verwalten** und dann **Objekte** aus. |
| your-iot-endpoint | Der *your-iot-endpoint* Wert hat das Format:`endpoint_id-ats.iot.region.amazonaws.com`, zum Beispiel`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`. So finden Sie diesen Wert: [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/lightbulb-shadow-application.html) |
**Installieren und Ausführen der Beispiel-App**
1. Navigieren Sie zum Verzeichnis der Beispiel-App.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
```
1. Ersetzen Sie im Befehlszeilenfenster *your-iot-endpoint* und *your-iot-thing-name* wie angegeben und führen Sie diesen Befehl aus.
```
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
1. Beachten Sie, dass die Beispiel-App:
1. Stellt eine Verbindung zum AWS IoT-Dienst für Ihr Konto her.
1. `Delta`-Ereignisse und `Update` und `Get`-Antworten abonniert.
1. Sie dazu auffordert, einen gewünschten Wert in das Terminal einzugeben.
1. Die Ausgabe sieht ähnlich aus wie:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow contains reported value 'off'.
Enter desired value:
```
**Anmerkung**
Wenn Sie Probleme beim Ausführen der `shadow.py`-Beispiel-App haben, überprüfen Sie [Schritt 3: Probleme mit der `shadow.py`-Beispiel-App beheben](#shadow-sample-app-troubleshoot). Um zusätzliche Informationen zu erhalten, die Ihnen bei der Behebung des Problems helfen könnten, fügen Sie den `--verbosity debug` Parameter zur Befehlszeile hinzu, sodass die Beispiel-App detaillierte Meldungen darüber anzeigt, was sie tut.
**Geben Sie Werte ein und beobachten Sie die Aktualisierungen im Schattendokument**
Sie können Werte in das Terminal eingeben, um den `desired`-Wert anzugeben, wodurch auch der `reported`-Wert aktualisiert wird. Angenommen, Sie geben die Farbe `yellow` im Terminal ein. Der `reported`-Wert wird ebenfalls auf die Farbe `yellow` aktualisiert. Im Folgenden werden die im Terminal angezeigten Meldungen angezeigt:
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Wenn Sie diese Aktualisierungsanforderung veröffentlichen, AWS IoT wird ein klassischer Standard-Shadow für die Ding-Ressource erstellt. Sie können die Aktualisierungsanforderung beobachten, die Sie für die `desired` Werte `reported` und in der AWS IoT Konsole veröffentlicht haben, indem Sie sich das Shadow-Dokument für die von Ihnen erstellte Ding-Ressource ansehen (z. B.`My_light_bulb`). Um das Update im Schattendokument zu sehen:
1. Wählen Sie in der AWS IoT Konsole „**Verwalten**“ und anschließend „**Dinge**“ aus.
1. Wählen Sie in der angezeigten Liste das Objekt aus, das Sie erstellt haben, wählen Sie **Schatten** und anschließend **Klassischer Schatten**.
Das Schattendokument sollte wie folgt aussehen und für die `reported`- und `desired`-Werte die Farbe `yellow` anzeigen. Sie sehen diese Werte im Abschnitt **Schattenstatus** des Dokuments.
```
{
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
}
```
Sie sehen auch einen Abschnitt mit den **Metadaten**, der die Zeitstempelinformationen und die Versionsnummer der Anfrage enthält.
Sie können die Version des Statusdokuments verwenden, um sicherzustellen, dass Sie die neueste Version eines Geräteschattendokuments aktualisieren. Wenn Sie eine weitere Aktualisierungsanfrage senden, wird die Versionsnummer um 1 erhöht. Geben Sie bei einer Aktualisierungsanfrage eine Version an, lehnt der Service die Anfrage mit einem Konflikt-Antwortcode HTTP 409 ab, wenn die aktuelle Version des Statusdokuments nicht der angegebenen Version entspricht.
```
{
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620156893
}
}
},
"version": 10
}
```
Um mehr über das Schattendokument zu erfahren und Änderungen an den Statusinformationen einzusehen, fahren Sie mit dem nächsten Tutorial [Tutorial: Interaktion mit Geräteschatten mithilfe der Beispiel-App und des MQTT-Testclients](interact-lights-device-shadows.md) fort, wie im [Schritt 4: Ergebnisse überprüfen und nächste Schritte](#sample-app-shadow-review) Abschnitt dieses Tutorials beschrieben. Optional können Sie im folgenden Abschnitt auch mehr über den `shadow.py`-Beispielcode und dessen Verwendung des MQTT-Protokolls erfahren.
## Schritt 2: Geräte-SDK-Beispiel-App shadow.py prüfen
In diesem Abschnitt wird die `shadow.py`-Beispiel-App aus dem **AWS IoT -Geräte-SDK v2 für Python** beschrieben, die in diesem Tutorial verwendet wird. Hier werden wir uns ansehen, wie es AWS IoT Core mithilfe des MQTT- und MQTT-über-WSS-Protokolls eine Verbindung herstellt. Die [AWS Common Runtime (AWS-CRT)](https://github.com/awslabs/aws-crt-python#aws-crt-python) -Bibliothek bietet Unterstützung für Low-Level-Kommunikationsprotokolle und ist im AWS IoT Device SDK v2 für Python enthalten.
Dieses Tutorial verwendet zwar MQTT und MQTT über WSS, AWS IoT unterstützt aber Geräte, die HTTPS-Anfragen veröffentlichen. Ein Beispiel für ein Python-Programm, das eine HTTP-Nachricht von einem Gerät sendet, finden Sie im [HTTPS-Codebeispiel](http.md#codeexample) unter Verwendung der Python `requests`-Bibliothek.
Informationen darüber, wie Sie eine fundierte Entscheidung darüber treffen können, welches Protokoll Sie für die Kommunikation mit Ihrem Gerät verwenden möchten, finden Sie unter [Wählen Sie ein Anwendungsprotokoll für Ihre Gerätekommunikation](protocols.md#protocol-selection).
**MQTT**
Das `shadow.py` Beispiel ruft `mtls_from_path` (hier gezeigt) in [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py), um AWS IoT Core mithilfe des MQTT-Protokolls eine Verbindung herzustellen. `mtls_from_path`verwendet X.509-Zertifikate und TLS v1.2 zur Authentifizierung des Geräts. Die AWS-CRT-Bibliothek verarbeitet die untergeordneten Details dieser Verbindung.
```
mqtt_connection = mqtt_connection_builder.mtls_from_path(
endpoint=args.endpoint,
cert_filepath=args.cert,
pri_key_filepath=args.key,
ca_filepath=args.ca_file,
client_bootstrap=client_bootstrap,
on_connection_interrupted=on_connection_interrupted,
on_connection_resumed=on_connection_resumed,
client_id=args.client_id,
clean_session=False,
keep_alive_secs=6
)
```
+ `endpoint`ist Ihr AWS IoT Endpunkt, den Sie über die Befehlszeile eingegeben haben, und `client_id` ist die ID, die dieses Gerät in der eindeutig identifiziert. AWS-Region
+ `cert_filepath`, `pri_key_filepath` und `ca_filepath` sind die Pfade zu den Zertifikats- und privaten Schlüsseldateien des Geräts sowie zur Root-CA-Datei.
+ `client_bootstrap` ist das allgemeine Runtime-Objekt, das Socket-Kommunikationsaktivitäten verarbeitet und vor dem Aufruf von `mqtt_connection_builder.mtls_from_path` instanziiert wird.
+ `on_connection_interrupted` und `on_connection_resumed` sind Callback-Funktionen, die aufgerufen werden, wenn die Verbindung des Geräts unterbrochen und wieder aufgenommen wird.
+ `clean_session` gibt an, ob eine neue, persistente Sitzung gestartet werden soll oder ob, falls eine vorhanden ist, die Verbindung zu einer bestehenden wiederhergestellt werden soll. `keep_alive_secs` ist der Keep-Alive-Wert in Sekunden, der in der `CONNECT`-Anfrage gesendet werden soll. In diesem Intervall wird automatisch ein Ping gesendet. Der Server geht davon aus, dass die Verbindung unterbrochen ist, wenn er nach dem 1,5-fachen dieses Werts keinen Ping erhält.
Das `shadow.py` Beispiel ruft auch `websockets_with_default_aws_signing` in [https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py](https://github.com/awslabs/aws-crt-python/blob/89207bcf1387177034e02fe29e8e469ca45e39b7/awscrt/awsiot_mqtt_connection_builder.py) auf, um mithilfe des MQTT-Protokolls über WSS eine Verbindung zu AWS IoT Core herzustellen. MQTT über WSS verwendet ebenfalls dieselben Parameter wie MQTT und verwendet diese zusätzlichen Parameter:
+ `region`ist die AWS Signaturregion, die von der Signature V4-Authentifizierung verwendet `credentials_provider` wird, und sind die AWS Anmeldeinformationen, die für die Authentifizierung bereitgestellt werden. Die Region wird von der Befehlszeile aus übergeben, und das `credentials_provider`-Objekt wird unmittelbar vor dem Aufruf von `mqtt_connection_builder.websockets_with_default_aws_signing` instanziiert.
+ `websocket_proxy_options` sind die HTTP-Proxyoptionen, wenn ein Proxyhost verwendet wird. In der `shadow.py` Beispiel-App wird dieser Wert unmittelbar vor dem Aufruf von `mqtt_connection_builder.websockets_with_default_aws_signing` instanziiert.
**Abonnieren von Shadow-Themen und -Ereignissen**
Das `shadow.py`-Beispiel versucht, eine Verbindung herzustellen, und wartet, bis die Verbindung vollständig hergestellt ist. Wenn es nicht verbunden ist, werden Befehle in die Warteschlange gestellt. Sobald die Verbindung hergestellt ist, abonniert das Beispiel Delta-Ereignisse und Aktualisierungs- und Abrufnachrichten und veröffentlicht Nachrichten mit einer QoS-Stufe (Quality of Service) von 1 (`mqtt.QoS.AT_LEAST_ONCE`).
Wenn ein Gerät eine Nachricht mit QoS Level 1 abonniert, speichert der Message Broker die Nachrichten, die das Gerät abonniert hat, bis sie an das Gerät gesendet werden können. Der Message Broker sendet die Nachrichten erneut, bis er eine `PUBACK`-Antwort vom Gerät erhält.
Weitere Informationen zum MQTT-Protokoll finden Sie unter [Ansehen des MQTT-Protokolls](sdk-tutorials.md#sdk-tutorials-mqtt-review) und [MQTT](mqtt.md).
Weitere Informationen zur Verwendung von MQTT, MQTT über WSS, persistente Sitzungen und QoS-Stufen, die in diesem Tutorial verwendet werden, finden Sie unter [Ansehen der Beispiel-App „pubsub.py“ des Device SDK](sdk-tutorials.md#sdk-tutorials-explore-sample).
## Schritt 3: Probleme mit der `shadow.py`-Beispiel-App beheben
Wenn Sie die `shadow.py`-Beispiel-App ausführen, sollten im Terminal einige Meldungen und eine Aufforderung zur Eingabe eines `desired`-Werts angezeigt werden. Wenn das Programm einen Fehler ausgibt, können Sie zum Debuggen des Fehlers zunächst überprüfen, ob Sie den richtigen Befehl für Ihr System ausgeführt haben.
In einigen Fällen weist die Fehlermeldung möglicherweise auf Verbindungsprobleme hin und sieht ähnlich aus wie: `Host name was invalid for dns resolution` oder `Connection was closed unexpectedly`. In solchen Fällen können Sie Folgendes überprüfen:
+
**Die Endpunktadresse im Befehl**
Das `endpoint`-Argument in dem Befehl, den Sie zum Ausführen der Beispiel-App eingegeben haben (z. B. `a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com`). Diesen Wert können Sie auch in der **AWS IoT Konsole** prüfen.
Um zu überprüfen, ob Sie den richtigen Wert verwendet haben:
1. Wählen Sie in der **AWS IoT -Konsole** **Verwalten** und danach **Objekte**.
1. Wählen Sie das Objekt aus, das Sie für Ihre Beispiel-App erstellt haben (z. B. **My\$1Light\$1Bulb**), und wählen Sie dann **Interagieren**.
Ihr Endpunkt wird im Abschnitt **HTTPS** auf der Seite mit den Objekt-Details angezeigt. Sie sollten auch eine Meldung sehen, die besagt: `This thing already appears to be connected.`
+
**Aktivierung des Zertifikats überprüfen**
Zertifikate authentifizieren Ihr Gerät mit AWS IoT Core.
Um zu überprüfen, ob Ihr Zertifikat aktiv ist:
1. Wählen Sie in der **AWS IoT -Konsole** **Verwalten** und danach **Objekte**.
1. Wählen Sie das Objekt aus, das Sie für Ihre Beispiel-App erstellt haben (z. B. **My\$1Light\$1Bulb**), und wählen Sie dann **Sicherheit**.
1. Wählen Sie das Zertifikat aus und wählen Sie dann auf der Detailseite des Zertifikats die Option „Zertifikat auswählen“ und dann auf der Detailseite des Zertifikats die Option **Aktionen** aus.
Wenn in der Dropdownliste **Aktivieren** nicht verfügbar ist und Sie nur **Deaktivieren** auswählen können, ist Ihr Zertifikat aktiv. Wenn nicht, wählen Sie **Aktivieren** und führen Sie das Beispielprogramm erneut aus.
Wenn das Programm immer noch nicht ausgeführt wird, überprüfen Sie die Namen der Zertifikatsdateien im `certs`-Ordner.
+
**Überprüfen der mit der Objekt-Ressource verknüpften Richtlinie**
Zertifikate authentifizieren zwar Ihr Gerät, aber AWS IoT Richtlinien gestatten es dem Gerät, bestimmte AWS IoT Vorgänge auszuführen, wie z. B. das Abonnieren oder Veröffentlichen von MQTT-Themen, die für MQTT reserviert sind.
Um zu überprüfen, ob die richtige Richtlinie angehängt ist:
1. Suchen Sie das Zertifikat wie zuvor beschrieben und wählen Sie dann **Richtlinien** aus.
1. Wählen Sie die angezeigte Richtlinie aus und überprüfen Sie, ob sie die Aktionen `connect`, `subscribe`, `receive` und `publish` beschreibt, die dem Gerät die Erlaubnis geben, die reservierten MQTT-Themen zu veröffentlichen und zu abonnieren.
Eine Beispielrichtlinie finden Sie unter [Schritt 1: Erstellen Sie eine AWS IoT Richtlinie für den Device Shadow](shadow-provision-cloud.md#create-policy-shadow).
Wenn Ihnen Fehlermeldungen angezeigt werden, die auf Probleme beim Herstellen einer Verbindung hinweisen AWS IoT, kann dies an den Berechtigungen liegen, die Sie für die Richtlinie verwenden. In diesem Fall empfehlen wir, mit einer Richtlinie zu beginnen, die vollen Zugriff auf AWS IoT Ressourcen gewährt, und dann das Beispielprogramm erneut auszuführen. Sie können entweder die aktuelle Richtlinie bearbeiten oder die aktuelle Richtlinie auswählen, **Trennen** auswählen und dann eine weitere Richtlinie erstellen, die vollen Zugriff gewährt, und diese an Ihre Objekt-Ressource anhängen. Sie können die Richtlinie später nur auf die Aktionen und Richtlinien beschränken, die Sie zur Ausführung des Programms benötigen.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:*"
],
"Resource": "*"
}
]
}
```
+
**Überprüfen der Installation Ihres Geräte-SDKs**
Wenn das Programm immer noch nicht ausgeführt wird, können Sie das Geräte-SDK erneut installieren, um sicherzustellen, dass Ihre SDK-Installation vollständig und korrekt ist.
## Schritt 4: Ergebnisse überprüfen und nächste Schritte
**In diesem Kurs haben Sie gelernt, wie Sie:**
+ Installieren Sie die erforderliche Software, Tools und das AWS IoT Geräte-SDK für Python.
+ Die Beispiel-App `shadow.py` das MQTT-Protokoll zum Abrufen und Aktualisieren des aktuellen Status des Schattens verwendet.
+ Führen Sie die Beispiel-App für Device Shadows aus und beobachten Sie die Aktualisierung des Shadow-Dokuments in der AWS IoT Konsole. Sie haben darüber hinaus gelernt, Probleme und Fehler bei der Ausführung des Programms zu beheben.
**Nächste Schritte**
Sie können jetzt die `shadow.py`-Beispielanwendung ausführen und Geräteschatten verwenden, um den Status zu kontrollieren. Sie können die Aktualisierungen des Schattendokuments in der AWS IoT -Konsole verfolgen und Delta-Ereignisse beobachten, auf die die Beispiel-App reagiert. Mit dem MQTT-Testclient können Sie die reservierten Schattenthemen abonnieren und die Nachrichten beobachten, die die Themen bei der Ausführung des Beispielprogramms erhalten. Weitere Informationen darüber, wie Sie dieses Tutorial ausführen, finden Sie unter [Tutorial: Interaktion mit Geräteschatten mithilfe der Beispiel-App und des MQTT-Testclients](interact-lights-device-shadows.md).
# Tutorial: Interaktion mit Geräteschatten mithilfe der Beispiel-App und des MQTT-Testclients
Um mit der `shadow.py`-Beispiel-App zu interagieren, geben Sie im Terminal einen Wert für den `desired`-Wert ein. Sie können beispielsweise Farben angeben, die den Ampeln ähneln und AWS IoT auf die Anfrage reagieren und die gemeldeten Werte aktualisieren.
**In diesem Kurs lernen Sie Folgendes:**
+ Verwenden der `shadow.py`-Beispiel-App, um die gewünschten Status anzugeben und den aktuellen Status des Schattens zu aktualisieren.
+ Bearbeiten Sie das Schattendokument, um Delta-Ereignisse und die Reaktion der `shadow.py`-Beispiel-App auf diese Ereignisse zu beobachten.
+ Verwenden Sie den MQTT-Testclient, um Schattenthemen zu abonnieren und Updates zu beobachten, wenn Sie das Beispielprogramm ausführen.
**Für dieses Tutorial benötigen Sie Folgendes:**
Richten Sie Ihr Raspberry Pi-Gerät ein AWS-Konto, konfigurieren Sie es und erstellen Sie eine AWS IoT Sache und Richtlinie. Sie müssen auch die erforderliche Software, das Geräte-SDK und die Zertifikatsdateien installiert haben und das Beispielprogramm im Terminal ausführen. Weitere Informationen finden Sie in den vorherigen Tutorials [Tutorial: Ihren Raspberry Pi für die Ausführung der Schattenanwendung vorbereiten](create-resources-shadow.md) und [Schritt 1: shadow.py-Beispiel-App ausführen](lightbulb-shadow-application.md#run-sample-application-shadows). Sie müssen diese Tutorials abschließen, wenn das noch nicht geschehen ist.
**Topics**
+ [Schritt 1: Die gewünschten und gemeldeten Werte mithilfe der `shadow.py`-Beispiel-App aktualisieren](#update-desired-shadow-sample)
+ [Schritt 2: Nachrichten aus der `shadow.py`-Beispiel-App im MQTT-Testclient anzeigen](#shadow-sample-view-msg)
+ [Schritt 3: Fehlerbehebung bei Interaktionen mit Geräteschatten](#shadow-observe-messages-troubleshoot)
+ [Schritt 4: Überprüfen der Ergebnisse und nächste Schritte](#sample-shadow-review)
Für dieses Tutorial brauchen Sie ungefähr 45 Minuten.
## Schritt 1: Die gewünschten und gemeldeten Werte mithilfe der `shadow.py`-Beispiel-App aktualisieren
Im vorherigen Tutorial haben Sie gelernt[Schritt 1: shadow.py-Beispiel-App ausführen](lightbulb-shadow-application.md#run-sample-application-shadows), wie Sie eine Nachricht beobachten können, die im Shadow-Dokument in der AWS IoT Konsole veröffentlicht wurde, wenn Sie einen gewünschten Wert eingeben, wie im Abschnitt beschrieben[Tutorial: Installation des Geräte-SDK und Ausführen der Beispielanwendung für Geräteschatten](lightbulb-shadow-application.md).
Im vorherigen Beispiel haben wir die gewünschte Farbe auf `yellow` eingestellt. Nachdem Sie jeden Wert eingegeben haben, fordert Sie das Terminal auf, einen anderen `desired`-Wert einzugeben. Wenn Sie erneut denselben Wert eingeben (`yellow`), erkennt die App dies und fordert Sie auf, einen neuen `desired`-Wert einzugeben.
```
Enter desired value:
yellow
Local value is already 'yellow'.
Enter desired value:
```
Nehmen wir nun an, dass Sie die Farbe eingeben`green`. AWS IoT antwortet auf die Anfrage und aktualisiert den `reported` Wert auf`green`. Auf diese Weise erfolgt die Aktualisierung, wenn sich der `desired`-Status vom `reported`-Status unterscheidet, was zu einem Delta führt.
**So simuliert die `shadow.py`-Beispiel-App Geräteschatten-Interaktionen:**
1. Geben Sie einen `desired`-Wert (sagen wir `yellow`) in das Terminal ein, um den gewünschten Status zu veröffentlichen.
1. Da sich der `desired`-Status vom `reported`-Status unterscheidet (sagen wir die Farbe `green`), tritt ein Delta auf, und die App, die das Delta abonniert hat, empfängt diese Nachricht.
1. Die App reagiert auf die Nachricht und aktualisiert ihren Status auf den `desired`-Wert `yellow`.
1. Die App veröffentlicht dann eine Aktualisierungsnachricht mit dem neuen gemeldeten Wert des Gerätestatus, `yellow`.
Im Folgenden werden die im Terminal angezeigten Meldungen angezeigt, aus denen hervorgeht, wie die Aktualisierungsanforderung veröffentlicht wird.
```
Enter desired value:
green
Changed local shadow value to 'green'.
Updating reported shadow value to 'green'...
Update request published.
Finished updating reported shadow value to 'green'.
```
In der AWS IoT Konsole spiegelt das Shadow-Dokument den aktualisierten Wert von sowohl `green` für die `reported` `desired` Felder als auch wider, und die Versionsnummer wird um 1 erhöht. Wenn die vorherige Versionsnummer beispielsweise als 10 angezeigt wurde, wird die aktuelle Versionsnummer als 11 angezeigt.
**Anmerkung**
Durch das Löschen eines Schattens wird seine Versionsnummer nicht sofort auf null zurückgesetzt. Sie werden feststellen, dass die Schattenversion um 1 erhöht wird, wenn Sie eine Aktualisierungsanforderung veröffentlichen oder einen anderen Schatten mit demselben Namen erstellen.
**Das Schattendokument berbeiten, um Delta-Ereignisse zu beobachten**
Die `shadow.py`-Beispiel-App hat auch `delta`-Ereignisse abonniert und reagiert, wenn sich der `desired`-Wert ändert. Sie können den `desired`-Wert beispielsweise in die Farbe `red` ändern. Bearbeiten Sie dazu in der AWS IoT Konsole das Shadow-Dokument, indem Sie auf **Bearbeiten** klicken und dann den `desired` Wert `red` in der JSON-Datei auf festlegen, während Sie den `reported` Wert auf `green` beibehalten. Bevor Sie die Änderungen speichern, lassen Sie das Terminal auf dem Raspberry Pi geöffnet, da im Terminal Meldungen angezeigt werden, wenn die Änderung erfolgt.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Nachdem Sie den neuen Wert gespeichert haben, reagiert die `shadow.py`-Beispiel-App auf diese Änderung und zeigt im Terminal Meldungen an, die auf das Delta hinweisen. Sie sollten dann die folgenden Meldungen unter der Aufforderung zur Eingabe des `desired`-Werts sehen.
```
Enter desired value:
Received shadow delta event.
Delta reports that desired value is 'red'. Changing local value...
Changed local shadow value to 'red'.
Updating reported shadow value to 'red'...
Finished updating reported shadow value to 'red'.
Enter desired value:
Update request published.
Finished updating reported shadow value to 'red'.
```
## Schritt 2: Nachrichten aus der `shadow.py`-Beispiel-App im MQTT-Testclient anzeigen
Sie können den **MQTT-Testclient** in der **AWS IoT Konsole** verwenden, um MQTT-Nachrichten zu überwachen, die zu Ihrem AWS-Kontoübermittelt werden. Wenn Sie reservierte MQTT-Themen abonnieren, die vom Geräteschattendienst verwendet werden, können Sie die Nachrichten beobachten, die von den Themen beim Ausführen der Beispiel-App empfangen wurden.
Wenn Sie den MQTT-Testclient noch nicht verwendet haben, können Sie sich [MQTT-Nachrichten mit dem AWS IoT MQTT-Client anzeigen](view-mqtt-messages.md) ansehen. Auf diese Weise lernen Sie, wie Sie den **MQTT-Testclient** in der **AWS IoT Konsole** verwenden, um MQTT-Nachrichten anzuzeigen, während sie durch den Message Broker laufen.
1.
**Öffnen des MQTT-Testclients**
Öffnen Sie den [MQTT-Testclient in der AWS IoT -Konsole](https://console.aws.amazon.com//iot/home#/test) in einem neuen Fenster, damit Sie die von den MQTT-Themen empfangenen Nachrichten beobachten können, ohne die Konfiguration Ihres MQTT-Testclients zu verlieren. Der MQTT-Testclient speichert keine Abonnements oder Nachrichtenprotokolle, wenn Sie ihn verlassen, um zu einer anderen Seite in der Konsole zu wechseln. In diesem Abschnitt des Tutorials können Sie das Shadow-Dokument Ihres Dings und AWS IoT den MQTT-Testclient in separaten Fenstern öffnen, um die Interaktion mit Device Shadows einfacher beobachten zu können.
1.
**Abonnieren der reservierten MQTT-Schatten-Themen**
Sie können den MQTT-Testclient verwenden, um die Namen der reservierten MQTT-Themen von Geräteschatten einzugeben und sie zu abonnieren, um Updates zu erhalten, wenn Sie die `shadow.py`-Beispiel-App ausführen. So abonnieren Sie MQTT-Themen:
1. Wählen Sie im **MQTT-Testclient** in der **AWS IoT Konsole** die Option **Thema abonnieren** aus.
1. Geben Sie im Abschnitt **Themenfilter Folgendes** ein: **\$1aws/things/ *thingname* /shadow/update/** \$1. Hier ist `thingname` der Name der Objekt-Ressource, die Sie zuvor erstellt haben (z. B. `My_light_bulb`).
1. Behalten Sie die Standardwerte für die zusätzlichen Konfigurationseinstellungen bei und wählen Sie dann **Abonnieren**.
Durch die Verwendung des Platzhalters **\$1** im Themenabonnement können Sie mehrere MQTT-Themen gleichzeitig abonnieren und alle Nachrichten, die zwischen dem Gerät und seinem Schatten ausgetauscht werden, in einem einzigen Fenster beobachten. Weitere Informationen über Platzhalterzeichen und ihre Verwendung finden Sie unter [MQTT-Themen](topics.md).
1.
**Ausführen des `shadow.py`-Beispielprogramms und Beobachten der Meldungen**
Wenn Sie in Ihrem Befehlszeilenfenster des Raspberry Pi das Programm getrennt haben, führen Sie die Beispiel-App erneut aus und sehen Sie sich die Meldungen im **MQTT-Testclient** in der **AWS IoT Konsole** an.
1. Geben Sie den folgenden Befehl ein, um das Beispielprogramm neu zu starten. Ersetzen Sie *your-iot-thing-name* und durch die Namen des Objekts, das Sie zuvor erstellt haben (z. B.), und durch den AWS IoT Endpunkt, `My_light_bulb` der *your-iot-endpoint* mit dem Gerät interagieren soll.
```
cd ~/aws-iot-device-sdk-python-v2/samples/service-clients
python3 shadow.py --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint --thing_name your-iot-thing-name
```
Die `shadow.py`-Beispiel-App wird dann ausgeführt und ruft den aktuellen Schattenstatus ab. Wenn Sie den Schatten oder den aktuellen Status gelöscht haben, setzt das Programm den aktuellen Wert auf `off` und fordert Sie dann auf, einen `desired`-Wert einzugeben.
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to Delta events...
Subscribing to Update responses...
Subscribing to Get responses...
Requesting current shadow state...
Launching thread to read user input...
Finished getting initial shadow state.
Shadow document lacks 'color' property. Setting defaults...
Changed local shadow value to 'off'.
Updating reported shadow value to 'off'...
Update request published.
Finished updating reported shadow value to 'off'...
Enter desired value:
```
Wenn das Programm jedoch ausgeführt wurde und Sie es neu gestartet haben, wird der letzte Farbwert im Terminal gemeldet. **Im MQTT-Testclient werden Sie ein Update zu den Themen **\$1aws/things/ /shadow/get und *thingname* \$1aws/things/**/sehen. *thingname* shadow/get/accepted**
Nehmen wir an, die zuletzt gemeldete Farbe war `green`. Im **Folgenden *thingname* wird shadow/get/accepted** der Inhalt der JSON-Datei \$1aws/things//gezeigt.
```
{
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
},
"reported": {
"welcome": {
"timestamp": 1620156892
},
"color": {
"timestamp": 1620161643
}
}
},
"version": 10,
"timestamp": 1620173908
}
```
1. Geben Sie einen `desired`-Wert in das Terminal ein, z. B. `yellow`. Die `shadow.py`-Beispiel-App reagiert und zeigt im Terminal die folgenden Meldungen an, die die Änderung des `reported`-Werts auf `yellow` zeigen.
```
Enter desired value:
yellow
Changed local shadow value to 'yellow'.
Updating reported shadow value to 'yellow'...
Update request published.
Finished updating reported shadow value to 'yellow'.
```
Im **MQTT-Testclient** in der **AWS IoT Konsole** sehen Sie unter **Abonnements**, dass die folgenden Themen eine Nachricht erhalten haben:
+ **\$1aws/things/ *thingname* /shadow/update: zeigt, dass sich beide Werte in der Farbe** ändern. `desired` `updated` `yellow`
+ **\$1aws/things/*thingname*/shadow/update/accepted**: zeigt die aktuellen Werte der Zustände und deren Metadaten und Versionsinformationen an. `desired` `reported`
+ **\$1aws/things/*thingname*/shadow/update/documents**: zeigt die vorherigen und aktuellen Werte der Zustände und deren Metadaten und Versionsinformationen an. `desired` `reported`
Da das Dokument **\$1aws/things/*thingname*/shadow/update/documents**auch Informationen enthält, die in den anderen beiden Themen enthalten sind, können wir es überprüfen, um die Statusinformationen einzusehen. Der vorherige Status zeigt den auf `green` festgelegten Wert, seine Metadaten und Versionsinformationen sowie den aktuellen Status `yellow`, auf den der gemeldete Wert aktualisiert wurde.
```
{
"previous": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "green"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297898
}
}
},
"version": 10
},
"current": {
"state": {
"desired": {
"welcome": "aws-iot",
"color": "yellow"
},
"reported": {
"welcome": "aws-iot",
"color": "yellow"
}
},
"metadata": {
"desired": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
},
"reported": {
"welcome": {
"timestamp": 1617297888
},
"color": {
"timestamp": 1617297904
}
}
},
"version": 11
},
"timestamp": 1617297904
}
```
1. Wenn Sie nun einen anderen `desired`-Wert eingeben, sehen Sie weitere Änderungen an den `reported`-Werten und Nachrichtenaktualisierungen, die in diesen Themen eingegangen sind. Die Versionsnummer wird ebenfalls um 1 erhöht. Wenn Sie beispielsweise den Wert `green` eingeben, meldet der vorherige Status den Wert `yellow` und der aktuelle Status meldet den Wert `green`.
1.
**Bearbeiten des Schattendokuments, um Delta-Ereignisse zu beobachten**
Um Änderungen am Delta-Thema zu beobachten, bearbeiten Sie das Schattendokument in der AWS IoT -Konsole. Sie können den `desired`-Wert beispielsweise in die Farbe `red` ändern. Wählen Sie dazu in der AWS IoT Konsole **Bearbeiten** und setzen Sie dann den `desired` Wert im JSON-Format auf Rot, während Sie den Wert auf beibehalten. `reported` `green` Lassen Sie das Terminal geöffnet, bevor Sie die Änderung speichern, da die Deltameldung im Terminal angezeigt wird.
```
{
"desired": {
"welcome": "aws-iot",
"color": "red"
},
"reported": {
"welcome": "aws-iot",
"color": "green"
}
}
```
Die `shadow.py`-Beispiel-App reagiert auf diese Änderung und zeigt im Terminal Meldungen an, die auf das Delta hinweisen. Im MQTT-Testclient haben die `update`-Themen eine Nachricht erhalten, die Änderungen an den `desired`- und `reported`-Werten anzeigt.
Sie sehen auch, dass das Thema **\$1aws/things//*thingname***eine Nachricht erhalten hat. shadow/update/delta Um die Nachricht zu sehen, wählen Sie dieses Thema aus, das unter **Abonnements** aufgeführt ist.
```
{
"version": 13,
"timestamp": 1617318480,
"state": {
"color": "red"
},
"metadata": {
"color": {
"timestamp": 1617318480
}
}
}
```
## Schritt 3: Fehlerbehebung bei Interaktionen mit Geräteschatten
Wenn Sie die Schatten-Beispiel-App ausführen, können Probleme bei der Beobachtung von Interaktionen mit dem Geräteschattendienst auftreten.
Wenn das Programm erfolgreich ausgeführt wird und Sie zur Eingabe eines `desired`-Werts auffordert werden, sollten Sie in der Lage sein, die Geräteschatten-Interaktionen mithilfe des Schattendokuments und des MQTT-Testclients wie zuvor beschrieben zu beobachten. Wenn Sie die Interaktionen jedoch nicht sehen können, können Sie Folgendes überprüfen:
+
**Überprüfe den Namen des Dings und seinen Schatten in der Konsole AWS IoT**
Wenn Sie die Meldungen im Schattendokument nicht sehen, überprüfen Sie den Befehl und stellen Sie sicher, dass er mit dem Namen des Objekts in der **AWS IoT Konsole** übereinstimmt. Sie können auch überprüfen, ob Sie einen klassischen Schatten haben, indem Sie Ihre Objekt-Ressource und dann **Schatten** auswählen. Dieses Tutorial konzentriert sich hauptsächlich auf Interaktionen mit dem klassischen Schatten.
Sie können auch überprüfen, ob das von Ihnen verwendete Gerät mit dem Internet verbunden ist. Wählen Sie in der **AWS IoT Konsole** das Objekt aus, das Sie zuvor erstellt haben, und wählen Sie dann **Interagieren** aus. Auf der Seite mit den Objekt-Details solltest Sie hier eine Meldung sehen, die besagt: `This thing already appears to be connected.`
+
**Überprüfen der reservierten abonnierten MQTT-Themen**
Wenn Sie die Nachrichten nicht im MQTT-Testclient sehen, überprüfen Sie, ob die Themen, die Sie abonniert haben, richtig formatiert sind. MQTT Device Shadow-Themen haben das Format **\$1aws/things/ *thingname* /shadow/** und können diesem Format folgen, oder `delete` folgen, je nachdem `update``get`, welche Aktionen Sie mit dem Shadow ausführen möchten. **Dieses Tutorial verwendet das Thema **\$1aws/things/ *thingname* /shadow/ \$1**. Stellen Sie also sicher, dass Sie es richtig eingegeben haben, wenn Sie das Thema im Themenfilterbereich des Testclients abonniert haben.**
Achten Sie bei der Eingabe des Themennamens darauf, dass der mit dem Namen der Sache *thingname* übereinstimmt, die Sie zuvor erstellt haben. AWS IoT Sie können auch zusätzliche MQTT-Themen abonnieren, um zu sehen, ob ein Update erfolgreich durchgeführt wurde. Sie können beispielsweise das Thema **\$1aws/things/*thingname*/**abonnieren, um eine Nachricht shadow/update/rejected zu erhalten, wenn eine Aktualisierungsanforderung fehlschlägt, sodass Sie Verbindungsprobleme debuggen können. Weitere Informationen zu den reservierten Themen finden Sie unter [Schatten-Themen](reserved-topics.md#reserved-topics-shadow) und [MQTT-Themen für Geräteschatten](device-shadow-mqtt.md).
## Schritt 4: Überprüfen der Ergebnisse und nächste Schritte
**In diesem Kurs haben Sie gelernt, wie Sie:**
+ Die `shadow.py`-Beispiel-App verwenden, um die gewünschten Status anzugeben und den aktuellen Status des Schattens zu aktualisieren.
+ Bearbeiten Sie das Schattendokument, um Delta-Ereignisse und die Reaktion der `shadow.py`-Beispiel-App auf diese Ereignisse zu beobachten.
+ Verwenden Sie den MQTT-Testclient, um Schattenthemen zu abonnieren und Updates zu beobachten, wenn Sie das Beispielprogramm ausführen.
**Nächste Schritte**
Sie können zusätzliche reservierte MQTT-Themen abonnieren, um Aktualisierungen der Schattenanwendung zu beobachten. Wenn Sie beispielsweise nur das Thema **\$1aws/things/*thingname*/**abonnieren, werden Ihnen nur die aktuellen Statusinformationen angezeigtshadow/update/accepted, wenn ein Update erfolgreich durchgeführt wurde.
Sie können auch zusätzliche Schattenthemen abonnieren, um Probleme zu beheben oder mehr über die Geräteschatten-Interaktionen zu erfahren sowie mögliche Probleme mit den Geräteschatten-Interaktionen zu debuggen. Weitere Informationen erhalten Sie unter [Schatten-Themen](reserved-topics.md#reserved-topics-shadow) und [MQTT-Themen für Geräteschatten](device-shadow-mqtt.md).
Sie können Ihre Anwendung auch erweitern, indem Sie Named Shadows verwenden oder zusätzliche Hardware verwenden, die mit dem Raspberry Pi verbunden ist, LEDs und Zustandsänderungen anhand von Nachrichten beobachten, die vom Terminal gesendet werden.
Weitere Informationen zum Geräteschattendienst und zur Verwendung des Dienstes in Geräten, Apps und Diensten finden Sie unter [AWS IoT Device Shadow-Dienst](iot-device-shadows.md), [Verwenden von Schatten in Geräten](device-shadow-comms-device.md) und [Verwenden von Schatten in Apps und Services](device-shadow-comms-app.md).
# Tutorial: Erstellen eines benutzerdefinierten Autorisierers für AWS IoT Core
Dieses Tutorial zeigt die Schritte zum Erstellen, Validieren und Verwenden einer benutzerdefinierten Authentifizierung mithilfe von AWS CLI. Optional können Sie mithilfe dieses Tutorials Postman verwenden, um mithilfe der HTTP Publish API Daten an AWS IoT Core zu senden.
In diesem Tutorial erfahren Sie, wie Sie eine exemplarische Lambda-Funktion erstellen, die die Autorisierungs- und Authentifizierungslogik implementiert, und einen benutzerdefinierten Autorisierer mithilfe des **create-authorizer**-Aufrufs mit aktivierter Tokensignatur. Der Autorisierer wird dann mit dem validiert**test-invoke-authorizer**, und schließlich können Sie Daten an ein MQTT-Testthema senden, AWS IoT Core indem Sie die HTTP Publish API verwenden. Die Beispielanforderung spezifiziert den Authorizer, der aufgerufen werden soll, mithilfe des `x-amz-customauthorizer-name` Headers und übergibt die Anforderungsheader. token-key-name `x-amz-customauthorizer-signature`
**Was Sie in diesem Tutorial lernen werden:**
+ So erstellen Sie eine Lambda-Funktion als benutzerdefinierten Autorisierer-Handler
+ Wie erstelle ich einen benutzerdefinierten Autorisierer mit aktivierter Tokensignatur AWS CLI
+ So testen Sie Ihren benutzerdefinierten Autorisierer mit dem Befehl **test-invoke-authorizer**
+ So veröffentlichen Sie ein MQTT-Thema mit [Postman](https://www.postman.com/) und validieren die Anfrage mit Ihrem benutzerdefinierten Autorisierer
Für dieses Tutorial brauchen Sie ungefähr 60 Minuten.
**Topics**
+ [Schritt 1: Erstellen einer Lambda-Funktion für Ihren benutzerdefinierten Autorisierer](#custom-auth-tutorial-define)
+ [Schritt 2: Erstellen eines öffentlichen und eines privaten Schlüsselpaars für Ihren benutzerdefinierten Autorisierer](#custom-auth-tutorial-keys)
+ [Schritt 3: Erstellen Sie eine benutzerdefinierte Autorisierungsressource und deren Autorisierung](#custom-auth-tutorial-authorizer)
+ [Schritt 4: Testen Sie den Authorizer, indem Sie ihn anrufen test-invoke-authorizer](#custom-auth-tutorial-test)
+ [Schritt 5: Testen der Veröffentlichung der MQTT-Nachricht mithilfe von Postman](#custom-auth-tutorial-postman)
+ [Schritt 6: Anzeigen von Nachrichten im MQTT-Testclient](#custom-auth-tutorial-testclient)
+ [Schritt 7: Überprüfen der Ergebnisse und die nächsten Schritte](#custom-auth-tutorial-review)
+ [Schritt 8: Bereinigen](#custom-auth-tutorial-cleanup)
**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.
Das Konto, das Sie für dieses Tutorial verwenden, funktioniert am besten, wenn es mindestens die folgenden AWS -verwalteten Richtlinien umfasst:
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/IAMFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSIoTFullAccess$jsonEditor)
+ [https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor](https://console.aws.amazon.com//iam/home#/policies/arn:aws:iam::aws:policy/AWSLambda_FullAccess$jsonEditor)
**Wichtig**
Die in diesem Tutorial verwendeten IAM-Richtlinien sind permissiver, als Sie sie bei einer Produktionsimplementierung befolgen sollten. Stellen Sie in einer Produktionsumgebung sicher, dass Ihre Konto- und Ressourcenrichtlinien nur die erforderlichen Berechtigungen gewähren.
Wenn Sie IAM-Richtlinien für die Produktion erstellen, bestimmen Sie, welchen Zugriff Benutzer und Rollen benötigen. Generieren Sie dann die Richtlinien, die es ihnen ermöglichen, nur diese Aufgaben auszuführen.
Weitere Informationen finden Sie unter [Bewährte IAM-Methoden](https://docs.aws.amazon.com//IAM/latest/UserGuide/best-practices.html).
+
**Installierte das AWS CLI**
Informationen zur Installation von finden Sie AWS CLI unter [AWS CLI installieren](https://docs.aws.amazon.com//cli/latest/userguide/cli-chap-install.html). Für dieses Tutorial ist AWS CLI Version `aws-cli/2.1.3 Python/3.7.4 Darwin/18.7.0 exe/x86_64` oder höher erforderlich.
+
**OpenSSL-Tools**
Die Beispiele in diesem Tutorial verwenden [LibreSSL 2.6.5](https://www.libressl.org/). Sie können für dieses Tutorial auch die [OpenSSL v1.1.1i](https://www.openssl.org/)-Tools verwenden.
+
**Die [AWS Lambda](https://docs.aws.amazon.com//lambda/latest/dg/welcome.html)-Übersicht wurde ü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.
+
**Es wurde überprüft, wie Anfragen in Postman erstellt werden.**
Weitere Informationen finden Sie unter [Erstellen von Anfragen](https://learning.postman.com/docs/sending-requests/requests/).
+
**Benutzerdefinierte Autorisierer wurden aus dem vorherigen Tutorial entfernt.**
Sie AWS-Konto können nur eine begrenzte Anzahl von benutzerdefinierten Autorisierern gleichzeitig konfigurieren. Weitere Informationen zum Erstellen eines benutzerdefinierten Autorisierers finden Sie unter [Schritt 8: Bereinigen](#custom-auth-tutorial-cleanup).
## Schritt 1: Erstellen einer Lambda-Funktion für Ihren benutzerdefinierten Autorisierer
Die benutzerdefinierte Authentifizierung in AWS IoT Core verwendet [Autorisierungsressourcen](https://docs.aws.amazon.com//iot/latest/apireference/API_AuthorizerDescription.html), die Sie zur Authentifizierung und Autorisierung von Clients erstellen. Die Funktion, die Sie in diesem Abschnitt erstellen, authentifiziert und autorisiert Clients, wenn sie sich mit Ressourcen verbinden und auf sie zugreifen. AWS IoT Core AWS IoT
Die Lambda-Funktion bewirkt Folgendes:
+ Wenn eine Anfrage von **test-invoke-authorizer** kommt, gibt sie eine IAM-Richtlinie mit einer `Deny`-Aktion zurück.
+ Wenn eine Anfrage von Postman über HTTP kommt und der `actionToken` Parameter den Wert von hat`allow`, wird eine IAM-Richtlinie mit einer Aktion zurückgegeben. `Allow` Andernfalls wird eine IAM-Richtlinie mit einer Aktion `Deny` zurückgegeben.
**So erstellen Sie die Lambda-Funktion für Ihren benutzerdefinierten Autorisierer**
1. Öffnen Sie auf der [Lambda](https://console.aws.amazon.com//lambda/home#)-Konsole die Option [Funktionen](https://console.aws.amazon.com//lambda/home#/functions).
1. Wählen Sie **Funktion erstellen**.
1. Bestätigen Sie, dass **Ohne Vorgabe erstellen** ausgewählt ist.
1. Unter **Grundlegende Informationen**:
1. Geben Sie unter **Funktionsname** **custom-auth-function** ein.
1. Bestätigen Sie unter **Laufzeit** **Node.js 18.x**
1. Wählen Sie **Funktion erstellen**.
Lambda erstellt eine Node.js-Funktion und eine [Ausführungsrolle](https://docs.aws.amazon.com//lambda/latest/dg/lambda-intro-execution-role.html), die der Funktion die Berechtigung zum Hochladen von Protokollen gewährt. Die Lambda-Funktion übernimmt die Ausführungsrolle, wenn Sie Ihre Funktion aufrufen, und verwendet die Ausführungsrolle, um Anmeldeinformationen für das AWS SDK zu erstellen und Daten aus Ereignisquellen zu lesen.
1. Um den Code und die Konfiguration der Funktion im [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)Editor zu sehen, wählen Sie **custom-auth-function**im Designerfenster und dann im Navigationsbereich des Editors **index.js** aus.
Für Skriptsprachen wie Node.js enthält Lambda eine grundlegende Funktion, die eine Erfolgsantwort zurückgibt. Sie können den [AWS Cloud9](https://docs.aws.amazon.com/cloud9/latest/user-guide/welcome.html)-Editor verwenden, um Ihre Funktion zu bearbeiten, solange Ihr Quellcode nicht größer als 3 MB ist.
1. Ersetzen Sie den Code **index.js** im Editor durch den folgenden Code:
```
// A simple Lambda function for an authorizer. It demonstrates
// How to parse a CLI and Http password to generate a response.
export const handler = async (event, context, callback) => {
//Http parameter to initiate allow/deny request
const HTTP_PARAM_NAME='actionToken';
const ALLOW_ACTION = 'Allow';
const DENY_ACTION = 'Deny';
//Event data passed to Lambda function
var event_str = JSON.stringify(event);
console.log('Complete event :'+ event_str);
//Read protocolData from the event json passed to Lambda function
var protocolData = event.protocolData;
console.log('protocolData value---> ' + protocolData);
//Get the dynamic account ID from function's ARN to be used
// as full resource for IAM policy
var ACCOUNT_ID = context.invokedFunctionArn.split(":")[4];
console.log("ACCOUNT_ID---"+ACCOUNT_ID);
//Get the dynamic region from function's ARN to be used
// as full resource for IAM policy
var REGION = context.invokedFunctionArn.split(":")[3];
console.log("REGION---"+REGION);
//protocolData data will be undefined if testing is done via CLI.
// This will help to test the set up.
if (protocolData === undefined) {
//If CLI testing, pass deny action as this is for testing purpose only.
console.log('Using the test-invoke-authorizer cli for testing only');
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
} else{
//Http Testing from Postman
//Get the query string from the request
var queryString = event.protocolData.http.queryString;
console.log('queryString values -- ' + queryString);
/* global URLSearchParams */
const params = new URLSearchParams(queryString);
var action = params.get(HTTP_PARAM_NAME);
if(action!=null && action.toLowerCase() === 'allow'){
callback(null, generateAuthResponse(ALLOW_ACTION,ACCOUNT_ID,REGION));
}else{
callback(null, generateAuthResponse(DENY_ACTION,ACCOUNT_ID,REGION));
}
}
};
// Helper function to generate the authorization IAM response.
var generateAuthResponse = function(effect,ACCOUNT_ID,REGION) {
var full_resource = "arn:aws:iot:"+ REGION + ":" + ACCOUNT_ID + ":*";
console.log("full_resource---"+full_resource);
var authResponse = {};
authResponse.isAuthenticated = true;
authResponse.principalId = 'principalId';
var policyDocument = {};
policyDocument.Version = '2012-10-17';
policyDocument.Statement = [];
var statement = {};
statement.Action = 'iot:*';
statement.Effect = effect;
statement.Resource = full_resource;
policyDocument.Statement[0] = statement;
authResponse.policyDocuments = [policyDocument];
authResponse.disconnectAfterInSeconds = 3600;
authResponse.refreshAfterInSeconds = 600;
console.log('custom auth policy function called from http');
console.log('authResponse --> ' + JSON.stringify(authResponse));
console.log(authResponse.policyDocuments[0]);
return authResponse;
}
```
1. Wählen Sie **Bereitstellen**.
1. Nachdem **Änderungen bereitgestellt** über dem Editor angezeigt wird:
1. Scrollen Sie zum Abschnitt **Funktionsübersicht** über dem Editor.
1. Kopieren Sie die **Funktion ARN** und speichern Sie sie, um sie später in diesem Tutorial zu verwenden.
1. Testen Sie Ihre Funktion.
1. Wählen Sie die Registerkarte **Test**.
1. Wählen Sie unter Verwendung der Standard-Testeinstellungen **Aufrufen**.
1. Wenn der Test erfolgreich war, öffnen Sie in den **Ausführungsergebnissen** die Ansicht **Details**. Sie sollten das Richtliniendokument sehen, das die Funktion zurückgegeben hat.
Wenn der Test fehlgeschlagen ist oder Sie kein Richtliniendokument finden, überprüfen Sie den Code, um die Fehler zu finden und zu korrigieren.
## Schritt 2: Erstellen eines öffentlichen und eines privaten Schlüsselpaars für Ihren benutzerdefinierten Autorisierer
Ihr benutzerdefinierter Autorisierer benötigt für seine Authentifizierung einen öffentlichen und einen privaten Schlüssel. Die Befehle in diesem Abschnitt verwenden OpenSSL-Tools zum Erstellen dieses Schlüsselpaars.
**So erstellen Sie das Paar aus öffentlichem und privatem Schlüssel für Ihren benutzerdefinierten Autorisierer**
1. Erstellen Sie die Datei mit dem privaten Schlüssel.
```
openssl genrsa -out private-key.pem 4096
```
1. Überprüfen Sie den Speicherort der Datei mit dem privaten Schlüssel, die Sie gerade erstellt haben.
```
openssl rsa -check -in private-key.pem -noout
```
Wenn der Befehl keine Fehler anzeigt, ist die Datei mit dem privaten Schlüssel gültig.
1. Erstellen Sie die Datei mit dem öffentlichen Schlüssel.
```
openssl rsa -in private-key.pem -pubout -out public-key.pem
```
1. Überprüfen Sie die Datei mit dem öffentlichen Schlüssel.
```
openssl pkey -inform PEM -pubin -in public-key.pem -noout
```
Wenn der Befehl keine Fehler anzeigt, ist die Datei mit dem öffentlichen Schlüssel gültig.
## Schritt 3: Erstellen Sie eine benutzerdefinierte Autorisierungsressource und deren Autorisierung
Der AWS IoT benutzerdefinierte Autorisierer ist die Ressource, die alle in den vorherigen Schritten erstellten Elemente zusammenfasst. In diesem Abschnitt erstellen Sie eine benutzerdefinierte Autorisierer-Ressource und erteilen ihr die Erlaubnis, die zuvor erstellte Lambda-Funktion auszuführen. Sie können eine benutzerdefinierte Autorisierungsressource mithilfe der AWS IoT Konsole, der oder der AWS CLI AWS API erstellen.
Für dieses Tutorial müssen Sie nur einen benutzerdefinierten Autorisierer erstellen. In diesem Abschnitt wird beschrieben, wie Sie mithilfe der AWS IoT Konsole und der erstellen AWS CLI, sodass Sie die Methode verwenden können, die für Sie am bequemsten ist. Es gibt keinen Unterschied zwischen den mithilfe dieser beiden Methoden erstellen benutzerdefinierten Autorisierer-Ressourcen.
### Erstellen Sie eine benutzerdefinierte Authorizer-Ressource
**Wählen Sie eine dieser Optionen, um Ihre benutzerdefinierte Autorisierer-Ressource zu erstellen.**
+ [Erstellen Sie mithilfe der Konsole einen benutzerdefinierten Autorisierer AWS IoT](#create-custom-auth-in-console)
+ [So erstellen Sie einen benutzerdefinierten Autorisierer mithilfe der AWS CLI](#create-custom-auth-in-cli)
**So erstellen Sie einen benutzerdefinierten Autorisierer (Konsole)**
1. Öffnen Sie die [Seite Benutzerdefinierter Autorisierer der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/authorizerhub) und wählen Sie **Create** Authorizer aus.
1. In **Autorisierer erstellen**:
1. Geben Sie in das Feld **Autorisierer-Name** **my-new-authorizer** ein.
1. Markieren Sie unter **Autorisierer-Status** die Option **Aktiv**.
1. Wählen Sie in der **Autorisierer-Funktion** die Lambda-Funktion aus, die Sie zuvor erstellt haben.
1. Unter **Token-Validierung – optional:**
1. Aktivieren Sie die **Token-Validierung**.
1. Geben Sie **tokenKeyName** in das Feld **Token-Schlüsselname** ein.
1. Wählen Sie **Schlüssel hinzufügen**.
1. Geben Sie unter **Schlüsselname** **FirstKey** ein.
1. Geben Sie in das Feld **Öffentlicher Schlüssel** den Inhalt der Datei `public-key.pem` ein. Achten Sie darauf, die Zeilen aus der Datei mit `-----BEGIN PUBLIC KEY-----` und `-----END PUBLIC KEY-----` einzuschließen und dem Inhalt der Datei keine Zeilenvorschübe, Zeilenumbrüche oder andere Zeichen hinzuzufügen oder aus ihm zu entfernen. Die Zeichenfolge, die Sie eingeben, sollte in etwa wie im folgenden Beispiel aussehen.
```
-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----
```
1. Wählen Sie **Autorisierer erstellen**.
1. Wenn die benutzerdefinierte Autorisierer-Ressource erstellt wurde, wird die Liste der benutzerdefinierten Autorisierer angezeigt und Ihr neuer benutzerdefinierter Autorisierer sollte in der Liste angezeigt werden. Sie können dann mit dem nächsten Abschnitt fortfahren, um ihn zu testen.
Wenn Sie einen Fehler sehen, überprüfen Sie den Fehler und versuchen Sie erneut, Ihren benutzerdefinierten Autorisierer zu erstellen, und überprüfen Sie die Einträge erneut. Beachten Sie, dass jeder Benutzer einen eindeutigen Namen haben muss.
**So erstellen Sie einen benutzerdefinierten Autorisierer (AWS CLI)**
1. Ersetzen Sie Ihre Werte durch `authorizer-function-arn` und `token-signing-public-keys`, und führen Sie dann den folgenden Befehl aus:
```
aws iot create-authorizer \
--authorizer-name "my-new-authorizer" \
--token-key-name "tokenKeyName" \
--status ACTIVE \
--no-signing-disabled \
--authorizer-function-arn "arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function" \
--token-signing-public-keys FirstKey="-----BEGIN PUBLIC KEY-----
MIICIjANBgkqhkiG9w0BAQEFAAOCAg8AMIICCgKCAgEAvEBzOk4vhN+3LgslvEWt
sLCqNmt5Damas3bmiTRvq2gjRJ6KXGTGQChqArAJwL1a9dkS9+maaXC3vc6xzx9z
QPu/vQOe5tyzz1MsKdmtFGxMqQ3qjEXAMPLEOmqyUKPP5mff58k6ePSfXAnzBH0q
lg2HioefrpU5OSAnpuRAjYKofKjbc2Vrn6N2G7hV+IfTBvCElf0csalS/Rk4phD5
oa4Y0GHISRnevypg5C8n9Rrz91PWGqP6M/q5DNJJXjMyleG92hQgu1N696bn5Dw8
FhedszFa6b2x6xrItZFzewNQkPMLMFhNrQIIyvshtT/F1LVCS5+v8AQ8UGGDfZmv
QeqAMAF7WgagDMXcfgKSVU8yid2sIm56qsCLMvD2Sq8Lgzpey9N5ON1o1Cvldwvc
KrJJtgwW6hVqRGuShnownLpgG86M6neZ5sRMbVNZO8OzcobLngJ0Ibw9KkcUdklW
gvZ6HEJqBY2XE70iEXAMPLETPHzhqvK6Ei1HGxpHsXx6BNft582J1VpgYjXha8oa
/NN7l7Zbj/euAb41IVtmX8JrD9z613d1iM5L8HluJlUzn62Q+VeNV2tdA7MfPfMC
8btGYladFAnitThaz6+F0VSBJPu7pZQoLnqyEp5zLMtF+kFl2yOBmGAP0RBivRd9
JWBUCG0bqcLQPeQyjbXSOfUCAwEAAQ==
-----END PUBLIC KEY-----"
```
**Wobei Folgendes gilt:**
+ Der Wert `authorizer-function-arn` ist der Amazon-Ressourcenname (ARN) der Lambda-Funktion, die Sie für Ihren benutzerdefinierten Autorisierer erstellt haben.
+ Der Wert `token-signing-public-keys` umfasst den Namen des Schlüssels, **FirstKey**, und den Inhalt der Datei `public-key.pem`. Achten Sie darauf, die Zeilen aus der Datei mit `-----BEGIN PUBLIC KEY-----` und `-----END PUBLIC KEY-----` einzuschließen und dem Inhalt der Datei keine Zeilenvorschübe, Zeilenumbrüche oder andere Zeichen hinzuzufügen oder aus ihm zu entfernen.
Hinweis: Seien Sie vorsichtig bei der Eingabe des öffentlichen Schlüssels, da jede Wertänderung des öffentlichen Schlüssels diesen unbrauchbar macht.
1. Wenn der benutzerdefinierte Autorisierer erstellt wird, gibt der Befehl den Namen und den ARN der neuen Ressource zurück, z. B. folgendermaßen:
```
{
"authorizerName": "my-new-authorizer",
"authorizerArn": "arn:aws:iot:Region:57EXAMPLE833:authorizer/my-new-authorizer"
}
```
Speichern Sie den Wert `authorizerArn` zur Verwendung im nächsten Schritt.
Denken Sie daran, dass jeder Benutzer einen eindeutigen Namen haben muss.
### Autorisieren der benutzerdefinierten Autorisierer-Ressource
In diesem Abschnitt erteilen Sie der benutzerdefinierten Autorisierer-Ressource, die Sie gerade erstellt haben, die Berechtigung zum Ausführen der Lambda-Funktion. Um die Berechtigung zu erteilen, können Sie den CLI-Befehl [add-permission](https://docs.aws.amazon.com//cli/latest/reference/lambda/add-permission.html) verwenden.
**Erteilen Sie Ihrer Lambda-Funktion die Erlaubnis mit dem AWS CLI**
1. Geben Sie nach der Eingabe Ihrer Werte den folgenden Befehl ein. Beachten Sie, dass der Wert `statement-id` eindeutig sein muss. Ersetzen Sie `Id-1234` durch einen anderen Wert, wenn Sie dieses Tutorial schon einmal ausgeführt haben oder wenn Sie einen Fehler `ResourceConflictException` angezeigt bekommen.
```
aws lambda add-permission \
--function-name "custom-auth-function" \
--principal "iot.amazonaws.com" \
--action "lambda:InvokeFunction" \
--statement-id "Id-1234" \
--source-arn authorizerArn
```
1. Wenn der Befehl erfolgreich ist, gibt er eine Berechtigungsanweisung zurück, wie in diesem Beispiel. Sie können mit dem nächsten Abschnitt fortfahren, um den benutzerdefinierten Autorisierer zu testen.
```
{
"Statement": "{\"Sid\":\"Id-1234\",\"Effect\":\"Allow\",\"Principal\":{\"Service\":\"iot.amazonaws.com\"},\"Action\":\"lambda:InvokeFunction\",\"Resource\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\",\"Condition\":{\"ArnLike\":{\"AWS:SourceArn\":\"arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function\"}}}"
}
```
Wenn der Befehl nicht erfolgreich ist, wird ein Fehler zurückgegeben, wie in diesem Beispiel. Sie müssen den Fehler überprüfen und korrigieren, bevor Sie fortfahren können.
```
An error occurred (AccessDeniedException) when calling the AddPermission operation: User: arn:aws:iam::57EXAMPLE833:user/EXAMPLE-1 is not authorized to perform: lambda:AddPer
mission on resource: arn:aws:lambda:Region:57EXAMPLE833:function:custom-auth-function
```
## Schritt 4: Testen Sie den Authorizer, indem Sie ihn anrufen test-invoke-authorizer
Wenn alle Ressourcen definiert sind, rufen Sie in diesem Abschnitt test-invoke-authorizer von der Befehlszeile aus auf, um den Autorisierungsdurchgang zu testen.
Beachten Sie, dass `protocolData` nicht definiert ist, wenn der Autorisierer aus der Befehlszeile aufgerufen wird, sodass der Autorisierer immer ein DENY-Dokument zurückgibt. Dieser Test bestätigt jedoch, dass Ihr benutzerdefinierter Autorisierer und Ihre Lambda-Funktion korrekt konfiguriert sind – auch wenn die Lambda-Funktion nicht vollständig getestet wird.
**Um Ihren benutzerdefinierten Authorizer und seine Lambda-Funktion zu testen, verwenden Sie den AWS CLI**
1. Führen Sie in dem Verzeichnis, welches die `private-key.pem`-Datei, die Sie in einem vorherigen Schritt erstellt haben, enthält, den folgenden Befehl aus.
```
echo -n "tokenKeyValue" | openssl dgst -sha256 -sign private-key.pem | openssl base64 -A
```
Mit diesem Befehl wird eine Signaturzeichenfolge zur Verwendung im nächsten Schritt generiert. Die Signaturzeichenfolge sollte wie folgt aussehen:
```
dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mn
VB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeeh
bQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjj
szEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29V
QJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuX
f3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+K
EWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFH
xRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Kopieren Sie diese Signaturzeichenfolge zur Verwendung im nächsten Schritt. Achten Sie darauf, keine zusätzlichen Zeichen einzufügen oder Zeichen wegzulassen.
1. Ersetzen Sie in diesem Befehl den Wert `token-signature` durch die Signaturzeichenfolge aus dem vorherigen Schritt und führen Sie diesen Befehl aus, um Ihren Autorisierer zu testen.
```
aws iot test-invoke-authorizer \
--authorizer-name my-new-authorizer \
--token tokenKeyValue \
--token-signature dBwykzlb+fo+JmSGdwoGr8dyC2qB/IyLefJJr+rbCvmu9Jl4KHAA9DG+V+MMWu09YSA86+64Y3Gt4tOykpZqn9mnVB1wyxp+0bDZh8hmqUAUH3fwi3fPjBvCa4cwNuLQNqBZzbCvsluv7i2IMjEg+CPY0zrWt1jr9BikgGPDxWkjaeehbQHHTo357TegKs9pP30Uf4TrxypNmFswA5k7QIc01n4bIyRTm90OyZ94R4bdJsHNig1JePgnuOBvMGCEFE09jGjjszEHfgAUAQIWXiVGQj16BU1xKpTGSiTAwheLKUjITOEXAMPLECK3aHKYKY+d1vTvdthKtYHBq8MjhzJ0kggbt29VQJCb8RilN/P5+vcVniSXWPplyB5jkYs9UvG08REoy64AtizfUhvSul/r/F3VV8ITtQp3aXiUtcspACi6ca+tsDuXf3LzCwQQF/YSUy02u5XkWn+sto6KCkpNlkD0wU8gl3+kOzxrthnQ8gEajd5Iylx230iqcXo3osjPha7JDyWM5o+KEWckTe91I1mokDr5sJ4JXixvnJTVSx1li49IalW4en1DAkc1a0s2U2UNm236EXAMPLELotyh7h+flFeloZlAWQFHxRlXsPqiVKS1ZIUClaZWprh/orDJplpiWfBgBIOgokJIDGP9gwhXIIk7zWrGmWpMK9o=
```
Wenn der Befehl erfolgreich ist, gibt er die Informationen zurück, die von Ihrer benutzerdefinierten Autorisierungsfunktion generiert wurden, wie in diesem Beispiel.
```
{
"isAuthenticated": true,
"principalId": "principalId",
"policyDocuments": [
"{\"Version\":\"2012-10-17\", \"Statement\":[{\"Action\":\"iot:*\",\"Effect\":\"Deny\",\"Resource\":\"arn:aws:iot:Region:57EXAMPLE833:*\"}]}"
],
"refreshAfterInSeconds": 600,
"disconnectAfterInSeconds": 3600
}
```
Wenn bei diesem Befehl ein Fehler zurückgegeben wird, überprüfen Sie den Fehler und überprüfen Sie erneut die Befehle, die Sie in diesem Abschnitt verwendet haben.
## Schritt 5: Testen der Veröffentlichung der MQTT-Nachricht mithilfe von Postman
1. Um Ihren Gerätedaten-Endpunkt über die Befehlszeile abzurufen, rufen Sie [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) auf, wie hier dargestellt
```
aws iot describe-endpoint --output text --endpoint-type iot:Data-ATS
```
Speichern Sie diese Adresse, damit Sie sie *device\$1data\$1endpoint\$1address* in einem späteren Schritt verwenden können.
1. Öffnen Sie ein neues Postman-Fenster, und erstellen Sie eine neue HTTP-POST-Anfrage.
1. Öffnen Sie auf Ihrem Computer die Postman-App.
1. Wählen Sie in Postman im Menü **Datei** die Option **Neu…**.
1. Wählen Sie im Dialogfeld **Neu** die Option **Anfrage**.
1. Unter Anfrage speichern:
1. Geben Sie unter **Name der Anfrage** **Custom authorizer test request** ein.
1. Wählen Sie unter **Sammlung oder Ordner zum Speichern auswählen:** eine Sammlung aus bzw. erstellen Sie eine, in der diese Anfrage gespeichert werden soll.
1. Wählen Sie **Speichern unter *collection\$1name***.
1. Erstellen Sie die POST-Anfrage, um Ihren benutzerdefinierten Autorisierer zu testen.
1. Wählen Sie in der Auswahl der Anfragemethode neben dem URL-Feld die Option **POST**.
1. Erstellen Sie im Feld URL die URL für Ihre Anfrage, indem Sie die folgende URL zusammen mit dem Befehl *device\$1data\$1endpoint\$1address* from the [describe-endpoint](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/describe-endpoint.html) in einem vorherigen Schritt verwenden.
```
https://device_data_endpoint_address:443/topics/test/cust-auth/topic?qos=0&actionToken=allow
```
Beachten Sie, dass diese URL den Abfrageparameter `actionToken=allow` enthält, der Ihre Lambda-Funktion anweist, ein Richtliniendokument zurückzugeben, das den Zugriff auf das AWS IoT ermöglicht. Nachdem Sie die URL eingegeben haben, werden die Abfrageparameter auch auf der Registerkarte **Params** von Postman angezeigt.
1. Wählen Sie auf der Registerkarte **Auth** im Feld **Typ** die Option **Keine Auth**.
1. Auf der Registerkarte Header:
1. Wenn ein **Host**-Schlüssel aktiviert ist, deaktivieren Sie diesen.
1. Fügen Sie diese neuen Header am Ende der Header-Liste hinzu, und bestätigen Sie, dass sie aktiviert sind. Ersetzen Sie den **Host** Wert durch Ihren *device\$1data\$1endpoint\$1address* und den **x-amz-customauthorizer-signature** Wert durch die Signaturzeichenfolge, die Sie mit dem **test-invoke-authorize** Befehl im vorherigen Abschnitt verwendet haben.
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/custom-auth-tutorial.html)
1. Auf der Registerkarte „Text“:
1. Wählen Sie im Optionsfeld für das Datenformat die Option **Raw**.
1. Wählen Sie in der Datentypliste **JavaScript**.
1. Geben Sie in das Textfeld diese JSON-Nachrichtennutzlast für Ihre Testnachricht ein:
```
{
"data_mode": "test",
"vibration": 200,
"temperature": 40
}
```
1. Wählen Sie **Senden** aus, um die Anfrage zu senden.
Wenn die Anfrage erfolgreich war, wird Folgendes zurückgegeben:
```
{
"message": "OK",
"traceId": "ff35c33f-409a-ea90-b06f-fbEXAMPLE25c"
}
```
Die erfolgreiche Antwort weist darauf hin, dass Ihr benutzerdefinierter Autorisierer die Verbindung zugelassen hat AWS IoT und dass die Testnachricht an den Broker in AWS IoT Core zugestellt wurde.
Wenn ein Fehler zurückgegeben wird, überprüfen Sie die Fehlermeldung*device\$1data\$1endpoint\$1address*, die Signaturzeichenfolge und die anderen Header-Werte.
Bewahren Sie diese Anfrage in Postman auf, um Sie im nächsten Abschnitt zu verwenden.
## Schritt 6: Anzeigen von Nachrichten im MQTT-Testclient
Im vorherigen Schritt haben Sie mithilfe AWS IoT von Postman simulierte Gerätemeldungen an gesendet. Die erfolgreiche Antwort wies darauf hin, dass Ihr benutzerdefinierter Autorisierer die Verbindung zum AWS IoT gestattet hat und dass die Testnachricht an den Broker in AWS IoT Core zugestellt wurde. In diesem Abschnitt verwenden Sie den MQTT-Testclient in der AWS IoT Konsole, um den Nachrichteninhalt dieser Nachricht so zu sehen, wie es bei anderen Geräten und Diensten der Fall ist.
**So zeigen Sie die von Ihrem benutzerdefinierten Autorisierer autorisierten Testnachrichten an**
1. Öffnen Sie in der AWS IoT Konsole den [MQTT-Testclient](https://console.aws.amazon.com//iot/home#/test).
1. Geben Sie auf der Registerkarte **Thema abonnieren** im **Themenfilter** **test/cust-auth/topic** ein – das Nachrichtenthema aus dem vorherigen Abschnitt, das im Postman-Beispiel verwendet wurde.
1. Wählen Sie **Abonnieren**.
Lassen Sie dieses Fenster für den nächsten Schritt geöffnet.
1. Wählen Sie in Postman in der Anfrage, die Sie für den vorherigen Abschnitt erstellt haben, die Option **Senden**.
Überprüfen Sie die Antwort, um sicherzustellen, dass sie erfolgreich war. Falls nicht, beheben Sie den Fehler, wie im vorherigen Abschnitt beschrieben.
1. Im **MQTT-Testclient** sollten Sie einen neuen Eintrag sehen, der das Nachrichtenthema und, falls erweitert, die Nachrichten-Nutzlast aus der Anfrage anzeigt, die Sie von Postman gesendet haben.
Wenn Sie Ihre Nachrichten nicht im **MQTT-Testclient** sehen, sollten Sie Folgendes überprüfen:
+ Stellen Sie sicher, dass Ihre Postman-Anfrage erfolgreich zurückgegeben wurde. Wenn die Verbindung AWS IoT zurückgewiesen wird und ein Fehler zurückgegeben wird, wird die Nachricht in der Anfrage nicht an den Message Broker weitergeleitet.
+ Stellen Sie sicher, dass die zum Öffnen der AWS IoT Konsole AWS-Region verwendeten AWS-Konto und dieselben sind, die Sie in der Postman-URL verwenden.
+ Stellen Sie sicher, dass Sie den entsprechenden Endpunkt für den benutzerdefinierten Authorizer verwenden. Der Standard-IoT-Endpunkt unterstützt möglicherweise nicht die Verwendung benutzerdefinierter Autorisierer mit Lambda-Funktionen. Stattdessen können Sie Domänenkonfigurationen verwenden, um einen neuen Endpunkt zu definieren und diesen Endpunkt dann für den benutzerdefinierten Autorisierer anzugeben.
+ Stellen Sie sicher, dass Sie das Thema korrekt in den **MQTT-Testclient** eingegeben haben. Beim Themenfilter wird die Groß-/Kleinschreibung berücksichtigt. Im Zweifelsfall können Sie auch das **\$1** Thema abonnieren, das alle MQTT-Nachrichten abonniert, die den Message Broker passieren AWS-Konto und zum Öffnen der Konsole AWS-Region verwendet werden. AWS IoT
## Schritt 7: Überprüfen der Ergebnisse und die nächsten Schritte
**In diesem Tutorial:**
+ Haben Sie eine Lambda-Funktion als benutzerdefinierten Autorisierer-Handler erstellt.
+ Haben Sie einen benutzerdefinierten Autorisierer mit aktivierter Token-Signatur erstellt.
+ Haben Sie Ihren benutzerdefinierten Autorisierer mit dem Befehl **test-invoke-authorizer** getestet.
+ Haben Sie ein MQTT-Thema mit [Postman](https://www.postman.com/) veröffentlicht und die Anfrage mit Ihrem benutzerdefinierten Autorisierer validiert.
+ Haben Sie den **MQTT-Testclient** verwendet, um die von Ihrem Postman-Test gesendeten Nachrichten anzusehen.
**Nächste Schritte**
Nachdem Sie einige Nachrichten von Postman gesendet haben, um zu überprüfen, ob der benutzerdefinierte Autorisierer funktioniert, versuchen Sie zu experimentieren, um festzustellen, wie sich Änderungen an verschiedenen Aspekten dieses Tutorials auf die Ergebnisse auswirken. Hier sind einige Beispiele, die Ihnen den Einstieg erleichtern sollen.
+ Ändern Sie die Signaturzeichenfolge so, dass sie nicht mehr gültig ist, um zu sehen, wie unbefugte Verbindungsversuche behandelt werden. Sie sollten eine Fehlerantwort wie diese erhalten und die Meldung sollte nicht auf dem **MQTT-Testclient** erscheinen.
```
{
"message": "Forbidden",
"traceId": "15969756-a4a4-917c-b47a-5433e25b1356"
}
```
+ 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)
## Schritt 8: Bereinigen
Wenn Sie dieses Tutorial wiederholen möchten, müssen Sie möglicherweise einige Ihrer benutzerdefinierten Autorisierer entfernen. Sie AWS-Konto können nur eine begrenzte Anzahl von benutzerdefinierten Autorisierern gleichzeitig konfigurieren. Sie erhalten einen, `LimitExceededException` wenn Sie versuchen, einen neuen hinzuzufügen, ohne einen vorhandenen benutzerdefinierten Autorisierer zu entfernen.
**So entfernen Sie einen benutzerdefinierten Autorisierer (Konsole)**
1. Öffnen Sie die [Seite Benutzerdefinierter Autorisierer der AWS IoT Konsole](https://console.aws.amazon.com//iot/home#/authorizerhub) und suchen Sie in der Liste der benutzerdefinierten Autorisierer nach dem benutzerdefinierten Autorisierer, den Sie entfernen möchten.
1. Öffnen Sie die Seite mit den Details des benutzerdefinierten Autorisierers, und wählen Sie aus dem Menü **Aktionen** die Option **Bearbeiten**.
1. Heben Sie die Auswahl von **Autorisierer aktivieren** auf, und wählen Sie dann **Aktualisieren**.
Während ein benutzerdefinierter Autorisierer aktiv ist, können Sie ihn nicht löschen.
1. Öffnen Sie auf der Seite mit den Details des benutzerdefinierten Autorisierers das Menü **Aktionen**, und wählen Sie **Löschen**.
**So entfernen Sie einen benutzerdefinierten Autorisierer (AWS CLI)**
1. Listen Sie die benutzerdefinierten Autorisierer auf, die Sie installiert haben, und suchen Sie nach dem Namen des benutzerdefinierten Autorisierers, den Sie löschen möchten.
```
aws iot list-authorizers
```
1. Legen Sie den benutzerdefinierten Autorisierer auf `inactive` fest, indem Sie diesen Befehl ausführen, nachdem Sie `Custom_Auth_Name` durch `authorizerName` des benutzerdefinierten Autorisierers, der gelöscht werden soll, ersetzt haben.
```
aws iot update-authorizer --status INACTIVE --authorizer-name Custom_Auth_Name
```
1. Löschen Sie den benutzerdefinierten Autorisierer, indem Sie diesen Befehl ausführen, nachdem Sie `Custom_Auth_Name` durch `authorizerName` des benutzerdefinierten Autorisierers, der gelöscht werden soll, ersetzt haben.
```
aws iot delete-authorizer --authorizer-name Custom_Auth_Name
```
# Tutorial: Überwachung der Bodenfeuchte mit einem AWS IoT Raspberry Pi
Dieses Tutorial zeigt Ihnen, wie Sie einen [Raspberry Pi](https://www.raspberrypi.org/), einen Feuchtigkeitssensor, verwenden und AWS IoT den Bodenfeuchtigkeitsgehalt einer Zimmerpflanze oder eines Gartens überwachen. Der Raspberry Pi führt Code aus, der den Feuchtigkeitsgehalt und die Temperatur vom Sensor liest und die Daten dann an sendet AWS IoT. Sie erstellen eine Regel AWS IoT , die eine E-Mail an eine Adresse sendet, die ein Amazon SNS SNS-Thema abonniert hat, wenn der Feuchtigkeitsgehalt unter einen Schwellenwert fällt.
**Anmerkung**
Dieses Tutorial ist möglicherweise nicht aktuell. Einige Verweise wurden möglicherweise seit der ursprünglichen Veröffentlichung dieses Themas ersetzt.
**Contents**
+ [Voraussetzungen](#iot-moisture-prereqs)
+ [Einrichten AWS IoT](iot-moisture-setup.md)
+ [Schritt 1: Erstellen Sie die AWS IoT Richtlinie](iot-moisture-policy.md)
+ [Schritt 2: Erstellen Sie das AWS IoT Ding, das Zertifikat und den privaten Schlüssel](iot-moisture-create-thing.md)
+ [Schritt 3: Erstellen eines Amazon-SNS-Themas und -Abonnements](iot-moisture-create-sns-topic.md)
+ [Schritt 4: Erstellen Sie eine AWS IoT Regel zum Senden einer E-Mail](iot-moisture-create-rule.md)
+ [Einrichten des Raspberry Pi und des Feuchtesensors](iot-moisture-raspi-setup.md)
## Voraussetzungen
Zum Durchführen dieses Tutorials benötigen Sie Folgendes:
+ Ein. AWS-Konto
+ Ein IAM-Benutzer mit Administratorberechtigungen.
+ Ein Entwicklungscomputer mit Windows, macOS, Linux oder Unix für den Zugriff auf die [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home).
+ Ein [Raspberry Pi 3B oder 4B](https://www.raspberrypi.com/products/) mit dem neuesten [Raspberry Pi-Betriebssystem](https://www.raspberrypi.com/software/operating-systems/). Installationsanweisungen finden [Sie unter Installieren eines Betriebssystems](https://www.raspberrypi.com/documentation/computers/getting-started.html#installing-the-operating-system) auf der Raspberry Pi-Website.
+ Ein Monitor, eine Tastatur, eine Maus und eine WLAN-Verbindung oder eine Ethernet-Verbindung für Ihren Raspberry Pi.
+ Ein mit Raspberry Pi kompatibler Feuchtigkeitssensor. Bei dem in diesem Tutorial verwendeten Sensor handelt es sich um einen [Adafruit STEMMA I2C Capacitive Moisture Sensor](https://www.adafruit.com/product/4026) mit einer [JST 4-adrigen Kabelbuchsenleiste](https://www.adafruit.com/product/3950).
# Einrichten AWS IoT
Um dieses Tutorial abzuschließen, müssen Sie die folgenden Ressourcen erstellen. Um ein Gerät zu verbinden AWS IoT, erstellen Sie ein IoT-Ding, ein Gerätezertifikat und eine AWS IoT Richtlinie.
+ AWS IoT Irgendein Ding.
Ein Objekt stellt ein physisches Gerät (in diesem Fall Ihr Rasberry Pi) dar und enthält statische Metadaten über das Gerät.
+ Ein Gerätezertifikat.
Alle Geräte müssen über ein Gerätezertifikat verfügen, um eine Verbindung herzustellen und sich mit AWS IoT zu authentifizieren.
+ Eine AWS IoT Richtlinie.
Jedem Gerätezertifikat sind eine oder mehrere AWS IoT Richtlinien zugeordnet. Diese Richtlinien legen fest, auf welche AWS IoT Ressourcen das Gerät zugreifen kann.
+ Ein AWS IoT Root-CA-Zertifikat.
Geräte und andere Clients verwenden ein AWS IoT Root-CA-Zertifikat, um den AWS IoT Server zu authentifizieren, mit dem sie kommunizieren. Weitere Informationen finden Sie unter [Serverauthentifizierung](server-authentication.md).
+ Eine AWS IoT Regel.
Eine Regel enthält eine Abfrage und mindestens eine Regelaktion. Die Abfrage extrahiert Daten aus Gerätenachrichten, um zu bestimmen, ob die Nachrichtendaten verarbeitet werden sollen. Die Regelaktion gibt an, was zu tun ist, wenn die Daten mit der Abfrage übereinstimmen.
+ Ein Amazon SNS-Thema und ein Themenabonnement.
Die Regel überwacht die Feuchtigkeitsdaten über Ihren Raspberry Pi. Wenn der Wert unter einem Schwellenwert liegt, wird eine Nachricht an das Amazon-SNS-Thema gesendet. Amazon SNS sendet diese Nachricht an alle E-Mail-Adressen, die das Thema abonniert haben.
# Schritt 1: Erstellen Sie die AWS IoT Richtlinie
Erstellen Sie eine AWS IoT Richtlinie, die es Ihrem Raspberry Pi ermöglicht, eine Verbindung herzustellen und Nachrichten an diese zu senden AWS IoT.
1. Wenn in der [AWS IoT -Konsole](https://console.aws.amazon.com/iot) die Schaltfläche **Erste Schritte** erscheint, klicken Sie darauf. Erweitern Sie andernfalls im Navigationsbereich ** Sicherheit** und wählen Sie dann **Richtlinien** aus.
1. Wenn das Dialogfeld **You don‘t have any policies yet (Sie haben noch keine Richtlinien)** angezeigt wird, wählen Sie **Create a policy (Richtlinie erstellen)** aus. Wählen Sie andernfalls **Erstellen**.
1. Geben Sie einen Namen für die AWS IoT Richtlinie ein (z. B.**MoistureSensorPolicy**).
1. Ersetzen Sie im Abschnitt **Add statements (Anweisungen hinzufügen)** die vorhandene Richtlinie durch das folgende JSON-Objekt. Ersetzen Sie *region* und *account* durch Ihre AWS-Konto Nummer AWS-Region und.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/RaspberryPi"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/RaspberryPi/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:us-east-1:123456789012:thing/RaspberryPi"
}
]
}
```
1. Wählen Sie **Erstellen** aus.
# Schritt 2: Erstellen Sie das AWS IoT Ding, das Zertifikat und den privaten Schlüssel
Erstellen Sie in der AWS IoT Registrierung ein Ding, das Ihren Raspberry Pi repräsentiert.
1. Wählen Sie in der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home) im Navigationsbereich **Manage (Verwalten)** und dann **Things (Objekte)**.
1. Wenn das Dialogfeld **You don‘t have any things yet (Sie haben noch keine Objekte)** angezeigt wird, wählen Sie **Register a thing (Objekt registrieren)** aus. Wählen Sie andernfalls **Erstellen**.
1. Wählen Sie auf der Seite „** AWS IoT Dinge erstellen****“ die Option Ein einzelnes Ding** erstellen aus.
1. Geben Sie auf der Seite **Add your device to the device registry (Ihr Gerät zur Geräteregistrierung hinzufügen)** einen Namen für Ihr IoT-Objekt ein (z. B. **RaspberryPi**) und wählen Sie dann **Next (Weiter)**. Sie können den Namen eines Objekts nicht mehr ändern, nachdem Sie es erstellt haben. Um den Namen eines Objekts zu ändern, müssen Sie ein neues Objekt erstellen, diesem den neuen Namen geben und dann das alte Objekt löschen.
1. Wählen Sie auf der Seite **Add a certificate for your thing (Fügen Sie ein Zertifikat für Ihr Objekt hinzu.)** die Option **Create certificate (Zertifikat erstellen)**.
1. Klicken Sie auf die **Download**-Links, um das Zertifikat, den privaten Schlüssel und das CA-Stammzertifikat herunterzuladen.
**Wichtig**
Dies ist das einzige Mal, dass Sie Ihr Zertifikat und Ihren privaten Schlüssel herunterladen können.
1. Wählen Sie **Aktivieren** aus, um Ihr Zertifikat zu aktivieren. Das Zertifikat muss aktiv sein, damit ein Gerät eine Verbindung mit AWS IoT herstellen kann.
1. Wählen Sie **Attach a policy (Richtlinie anfügen)** aus.
1. Wählen ****MoistureSensorPolicy**Sie unter Richtlinie für Ihr Ding hinzufügen** die Option und anschließend **Ding registrieren** aus.
# Schritt 3: Erstellen eines Amazon-SNS-Themas und -Abonnements
Erstellen eines Amazon-SNS-Themas und -Abonnements.
1. Klicken Sie in der [AWS SNS-Konsole](https://console.aws.amazon.com/sns/home) im Navigationsbereich auf **Themen** und wählen Sie dann **Thema erstellen** aus.
1. Wählen Sie Typ als **Standard** und geben Sie einen Namen für das Thema ein (z. B.**MoistureSensorTopic**).
1. Geben Sie einen Anzeigenamen für das Thema ein (z. B. **Moisture Sensor Topic**). Dies ist der Name, der für Ihr Thema in der Amazon SNS -Konsole angezeigt wird.
1. Wählen Sie **Thema erstellen** aus.
1. Wählen Sie auf der Seite mit den Details des Amazon SNS-Themas die Option **Create subscription (Abonnement erstellen)** aus.
1. Wählen Sie unter **Protocol (Protokoll)** die Option **Email (E-Mail)** aus.
1. Geben Sie unter **Endpunkt** Ihre E-Mail-Adresse ein.
1. Wählen Sie **Create subscription** (Abonnement erstellen) aus.
1. Öffnen Sie Ihren E-Mail-Client und suchen Sie nach einer Nachricht mit dem Betreff **MoistureSensorTopic**. Öffnen Sie die E-Mail und klicken Sie auf den Link **Confirm subscription (Abonnement bestätigen)**.
**Wichtig**
Sie erhalten keine E-Mail-Benachrichtigungen von diesem Amazon SNS-Thema, bis Sie das Abonnement bestätigen.
Sie sollten eine E-Mail-Nachricht mit dem von Ihnen eingegebenen Text erhalten.
# Schritt 4: Erstellen Sie eine AWS IoT Regel zum Senden einer E-Mail
Eine AWS IoT Regel definiert eine Abfrage und eine oder mehrere Aktionen, die ausgeführt werden sollen, wenn eine Nachricht von einem Gerät empfangen wird. Die AWS IoT Regel-Engine wartet auf Nachrichten, die von Geräten gesendet werden, und bestimmt anhand der in den Nachrichten enthaltenen Daten, ob Maßnahmen ergriffen werden sollten. Weitere Informationen finden Sie unter [Regeln für AWS IoT](iot-rules.md).
In diesem Tutorial veröffentlicht Ihr Raspberry Pi Nachrichten auf `aws/things/RaspberryPi/shadow/update`. Dies ist ein internes MQTT-Thema, das von Geräten und dem Thing Shadow-Service verwendet wird. Der Raspberry Pi veröffentlicht Nachrichten in der folgenden Form:
```
{
"reported": {
"moisture" : moisture-reading,
"temp" : temperature-reading
}
}
```
Sie erstellen eine Abfrage, die die Feuchtigkeits- und Temperaturdaten aus der eingehenden Nachricht extrahiert. Sie erstellen auch eine Amazon SNS-Aktion, die die Daten übernimmt und an Abonnenten des Amazon SNS-Themas sendet, wenn der Feuchtigkeitswert unter einem Schwellenwert liegt.
**Erstellen Sie eine Amazon SNS-Regel**
1. Wählen Sie in der [AWS IoT Konsole](https://console.aws.amazon.com/iot/home) **Nachrichtenrouting** und dann **Regeln** aus. Wenn das Dialogfeld **You don‘t have any rules yet (Sie haben noch keine Regeln)** angezeigt wird, wählen Sie **Create a rule (Regel erstellen)** aus. Wählen Sie andernfalls **Regel erstellen**.
1. Geben Sie auf der Seite mit den **Regeleigenschaften** einen **Regelnamen** wie **MoistureSensorRule** ein und geben Sie eine kurze **Regelbeschreibung** ein, z.B. **Sends an alert when soil moisture level readings are too low**.
1. Wählen Sie **Weiter** und konfigurieren Sie Ihre SQL-Anweisung. Wählen Sie die **SQL-Version** **2016-03-23** und geben Sie die folgende AWS IoT SQL-Abfrageanweisung ein:
```
SELECT * FROM '$aws/things/RaspberryPi/shadow/update/accepted' WHERE state.reported.moisture < 400
```
Diese Anweisung löst die Regelaktion aus, wenn der `moisture`-Lesevorgang kleiner als `400` ist.
**Anmerkung**
Möglicherweise müssen Sie einen anderen Wert verwenden. Nachdem Sie den Code auf Ihrem Raspberry Pi ausgeführt haben, können Sie die Werte sehen, die Sie von Ihrem Sensor erhalten, indem Sie den Sensor berühren, ihn in Wasser platzieren oder ihn in einem Übertopf platzieren.
1. Wählen Sie **Weiter** und hängen Sie Regelaktionen an. Wählen Sie für **Aktion 1** **Einfacher Benachrichtigungsservice** aus. Die Beschreibung für diese Regelaktion lautet **Eine Nachricht als SNS-Push-Benachrichtigung** senden.
1. **Wählen Sie als **SNS-Thema das Thema**, das Sie in, erstellt haben [Schritt 3: Erstellen eines Amazon-SNS-Themas und -Abonnements](iot-moisture-create-sns-topic.md) **MoistureSensorTopic**, und behalten Sie das **Nachrichtenformat** RAW bei.** Wählen Sie für **IAM Role (IAM-Rolle)** die Option **Create a New Role (Neue Rolle erstellen)** aus. Geben Sie einen Namen für die Rolle ein, beispielsweise **LowMoistureTopicRole**, und wählen Sie dann **Rolle erstellen** aus.
1. Wählen Sie **Weiter** aus, um die Regel zu überprüfen, und klicken Sie dann auf **Erstellen**, um die Regel zu erstellen.
# Einrichten des Raspberry Pi und des Feuchtesensors
Setzen Sie Ihre Micro-SD-Karte in den Raspberry Pi ein, schließen Sie Ihren Monitor, Ihre Tastatur, Ihre Maus und Ihr Ethernet-Kabel an, falls Sie kein WLAN verwenden. Schließen Sie das Stromkabel noch nicht an.
Schließen Sie das JST-Überbrückungskabel an den Feuchtigkeitssensor an. Die andere Seite des Kabels hat vier Drähte:
+ Grün: I2C SCL
+ Weiß: I2C SDA
+ Rot: Stromversorgung (3,5 V)
+ Schwarz: Erdung
Halten Sie den Raspberry Pi mit der Ethernet-Buchse auf der rechten Seite. In dieser Ausrichtung befinden sich oben zwei Reihen von GPIO-Stiften. Verbinden Sie die Drähte vom Feuchtigkeitssensor in der folgenden Reihenfolge mit der unteren Reihe der Stifte. Beginnen Sie mit dem Stift ganz links. Schließen Sie rot (Strom), weiß (SDA) und grün (SCL) an. Überspringen Sie einen Stift und schließen Sie dann den schwarzen Draht (Erdung) an. Weitere Informationen finden Sie unter [Python Computer Wiring](https://learn.adafruit.com/adafruit-stemma-soil-sensor-i2c-capacitive-moisture-sensor/python-circuitpython-test).
Schließen Sie das Stromkabel an den Raspberry Pi und das andere Ende an eine Steckdose an, um ihn einzuschalten.
**Konfigurieren Ihres Raspberry Pi**
1. Wählen Sie unter **Welcome to Raspberry Pi (Willkommen bei Raspberry Pi)**, **Next (Weiter)**.
1. Wählen Sie Ihr Land, Ihre Sprache, die Zeitzone und das Tastaturlayout. Wählen Sie **Weiter** aus.
1. Geben Sie ein Passwort für Ihren Raspberry Pi ein und wählen Sie dann **Next (Weiter)**.
1. Wählen Sie Ihr WLAN und klicken Sie dann auf **Next (Weiter)**. Wenn Sie kein WLAN verwenden, wählen Sie **Skip (Überspringen)** aus.
1. Wählen Sie **Next (Weiter)**, um nach Software-Updates zu suchen. Wenn die Updates abgeschlossen sind, wählen Sie **Restart (Neu starten)**, um Ihren Raspberry Pi neu zu starten.
Nach dem Start Ihres Raspberry Pi aktivieren Sie die I2C-Schnittstelle.
1. Klicken Sie in der oberen linken Ecke des Raspbian-Desktops auf das Raspberry-Symbol, wählen Sie **Preferences (Einstellungen)** und dann **Raspberry Pi Configuration (Raspberry Pi-Konfiguration)**.
1. Wählen Sie auf der Registerkarte **Interfaces (Schnittstellen)** für **I2C** die Option **Enable (Aktivieren)**.
1. Wählen Sie **OK** aus.
Die Bibliotheken für den STEMMA-Feuchtigkeitssensor von Adafruit sind dafür geschrieben. CircuitPython Um sie auf einem Raspberry Pi auszuführen, müssen Sie die neueste Version von Python 3 installieren.
1. Führen Sie die folgenden Befehle über eine Eingabeaufforderung aus, um Ihre Raspberry Pi-Software zu aktualisieren:
`sudo apt-get update`
`sudo apt-get upgrade`
1. Führen Sie den folgenden Befehl aus, um Ihre Python 3-Installation zu aktualisieren:
`sudo pip3 install --upgrade setuptools`
1. Führen Sie den folgenden Befehl aus, um die Raspberry Pi GPIO-Bibliotheken zu installieren:
`pip3 install RPI.GPIO`
1. Führen Sie den folgenden Befehl aus, um die Adafruit Blinka-Bibliotheken zu installieren:
`pip3 install adafruit-blinka`
Weitere Informationen finden Sie unter [ CircuitPython Bibliotheken auf dem Raspberry Pi installieren](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux/installing-circuitpython-on-raspberry-pi).
1. Führen Sie den folgenden Befehl aus, um die Adafruit Seesaw-Bibliotheken zu installieren:
`sudo pip3 install adafruit-circuitpython-seesaw`
1. Führen Sie den folgenden Befehl aus, um das AWS IoT Device SDK für Python zu installieren:
`pip3 install AWSIoTPythonSDK`
Ihr Raspberry Pi verfügt jetzt über alle erforderlichen Bibliotheken. Erstellen Sie eine Datei mit dem Namen **moistureSensor.py** und kopieren Sie den folgenden Python-Code in die Datei:
```
from adafruit_seesaw.seesaw import Seesaw
from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTShadowClient
from board import SCL, SDA
import logging
import time
import json
import argparse
import busio
# Shadow JSON schema:
#
# {
# "state": {
# "desired":{
# "moisture":,
# "temp":
# }
# }
# }
# Function called when a shadow is updated
def customShadowCallback_Update(payload, responseStatus, token):
# Display status and data from update request
if responseStatus == "timeout":
print("Update request " + token + " time out!")
if responseStatus == "accepted":
payloadDict = json.loads(payload)
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Update request with token: " + token + " accepted!")
print("moisture: " + str(payloadDict["state"]["reported"]["moisture"]))
print("temperature: " + str(payloadDict["state"]["reported"]["temp"]))
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Update request " + token + " rejected!")
# Function called when a shadow is deleted
def customShadowCallback_Delete(payload, responseStatus, token):
# Display status and data from delete request
if responseStatus == "timeout":
print("Delete request " + token + " time out!")
if responseStatus == "accepted":
print("~~~~~~~~~~~~~~~~~~~~~~~")
print("Delete request with token: " + token + " accepted!")
print("~~~~~~~~~~~~~~~~~~~~~~~\n\n")
if responseStatus == "rejected":
print("Delete request " + token + " rejected!")
# Read in command-line parameters
def parseArgs():
parser = argparse.ArgumentParser()
parser.add_argument("-e", "--endpoint", action="store", required=True, dest="host", help="Your device data endpoint")
parser.add_argument("-r", "--rootCA", action="store", required=True, dest="rootCAPath", help="Root CA file path")
parser.add_argument("-c", "--cert", action="store", dest="certificatePath", help="Certificate file path")
parser.add_argument("-k", "--key", action="store", dest="privateKeyPath", help="Private key file path")
parser.add_argument("-p", "--port", action="store", dest="port", type=int, help="Port number override")
parser.add_argument("-n", "--thingName", action="store", dest="thingName", default="Bot", help="Targeted thing name")
parser.add_argument("-id", "--clientId", action="store", dest="clientId", default="basicShadowUpdater", help="Targeted client id")
args = parser.parse_args()
return args
# Configure logging
# AWSIoTMQTTShadowClient writes data to the log
def configureLogging():
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Parse command line arguments
args = parseArgs()
if not args.certificatePath or not args.privateKeyPath:
parser.error("Missing credentials for authentication.")
exit(2)
# If no --port argument is passed, default to 8883
if not args.port:
args.port = 8883
# Init AWSIoTMQTTShadowClient
myAWSIoTMQTTShadowClient = None
myAWSIoTMQTTShadowClient = AWSIoTMQTTShadowClient(args.clientId)
myAWSIoTMQTTShadowClient.configureEndpoint(args.host, args.port)
myAWSIoTMQTTShadowClient.configureCredentials(args.rootCAPath, args.privateKeyPath, args.certificatePath)
# AWSIoTMQTTShadowClient connection configuration
myAWSIoTMQTTShadowClient.configureAutoReconnectBackoffTime(1, 32, 20)
myAWSIoTMQTTShadowClient.configureConnectDisconnectTimeout(10) # 10 sec
myAWSIoTMQTTShadowClient.configureMQTTOperationTimeout(5) # 5 sec
# Initialize Raspberry Pi's I2C interface
i2c_bus = busio.I2C(SCL, SDA)
# Intialize SeeSaw, Adafruit's Circuit Python library
ss = Seesaw(i2c_bus, addr=0x36)
# Connect to AWS IoT
myAWSIoTMQTTShadowClient.connect()
# Create a device shadow handler, use this to update and delete shadow document
deviceShadowHandler = myAWSIoTMQTTShadowClient.createShadowHandlerWithName(args.thingName, True)
# Delete current shadow JSON doc
deviceShadowHandler.shadowDelete(customShadowCallback_Delete, 5)
# Read data from moisture sensor and update shadow
while True:
# read moisture level through capacitive touch pad
moistureLevel = ss.moisture_read()
# read temperature from the temperature sensor
temp = ss.get_temp()
# Display moisture and temp readings
print("Moisture Level: {}".format(moistureLevel))
print("Temperature: {}".format(temp))
# Create message payload
payload = {"state":{"reported":{"moisture":str(moistureLevel),"temp":str(temp)}}}
# Update shadow
deviceShadowHandler.shadowUpdate(json.dumps(payload), customShadowCallback_Update, 5)
time.sleep(1)
```
Speichern Sie die Datei an einem Speicherort, an dem Sie sie finden können. Führen Sie `moistureSensor.py` über die Befehlszeile mit den folgenden Parametern aus:
Endpunkt
Ihr benutzerdefinierter AWS IoT Endpunkt. Weitere Informationen finden Sie unter [Geräteschatten-REST-API](device-shadow-rest-api.md).
rootCA
Der vollständige Pfad zu Ihrem AWS IoT Root-CA-Zertifikat.
cert
Der vollständige Pfad zu Ihrem AWS IoT Gerätezertifikat.
Schlüssel
Der vollständige Pfad zum privaten Schlüssel Ihres AWS IoT Gerätezertifikats.
thingName
Ihr Objektname (in diesem Fall `RaspberryPi`).
clientId
Die MQTT-Client-ID. Verwenden Sie `RaspberryPi`.
Die Befehlszeile sollte wie folgt aussehen:
`python3 moistureSensor.py --endpoint your-endpoint --rootCA ~/certs/AmazonRootCA1.pem --cert ~/certs/raspberrypi-certificate.pem.crt --key ~/certs/raspberrypi-private.pem.key --thingName RaspberryPi --clientId RaspberryPi`
Versuchen Sie, den Sensor zu berühren, ihn in einen Übertopf zu legen oder ihn in ein Glas Wasser zu legen, um zu sehen, wie der Sensor auf verschiedene Feuchtigkeitsstufen reagiert. Bei Bedarf können Sie den Schwellenwert in `MoistureSensorRule` ändern. Wenn der Messwert des Feuchtigkeitssensors unter den in der SQL-Abfrageanweisung Ihrer Regel angegebenen Wert fällt, wird eine Nachricht im Amazon SNS SNS-Thema AWS IoT veröffentlicht. Sie sollten eine E-Mail-Nachricht erhalten, die die Feuchtigkeits- und Temperaturdaten enthält.
Nachdem Sie den Empfang von E-Mail-Nachrichten von Amazon SNS überprüft haben, drücken Sie **CTRL\$1C (STRG\$1C)**, um das Python-Programm zu beenden. Es ist unwahrscheinlich, dass das Python-Programm so viele Nachrichten sendet, dass Kosten anfallen, aber es hat sich bewährt, das Programm zu beenden, wenn Sie fertig sind.