

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.

# Bereiten Sie den Raspberry Pi vor, um die Kommunikation mit MQTT-Nachrichten zu demonstrieren
<a name="iot-dc-testconn-provision"></a>

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
<a name="iot-dc-testconn-provision-certs"></a>

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
<a name="iot-dc-testconn-provision-aws"></a>

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
<a name="iot-dc-testconn-provision-dc-config"></a>

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.