Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Tutorial: Demonstrieren Sie die MQTT-Nachrichtenkommunikation mit dem AWS IoT Device Client
Dieses Tutorial zeigt, wie der AWS IoT Device Client MQTT-Nachrichten abonnieren und veröffentlichen kann, die häufig in IoT-Lösungen verwendet werden.
**So beginnen Sie dieses Tutorial:**
+ Sie haben Ihren lokalen Host-Computer und den Raspberry Pi so konfiguriert, wie [im vorherigen Abschnitt](iot-dc-install-dc.md) zu sehen.
Wenn Sie das microSD-Karten-Image nach der Installation des AWS IoT Device Clients gespeichert haben, können Sie eine microSD-Karte mit diesem Image mit Ihrem Raspberry Pi verwenden.
+ Wenn Sie diese Demo schon einmal ausgeführt haben, überprüfen [Schritt 2: Bereinigen Sie Ihre Demos AWS-Konto nach dem Erstellen mit dem AWS IoT Device Client](iot-dc-cleanup.md#iot-dc-cleanup-cloud) Sie, ob Sie alle AWS IoT Ressourcen löschen sollten, die Sie in früheren Läufen erstellt haben, um doppelte Ressourcenfehler zu vermeiden.
Für dieses Tutorial brauchen Sie ungefähr 45 Minuten.
**Wenn Sie mit diesem Thema fertig sind:**
+ Sie haben verschiedene Möglichkeiten demonstriert, wie Ihr IoT-Gerät MQTT-Nachrichten abonnieren AWS IoT und MQTT-Nachrichten veröffentlichen kann. AWS IoT
**Erforderliche Ausstattung:**
+ Ihre lokale Entwicklungs- und Testumgebung aus [dem vorherigen Abschnitt](iot-dc-install-dc.md)
+ Der Raspberry Pi, den Sie im [vorherigen Abschnitt](iot-dc-install-dc.md) verwendet haben
+ Die microSD-Speicherkarte des Raspberry Pi, die Sie [im vorherigen Abschnitt](iot-dc-install-dc.md) verwendet haben
**Topics**
+ [Bereiten Sie den Raspberry Pi vor, um die Kommunikation mit MQTT-Nachrichten zu demonstrieren](iot-dc-testconn-provision.md)
+ [Demonstrieren Sie das Veröffentlichen von Nachrichten mit dem AWS IoT Device Client](iot-dc-testconn-publish.md)
+ [Demonstrieren Sie das Abonnieren von Nachrichten mit dem Device Client AWS IoT](iot-dc-testconn-subscribe.md)
# Bereiten Sie den Raspberry Pi vor, um die Kommunikation mit MQTT-Nachrichten zu demonstrieren
Dieses Verfahren erstellt die Ressourcen im AWS IoT und im Raspberry Pi, um die MQTT-Nachrichtenkommunikation mithilfe des AWS IoT Geräteclients zu demonstrieren.
**Topics**
+ [Erstellen der Zertifikatsdateien für die Demonstration der MQTT-Kommunikation](#iot-dc-testconn-provision-certs)
+ [Bereitstellen Ihres Geräts für die Demonstration der MQTT-Kommunikation](#iot-dc-testconn-provision-aws)
+ [Konfigurieren Sie die AWS IoT Device Client-Konfigurationsdatei und den MQTT-Testclient, um die MQTT-Kommunikation zu demonstrieren](#iot-dc-testconn-provision-dc-config)
## Erstellen der Zertifikatsdateien für die Demonstration der MQTT-Kommunikation
Mit diesem Verfahren werden die Gerätezertifikatsdateien für diese Demo erstellt.
**So erstellen Sie die Gerätezertifikatsdateien für Ihren Raspberry Pi und laden sie herunter:**
1. Geben Sie im Terminalfenster auf Ihrem lokalen Host-Computer den folgenden Befehl ein, um die Gerätezertifikatsdateien für Ihr Gerät zu erstellen.
```
mkdir ~/certs/pubsub
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "~/certs/pubsub/device.pem.crt" \
--public-key-outfile "~/certs/pubsub/public.pem.key" \
--private-key-outfile "~/certs/pubsub/private.pem.key"
```
Die Ausgabe des Befehls ähnelt der folgenden: Speichern Sie den `certificateArn`-Wert zur späteren Verwendung.
```
{
"certificateArn": "arn:aws:iot:us-west-2:57EXAMPLE833:cert/76e7e4edb3e52f52334be2f387a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificateId": "76e7e4edb3e52f5233EXAMPLE7a06145b2aa4c7fcd810f3aea2d92abc227d269",
"certificatePem": "-----BEGIN CERTIFICATE-----\nMIIDWTCCAkGgAwIBAgI_SHORTENED_FOR_EXAMPLE_Lgn4jfgtS\n-----END CERTIFICATE-----\n",
"keyPair": {
"PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BA_SHORTENED_FOR_EXAMPLE_ImwIDAQAB\n-----END PUBLIC KEY-----\n",
"PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nMIIEowIBAAKCAQE_SHORTENED_FOR_EXAMPLE_T9RoDiukY\n-----END RSA PRIVATE KEY-----\n"
}
}
```
1. Geben Sie die folgenden Befehle ein, um die Berechtigungen für das Zertifikatsverzeichnis und seine Dateien festzulegen.
```
chmod 700 ~/certs/pubsub
chmod 644 ~/certs/pubsub/*
chmod 600 ~/certs/pubsub/private.pem.key
```
1. Führen Sie diesen Befehl aus, um die Berechtigungen für Ihre Zertifikatsverzeichnisse und -dateien zu überprüfen.
```
ls -l ~/certs/pubsub
```
Der Befehl sollte ähnliche Werte wie die hier angezeigten ausgeben, mit der Ausnahme, dass Datum und Uhrzeit unterschiedlich sein werden.
```
-rw-r--r-- 1 pi pi 1220 Oct 28 13:02 device.pem.crt
-rw------- 1 pi pi 1675 Oct 28 13:02 private.pem.key
-rw-r--r-- 1 pi pi 451 Oct 28 13:02 public.pem.key
```
1. Geben Sie diese Befehle ein, um die Verzeichnisse für die Protokolldateien zu erstellen.
```
mkdir ~/.aws-iot-device-client
mkdir ~/.aws-iot-device-client/log
chmod 745 ~/.aws-iot-device-client/log
echo " " > ~/.aws-iot-device-client/log/aws-iot-device-client.log
echo " " > ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
chmod 600 ~/.aws-iot-device-client/log/*
```
## Bereitstellen Ihres Geräts für die Demonstration der MQTT-Kommunikation
In diesem Abschnitt werden die AWS IoT Ressourcen erstellt, in AWS IoT denen Ihr Raspberry Pi bereitgestellt wird.
**So stellen Sie Ihr Gerät in AWS IoT bereit:**
1. Geben Sie im Terminalfenster auf Ihrem lokalen Host-Computer den folgenden Befehl ein, um die Adresse des Gerätedatenendpunkts für Ihr AWS-Konto abzurufen.
```
aws iot describe-endpoint --endpoint-type IoT:Data-ATS
```
Der Endpunktwert hat sich seit der letzten Ausführung dieses Befehls im vorhergehenden Tutorial nicht geändert. Wenn Sie den Befehl hier erneut ausführen, können Sie den Datenendpunktwert leicht finden und in die in diesem Tutorial verwendete Konfigurationsdatei einfügen.
Der Befehl aus den vorhergehenden Schritten gibt eine Antwort aus, die der folgenden ähnelt: Notieren Sie sich den `endpointAddress`-Wert zur späteren Verwendung.
```
{
"endpointAddress": "a3qjEXAMPLEffp-ats.iot.us-west-2.amazonaws.com"
}
```
1. Geben Sie diesen Befehl ein, um eine neue Ding-Ressource AWS IoT für Ihren Raspberry Pi zu erstellen.
```
aws iot create-thing --thing-name "PubSubTestThing"
```
Da AWS IoT es sich bei einer Ding-Ressource um eine *virtuelle* Darstellung Ihres Geräts in der Cloud handelt, können wir mehrere Ding-Ressourcen erstellen, AWS IoT um sie für verschiedene Zwecke zu verwenden. Sie können alle von demselben physischen IoT-Gerät verwendet werden, um verschiedene Aspekte des Geräts darzustellen.
In diesen Tutorials wird jeweils nur eine Objektressource verwendet, um den Raspberry Pi darzustellen. Auf diese Weise stellen sie in diesen Tutorials die verschiedenen Demos dar, sodass Sie, nachdem Sie die AWS IoT Ressourcen für eine Demo erstellt haben, zurückgehen und die Demo wiederholen können, indem Sie die Ressourcen verwenden, die Sie jeweils speziell erstellt haben.
Wenn Ihre AWS IoT Ding-Ressource erstellt wurde, gibt der Befehl eine Antwort wie diese zurück.
```
{
"thingName": "PubSubTestThing",
"thingArn": "arn:aws:iot:us-west-2:57EXAMPLE833:thing/PubSubTestThing",
"thingId": "8ea78707-32c3-4f8a-9232-14bEXAMPLEfd"
}
```
1. Im Terminalfenster:
1. Öffnen Sie einen Texteditor, z. B. `nano`.
1. Kopieren Sie dieses JSON-Dokument und fügen Sie es in Ihren geöffneten Texteditor ein.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:client/PubSubTestThing"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/pubtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topicfilter/test/dc/subtopic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:123456789012:topic/test/dc/subtopic"
]
}
]
}
```
1. Ersetzen Sie im Editor in jedem `Resource` Abschnitt des Richtliniendokuments *us-west-2:57EXAMPLE833* durch Ihr AWS-Region, einen Doppelpunkt (:) und Ihre 12-stellige AWS-Konto Zahl.
1. Speichern Sie die Datei als **\$1/policies/pubsub\$1test\$1thing\$1policy.json** in Ihrem Texteditor.
1. Führen Sie diesen Befehl aus, um das Richtliniendokument aus den vorherigen Schritten zum Erstellen einer AWS IoT Richtlinie zu verwenden.
```
aws iot create-policy \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_test_thing_policy.json"
```
Wenn die Richtlinie erstellt wurde, gibt der Befehl eine Antwort wie die folgende zurück:
```
{
"policyName": "PubSubTestThingPolicy",
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n\"Version\": \"2012-10-17\", \n\"Statement\": [\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Connect\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Publish\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Subscribe\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic\"\n]\n},\n{\n\"Effect\": \"Allow\",\n\"Action\": [\n\"iot:Receive\"\n],\n\"Resource\": [\n\"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n]\n}\n]\n}\n",
"policyVersionId": "1"
}
```
1. Führen Sie diesen Befehl aus, um die Richtlinie an das Gerätezertifikat anzufügen. Ersetzen Sie `certificateArn` durch den `certificateArn`-Wert, den Sie in diesem Abschnitt bereits gespeichert haben.
```
aws iot attach-policy \
--policy-name "PubSubTestThingPolicy" \
--target "certificateArn"
```
Bei erfolgreicher Ausführung gibt dieser Befehl nichts zurück.
1. Führen Sie diesen Befehl aus, um das Gerätezertifikat an die AWS IoT -Objektressource anzuhängen. Ersetzen Sie `certificateArn` durch den `certificateArn`-Wert, den Sie in diesem Abschnitt bereits gespeichert haben.
```
aws iot attach-thing-principal \
--thing-name "PubSubTestThing" \
--principal "certificateArn"
```
Bei erfolgreicher Ausführung gibt dieser Befehl nichts zurück.
Nachdem Sie Ihr Gerät erfolgreich bereitgestellt haben AWS IoT, können Sie damit fortfahren[Konfigurieren Sie die AWS IoT Device Client-Konfigurationsdatei und den MQTT-Testclient, um die MQTT-Kommunikation zu demonstrieren](#iot-dc-testconn-provision-dc-config).
## Konfigurieren Sie die AWS IoT Device Client-Konfigurationsdatei und den MQTT-Testclient, um die MQTT-Kommunikation zu demonstrieren
Dieses Verfahren erstellt eine Konfigurationsdatei zum Testen des AWS IoT Geräteclients.
**Um die Konfigurationsdatei zum Testen des AWS IoT Geräteclients zu erstellen**
1. Gehen Sie im Terminalfenster auf Ihrem lokalen Host-Computer, der mit Ihrem Raspberry Pi verbunden ist, folgendermaßen vor:
1. Öffnen Sie einen Texteditor, z. B. `nano`.
1. Kopieren Sie dieses JSON-Dokument und fügen Sie es in Ihren geöffneten Texteditor ein.
```
{
"endpoint": "a3qEXAMPLEaffp-ats.iot.us-west-2.amazonaws.com",
"cert": "~/certs/pubsub/device.pem.crt",
"key": "~/certs/pubsub/private.pem.key",
"root-ca": "~/certs/AmazonRootCA1.pem",
"thing-name": "PubSubTestThing",
"logging": {
"enable-sdk-logging": true,
"level": "DEBUG",
"type": "STDOUT",
"file": ""
},
"jobs": {
"enabled": false,
"handler-directory": ""
},
"tunneling": {
"enabled": false
},
"device-defender": {
"enabled": false,
"interval": 300
},
"fleet-provisioning": {
"enabled": false,
"template-name": "",
"template-parameters": "",
"csr-file": "",
"device-key": ""
},
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
}
},
"config-shadow": {
"enabled": false
},
"sample-shadow": {
"enabled": false,
"shadow-name": "",
"shadow-input-file": "",
"shadow-output-file": ""
}
}
```
1. Ersetzen Sie den *endpoint* Wert durch den Gerätedatenendpunkt für Ihren AWS-Konto , den Sie in gefunden haben[Stellen Sie Ihr Gerät bereit in AWS IoT Core](iot-dc-install-provision.md#iot-dc-install-dc-provision).
1. Speichern Sie die Datei als **\$1/dc-configs/dc-pubsub-config.json** in Ihrem Texteditor.
1. Führen Sie diesen Befehl aus, um die Berechtigungen für die neue Konfigurationsdatei festzulegen.
```
chmod 644 ~/dc-configs/dc-pubsub-config.json
```
1. So bereiten Sie den **MQTT-Testclient** darauf vor, alle MQTT-Nachrichten zu abonnieren:
1. Wählen Sie auf Ihrem lokalen Host-Computer in der [AWS IoT -Konsole](https://console.aws.amazon.com//iot/home#/test) **MQTT-Testclient** aus.
1. Geben Sie auf der Registerkarte **Thema abonnieren** unter **Themenfilter** **\$1** (ein einzelnes Rautenzeichen) ein und wählen Sie **Abonnieren** aus.
1. Vergewissern Sie sich, dass Sie unter der Bezeichnung **Abonnements** **\$1** (ein einzelnes Pfundzeichen) sehen.
Lassen Sie das Fenster mit dem **MQTT-Testclient** geöffnet, während Sie mit diesem Tutorial fortfahren.
Nachdem Sie die Konfigurationsdatei gespeichert und den **MQTT-Testclient** konfiguriert haben, können Sie mit [Demonstrieren Sie das Veröffentlichen von Nachrichten mit dem AWS IoT Device Client](iot-dc-testconn-publish.md) fortfahren.
# Demonstrieren Sie das Veröffentlichen von Nachrichten mit dem AWS IoT Device Client
Die Verfahren in diesem Abschnitt zeigen, wie der AWS IoT Device Client standardmäßige und benutzerdefinierte MQTT-Nachrichten senden kann.
Die Richtlinienanweisungen in der Richtlinie, die Sie im vorherigen Schritt für diese Übungen erstellt haben, geben dem Raspberry Pi die Erlaubnis, die folgenden Aktionen auszuführen:
+
**`iot:Connect`**
Gibt dem genannten Client`PubSubTestThing`, Ihrem Raspberry Pi, auf dem der AWS IoT Geräteclient ausgeführt wird, die Möglichkeit, eine Verbindung herzustellen.
```
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing"
]
}
```
+
**`iot:Publish`**
Erteilt dem Raspberry Pi die Erlaubnis, Nachrichten mit dem MQTT-Thema von `test/dc/pubtopic` zu veröffentlichen.
```
{
"Effect": "Allow",
"Action": [
"iot:Publish"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic"
]
}
```
Die `iot:Publish`-Aktion erteilt die Erlaubnis zu Veröffentlichungen zu den MQTT-Themen, die im Resourcen-Array aufgeführt sind. Der *Inhalt* dieser Nachrichten wird nicht durch die Richtlinienanweisung geregelt.
## Veröffentlichen Sie die Standardnachricht mit dem AWS IoT Device Client
Bei diesem Verfahren wird der AWS IoT Device Client so ausgeführt, dass er eine einzige Standard-MQTT-Nachricht veröffentlicht, die der **MQTT-Testclient** empfängt und anzeigt.
**Um die Standard-MQTT-Nachricht vom Device Client aus zu senden AWS IoT**
1. Stellen Sie sicher, dass sowohl das Terminalfenster auf Ihrem lokalen Host-Computer, das mit dem Raspberry Pi verbunden ist, als auch das Fenster mit dem **MQTT-Testclient** sichtbar sind, während Sie dieses Verfahren ausführen.
1. Geben Sie im Terminalfenster diese Befehle ein, um den AWS IoT Geräteclient mithilfe der in [Erstellen der Konfigurationsdatei](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1) erstellten Konfigurationsdatei auszuführen.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-config.json
```
Im Terminalfenster zeigt der AWS IoT Geräteclient Informationsmeldungen und alle Fehler an, die bei der Ausführung auftreten.
Wenn im Terminalfenster keine Fehler angezeigt werden, überprüfen Sie den **MQTT-Testclient**.
1. Im **MQTT-Testclient** finden Sie im Fenster **Abonnements** die Nachricht *Hallo Welt\$1*, die an das `test/dc/pubtopic`-Nachrichtenthema gesendet wurde.
1. Wenn der AWS IoT Geräteclient keine Fehler anzeigt und Sie *Hello World\$1* sehen an die `test/dc/pubtopic` Nachricht im **MQTT-Testclient** gesendet, haben Sie eine erfolgreiche Verbindung nachgewiesen.
1. Geben Sie im Terminalfenster **^C** (Strg-C) ein, um den AWS IoT Geräteclient zu beenden.
Nachdem Sie nachgewiesen haben, dass der AWS IoT Device Client die Standard-MQTT-Nachricht veröffentlicht hat, können Sie mit dem fortfahren. [Veröffentlichen Sie eine benutzerdefinierte Nachricht mit dem AWS IoT Device Client](#iot-dc-testconn-publish-custom)
## Veröffentlichen Sie eine benutzerdefinierte Nachricht mit dem AWS IoT Device Client
Die Verfahren in diesem Abschnitt erstellen eine benutzerdefinierte MQTT-Nachricht und führen dann den AWS IoT Device Client aus, sodass er die benutzerdefinierte MQTT-Nachricht einmal veröffentlicht, damit der **MQTT-Testclient** sie empfangen und anzeigen kann.
### Erstellen Sie eine benutzerdefinierte MQTT-Nachricht für den Device Client AWS IoT
Führen Sie diese Schritte im Terminalfenster auf Ihrem lokalen Host-Computer aus, der mit Ihrem Raspberry Pi verbunden ist.
**Um eine benutzerdefinierte Nachricht für den AWS IoT Device Client zur Veröffentlichung zu erstellen**
1. Öffnen Sie im Terminalfenster einen Texteditor Ihrer Wahl, z. B. `nano`.
1. Kopieren Sie im Texteditor das folgende JSON-Dokument und fügen Sie es ein: Dies wird die MQTT-Nachrichtennutzlast sein, die der AWS IoT Geräteclient veröffentlicht.
```
{
"temperature": 28,
"humidity": 80,
"barometer": 1013,
"wind": {
"velocity": 22,
"bearing": 255
}
}
```
1. Speichern Sie den Inhalt des Texteditors als **\$1/messages/sample-ws-message.json**.
1. Geben Sie den folgenden Befehl ein, um die Berechtigungen der Nachrichtendatei festzulegen, die Sie gerade erstellt haben.
```
chmod 600 ~/messages/*
```
**Um eine Konfigurationsdatei für den AWS IoT Geräteclient zu erstellen, die zum Senden der benutzerdefinierten Nachricht verwendet werden soll**
1. Öffnen Sie im Terminalfenster in einem Texteditor wie `nano` z. B. die vorhandene AWS IoT Geräteclient-Konfigurationsdatei:**\$1/dc-configs/dc-pubsub-config.json**.
1. Bearbeiten Sie das `samples`-Objekt so, dass es folgendermaßen aussieht. Kein anderer Teil dieser Datei muss geändert werden.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
1. Speichern Sie den Inhalt des Texteditors als **\$1/dc-configs/dc-pubsub-custom-config.json**.
1. Führen Sie diesen Befehl aus, um die Berechtigungen für die neue Konfigurationsdatei festzulegen.
```
chmod 644 ~/dc-configs/dc-pubsub-custom-config.json
```
### Veröffentlichen Sie die benutzerdefinierte MQTT-Nachricht mit dem AWS IoT Device Client
Diese Änderung wirkt sich nur auf den *Inhalt* der MQTT-Nachrichtennutzlast aus, sodass die aktuelle Richtlinie weiterhin funktioniert. Wenn jedoch das *MQTT-Thema* (wie durch den `publish-topic`-Wert in `~/dc-configs/dc-pubsub-custom-config.json` definiert) geändert wurde, muss auch die `iot::Publish`-Richtlinienanweisung geändert werden, damit der Raspberry Pi unter dem neuen MQTT-Thema veröffentlichen kann.
**Um die MQTT-Nachricht vom Device Client aus zu senden AWS IoT**
1. Stellen Sie sicher, dass sowohl das Terminalfenster als auch das Fenster mit dem **MQTT-Testclient** sichtbar sind, während Sie dieses Verfahren ausführen. Stellen Sie außerdem sicher, dass Ihr **MQTT-Testclient** weiterhin den **\$1**-Themenfilter abonniert hat. Falls nicht, abonnieren Sie den **\$1**-Themenfilter erneut.
1. Geben Sie im Terminalfenster diese Befehle ein, um den AWS IoT Device Client mithilfe der in [Erstellen der Konfigurationsdatei](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1) erstellten Konfigurationsdatei auszuführen.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
Im Terminalfenster zeigt der AWS IoT Geräteclient Informationsmeldungen und alle Fehler an, die bei der Ausführung auftreten.
Wenn im Terminalfenster keine Fehler angezeigt werden, überprüfen Sie den MQTT-Testclient.
1. Im **MQTT-Testclient** finden Sie im Fenster **Abonnements** die benutzerdefinierte Nachrichtennutzlast „Hallo Welt\$1“, die an das `test/dc/pubtopic`-Nachrichtenthema gesendet wurde.
1. Wenn der AWS IoT Geräteclient keine Fehler anzeigt und Sie die Nutzdaten für benutzerdefinierte Nachrichten sehen, die Sie zu der `test/dc/pubtopic` Nachricht im **MQTT-Testclient** veröffentlicht haben, haben Sie eine benutzerdefinierte Nachricht erfolgreich veröffentlicht.
1. Geben Sie im Terminalfenster **^C** (Strg-C) ein, um den Device Client zu beenden. AWS IoT
Nachdem Sie nachgewiesen haben, dass der AWS IoT Device Client eine benutzerdefinierte Nachrichten-Payload veröffentlicht hat, können Sie damit fortfahren. [Demonstrieren Sie das Abonnieren von Nachrichten mit dem Device Client AWS IoT](iot-dc-testconn-subscribe.md)
# Demonstrieren Sie das Abonnieren von Nachrichten mit dem Device Client AWS IoT
In diesem Abschnitt werden Sie zwei Arten von Nachrichtenabonnements demonstrieren:
+ Abonnement für ein einzelnes Thema
+ Abonnement für Wildcard-Themen
Die Richtlinienanweisungen in der Richtlinie, die Sie für diese Übungen erstellt haben, geben dem Raspberry Pi die Erlaubnis, die folgenden Aktionen auszuführen:
+
**`iot:Receive`**
Erteilt dem AWS IoT Geräteclient die Erlaubnis, MQTT-Themen zu empfangen, die den `Resource` im Objekt genannten Themen entsprechen.
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/subtopic"
]
}
```
+
**`iot:Subscribe`**
Erteilt dem AWS IoT Geräteclient die Berechtigung, MQTT-Themenfilter zu abonnieren, die den `Resource` im Objekt genannten entsprechen.
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/subtopic"
]
}
```
## Abonnieren eines einzelnen MQTT-Nachrichtenthemas
Dieses Verfahren zeigt, wie der AWS IoT Device Client MQTT-Nachrichten abonnieren und protokollieren kann.
Listen Sie im Terminalfenster auf Ihrem lokalen Host-Computer, der mit Ihrem Raspberry Pi verbunden ist, den Inhalt der Datei von **\$1/dc-configs/dc-pubsub-custom-config.json** auf oder öffnen Sie die Datei in einem Texteditor, um den Inhalt zu überprüfen. Suchen Sie das `samples`-Objekt, das wie folgt aussehen sollte.
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/subtopic",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
Beachten Sie, dass der `subscribe-topic`-Wert das MQTT-Thema ist, das der AWS IoT Device Client bei der Ausführung abonniert. Der AWS IoT Device Client schreibt die Nachrichten-Payloads, die er von diesem Abonnement empfängt, in die `subscribe-file` im Wert angegebene Datei.
**Um ein MQTT-Nachrichtenthema vom Device Client aus zu abonnieren AWS IoT**
1. Stellen Sie sicher, dass sowohl das Terminalfenster als auch das Fenster mit dem MQTT-Testclient sichtbar sind, während Sie dieses Verfahren ausführen. Stellen Sie außerdem sicher, dass Ihr **MQTT-Testclient** weiterhin den **\$1**-Themenfilter abonniert hat. Falls nicht, abonnieren Sie den **\$1**-Themenfilter erneut.
1. Geben Sie im Terminalfenster diese Befehle ein, um den AWS IoT Device Client mithilfe der in [Erstellen der Konfigurationsdatei](iot-dc-install-configure.md#iot-dc-install-dc-configure-step1) erstellten Konfigurationsdatei auszuführen.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-custom-config.json
```
Im Terminalfenster zeigt der AWS IoT Geräteclient Informationsmeldungen und alle Fehler an, die bei der Ausführung auftreten.
Wenn im Terminalfenster keine Fehler angezeigt werden, fahren Sie in der AWS IoT -Konsole fort.
1. Wählen Sie in der AWS IoT Konsole im **MQTT-Testclient** die Registerkarte In **einem Thema veröffentlichen**.
1. Geben Sie in das Feld **Name des Themas** **test/dc/subtopic** ein.
1. Überprüfen Sie unter **Nachrichtennutzlast** den Nachrichteninhalt.
1. Wählen Sie **Veröffentlichen**, um die MQTT-Nachricht zu veröffentlichen.
1. Achten Sie im Terminalfenster auf den Eintrag „*Nachricht empfangen*“ vom AWS IoT Geräteclient, der wie folgt aussieht.
```
2021-11-10T16:02:20.890Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 45 bytes
```
1. Wenn Sie den Eintrag „*Nachricht empfangen*“ sehen, aus dem hervorgeht, dass die Nachricht empfangen wurde, geben Sie **^C** (Strg-C) ein, um den AWS IoT Geräteclient zu beenden.
1. Geben Sie diesen Befehl ein, um das Ende der Nachrichtenprotokolldatei und die Nachricht zu sehen, die Sie vom **MQTT-Testclient** aus veröffentlicht haben.
```
tail ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
Wenn Sie die Nachricht in der Protokolldatei angesehen haben, haben Sie nachgewiesen, dass der AWS IoT Device Client die von Ihnen über den MQTT-Testclient veröffentlichte Nachricht erhalten hat.
## Abonnieren mehrerer MQTT-Nachrichtenthemen mit Platzhalterzeichen
Diese Verfahren zeigen, wie der AWS IoT Device Client MQTT-Nachrichten mithilfe von Platzhalterzeichen abonnieren und protokollieren kann. Gehen Sie dazu wie folgt vor:
1. Aktualisieren Sie den Themenfilter, den der AWS IoT Device Client verwendet, um MQTT-Themen zu abonnieren.
1. Aktualisieren Sie die vom Gerät verwendete Richtlinie, um die neuen Abonnements zuzulassen.
1. Führen Sie den AWS IoT Device Client aus und veröffentlichen Sie Nachrichten von der MQTT-Testkonsole aus.
**So erstellen Sie eine Konfigurationsdatei, um mehrere MQTT-Nachrichtenthemen mithilfe eines MQTT-Themenfilters mit Platzhaltern zu abonnieren:**
1. Öffnen Sie im Terminalfenster auf Ihrem lokalen Host-Computer, der mit Ihrem Raspberry Pi verbunden ist, **\$1/dc-configs/dc-pubsub-custom-config.json**, um das `samples`-Objekt zu finden und zu bearbeiten.
1. Suchen Sie im Texteditor das `samples`-Objekt und aktualisieren Sie den `subscribe-topic`-Wert so, dass er folgendermaßen aussieht:
```
"samples": {
"pub-sub": {
"enabled": true,
"publish-topic": "test/dc/pubtopic",
"publish-file": "~/messages/sample-ws-message.json",
"subscribe-topic": "test/dc/#",
"subscribe-file": "~/.aws-iot-device-client/log/pubsub_rx_msgs.log"
```
Der neue `subscribe-topic`-Wert ist ein [MQTT-Themenfilter](topics.md#topicfilters) mit einem MQTT-Platzhalterzeichen am Ende. Dies beschreibt ein Abonnement für alle MQTT-Themen, die mit `test/dc/` beginnen. Der AWS IoT Geräteclient schreibt die Nachrichten-Payloads, die er von diesem Abonnement empfängt, in die unter genannte Datei. `subscribe-file`
1. Speichern Sie die geänderte Konfigurationsdatei als **\$1/dc-configs/dc-pubsub-wild-config.json** und schließen Sie den Editor.
**So ändern Sie die von Ihrem Raspberry Pi verwendete Richtlinie, um das Abonnieren und Empfangen mehrerer MQTT-Nachrichtenthemen zu ermöglichen:**
1. Öffnen Sie im Terminalfenster auf Ihrem lokalen Host-Computer, der mit Ihrem Raspberry Pi verbunden ist, in Ihrem bevorzugten Texteditor **\$1/policies/pubsub\$1test\$1thing\$1policy.json** zur Bearbeitung und suchen Sie dann die `iot::Subscribe`- und `iot::Receive`-Richtlinienanweisungen in der Datei.
1. Aktualisieren Sie in der `iot::Subscribe`-Richtlinienanweisung die Zeichenfolge im Ressourcenobjekt, indem Sie `subtopic` durch `*` ersetzten, sodass sie wie folgt aussieht:
```
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*"
]
}
```
**Anmerkung**
Die [Platzhalterzeichen für den MQTT-Themenfilter](topics.md#topicfilters) sind das `+` (Pluszeichen) und das `#` (Pfundzeichen). Eine Abonnementanfrage mit `#` am Ende abonniert alle Themen, die mit der Zeichenfolge beginnen, die dem `#`-Zeichen vorausgeht (zum Beispiel `test/dc/` in diesem Fall).
Der Ressourcenwert in der Richtlinienanweisung, die dieses Abonnement autorisiert, muss jedoch `*` (ein Sternchen) anstelle von `#` (ein Pfundzeichen) im Themenfilter ARN verwenden. Das liegt daran, dass der Richtlinienprozessor ein anderes Platzhalterzeichen verwendet als MQTT.
Weitere Informationen zur Verwendung von Platzhalterzeichen für Themen und Themenfilter in Richtlinien finden Sie unter [Verwendung von Platzhalterzeichen in MQTT und Richtlinien AWS IoT Core](pub-sub-policy.md#pub-sub-policy-cert).
1. Aktualisieren Sie in der `iot::Receive`-Richtlinienanweisung die Zeichenfolge im Ressourcenobjekt, indem Sie `subtopic` durch `*` ersetzten, sodass sie wie folgt aussieht:
```
{
"Effect": "Allow",
"Action": [
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*"
]
}
```
1. Speichern Sie das aktualisierte Richtliniendokument unter **\$1/policies/pubsub\$1wild\$1test\$1thing\$1policy.json** und schließen Sie den Editor.
1. Geben Sie diesen Befehl ein, um die Richtlinie für dieses Tutorial zu aktualisieren und die neuen Ressourcendefinitionen zu verwenden.
```
aws iot create-policy-version \
--set-as-default \
--policy-name "PubSubTestThingPolicy" \
--policy-document "file://~/policies/pubsub_wild_test_thing_policy.json"
```
Bei Erfolg gibt der Befehl ein Ergebnis wie dieses zurück: Beachten Sie, dass `policyVersionId` jetzt `2` ist, was darauf hindeutet, dass es sich um die zweite Version dieser Richtlinie handelt.
Wenn Sie die Richtlinie erfolgreich aktualisiert haben, können Sie mit dem nächsten Verfahren fortfahren.
```
{
"policyArn": "arn:aws:iot:us-west-2:57EXAMPLE833:policy/PubSubTestThingPolicy",
"policyDocument": "{\n \"Version\": \"2012-10-17\", \n \"Statement\": [\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Connect\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:client/PubSubTestThing\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Publish\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/pubtopic\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Subscribe\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topicfilter/test/dc/*\"\n ]\n },\n {\n \"Effect\": \"Allow\",\n \"Action\": [\n \"iot:Receive\"\n ],\n \"Resource\": [\n \"arn:aws:iot:us-west-2:57EXAMPLE833:topic/test/dc/*\"\n ]\n }\n ]\n}\n",
"policyVersionId": "2",
"isDefaultVersion": true
}
```
Wenn Sie die Fehlermeldung erhalten, dass zu viele Richtlinienversionen vorhanden sind, um eine neue zu speichern, geben Sie diesen Befehl ein, um die aktuellen Versionen der Richtlinie aufzulisten. Suchen Sie in der Liste, die dieser Befehl zurückgibt, nach einer Richtlinienversion, die Sie löschen können.
```
aws iot list-policy-versions --policy-name "PubSubTestThingPolicy"
```
Geben Sie diesen Befehl ein, um eine nicht mehr benötigte Version zu löschen. Beachten Sie, dass Sie die Standardversion der Richtlinie nicht löschen können. Die Standardversion der Richtlinie hat einen `isDefaultVersion`-Wert von `true`.
```
aws iot delete-policy-version \
--policy-name "PubSubTestThingPolicy" \
--policy-version-id policyId
```
Versuchen Sie diesen Schritt erneut, nachdem Sie eine Richtlinienversion gelöscht haben.
Mit der aktualisierten Konfigurationsdatei und der aktualisierten Richtlinie sind Sie bereit, Wildcard-Abonnements mit dem AWS IoT Device Client zu demonstrieren.
**Um zu demonstrieren, wie der AWS IoT Device Client mehrere MQTT-Nachrichtenthemen abonniert und empfängt**
1. Überprüfen Sie im **MQTT-Testclient** die Abonnements. Wenn der **MQTT-Testclient** den **\$1**-Themenfilter abonniert hat, fahren Sie mit dem nächsten Schritt fort. Falls nicht, geben Sie im **MQTT-Testclient** auf der Registerkarte **Thema abonnieren** im **Themenfilter** **\$1** (ein Pfundzeichen) ein und wählen Sie dann **Abonnieren** aus, um es zu abonnieren.
1. Gehen Sie im Terminalfenster auf Ihrem lokalen Host-Computer, der mit Ihrem Raspberry Pi verbunden ist, diese Befehle ein, um den AWS IoT Device Client zu starten.
```
cd ~/aws-iot-device-client/build
./aws-iot-device-client --config-file ~/dc-configs/dc-pubsub-wild-config.json
```
1. Kehren Sie zum **MQTT-Testclient** zurück, während Sie sich die Ausgabe des AWS IoT Device Clients im Terminalfenster auf dem lokalen Host-Computer ansehen. Geben Sie auf der Registerkarte **In einem Thema veröffentlichen** unter **Themenname** **test/dc/subtopic** ein, und wählen Sie dann **Veröffentlichen** aus.
1. Vergewissern Sie sich im Terminalfenster, dass die Nachricht empfangen wurde, indem Sie nach einer Nachricht suchen, wie z. B.:
```
2021-11-10T16:34:20.101Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 76 bytes
```
1. Kehren Sie zum **MQTT-Testclient** zurück, während Sie sich die AWS IoT Geräteclient-Ausgabe im Terminalfenster des lokalen Host-Computers ansehen. Geben Sie auf der Registerkarte **In einem Thema veröffentlichen** unter **Themenname** **test/dc/subtopic2** ein, und wählen Sie dann **Veröffentlichen** aus.
1. Vergewissern Sie sich im Terminalfenster, dass die Nachricht empfangen wurde, indem Sie nach einer Nachricht suchen, wie z. B.:
```
2021-11-10T16:34:32.078Z [DEBUG] {samples/PubSubFeature.cpp}: Message received on subscribe topic, size: 77 bytes
```
1. Wenn Sie die Meldungen sehen, die bestätigen, dass beide Nachrichten empfangen wurden, geben Sie **^C** (Strg-C) ein, um den AWS IoT Geräteclient zu beenden.
1. Geben Sie diesen Befehl ein, um das Ende der Nachrichtenprotokolldatei und die Nachricht zu sehen, die Sie vom **MQTT-Testclient** aus veröffentlicht haben.
```
tail -n 20 ~/.aws-iot-device-client/log/pubsub_rx_msgs.log
```
**Anmerkung**
Die Protokolldatei enthält nur Nachrichtennutzlasten. Die Nachrichtenthemen werden nicht in der Protokolldatei für empfangene Nachrichten aufgezeichnet.
Möglicherweise wird die vom AWS IoT Geräteclient veröffentlichte Nachricht auch im Empfangsprotokoll angezeigt. Das liegt daran, dass der Themenfilter mit Platzhaltern dieses Nachrichtenthema enthält und die Abonnementanforderung manchmal vom Message Broker verarbeitet werden kann, bevor die veröffentlichte Nachricht an Subscriber gesendet wird.
Die Einträge in der Protokolldatei belegen, dass die Nachrichten empfangen wurden. Sie können dieses Verfahren mit anderen Themennamen wiederholen. Alle Nachrichten, deren Themenname mit `test/dc/` beginnt, sollten empfangen und protokolliert werden. Nachrichten mit Themennamen, die mit einem anderen Text beginnen, werden ignoriert.
Nachdem Sie gezeigt haben, wie der AWS IoT Device Client MQTT-Nachrichten veröffentlichen und abonnieren kann, fahren Sie fort mit[Tutorial: Demonstrieren von Remote-Aktionen (Jobs) mit dem AWS IoT Device Client](iot-dc-runjobs.md).