

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.

# Erstellen Sie ein virtuelles Gerät mit Amazon EC2
<a name="creating-a-virtual-thing"></a>

In diesem Tutorial erstellen Sie eine Amazon EC2-Instance, die als Ihr virtuelles Gerät in der Cloud dient.

Um dieses Tutorial abzuschließen, benötigen Sie eine 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.

**Topics**
+ [Eine Amazon-EC2-Instance konfigurieren](#set-up-ec2)
+ [Installiere Git, Node.js und konfiguriere die AWS CLI](#install-git-node)
+ [Erstellen Sie AWS IoT Ressourcen für Ihr virtuelles Gerät](#ec2-create-certificate)
+ [Installieren Sie das AWS IoT Geräte-SDK für JavaScript](#ec2-sdk)
+ [Ausführen der Beispielanwendungen](#ec2-run-app)
+ [Nachrichten aus der Beispiel-App in der AWS IoT Konsole anzeigen](#ec2-view-msg)

## Eine Amazon-EC2-Instance konfigurieren
<a name="set-up-ec2"></a>

Die folgenden Schritte zeigen Ihnen, wie Sie eine Amazon EC2-Instance erstellen, die anstelle eines physischen Geräts als Ihr virtuelles Gerät fungiert.

Wenn Sie zum ersten Mal eine Amazon EC2 EC2-Instance erstellen, sind die Anweisungen unter [Erste Schritte mit Amazon EC2 Linux-Instances](https://docs.aws.amazon.com//AWSEC2/latest/UserGuide/EC2_GetStarted.html) möglicherweise hilfreicher.

**So starten Sie eine Instance**

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Erweitern Sie im Konsolenmenü auf der linken Seite den Abschnitt **Instances** und wählen Sie **Instances** aus. Wählen Sie im **Instances**-Dashboard rechts die Option **Instances starten** aus, um eine Liste der Basiskonfigurationen anzuzeigen. 

1. Geben Sie im Abschnitt **Name und Tags** einen Namen für die Instance ein und fügen Sie optional Tags hinzu.

1. Wählen Sie im Abschnitt **Anwendungs- und Betriebssystem-Images (Amazon Machine Image)** eine AMI-Vorlage für Ihre Instance aus, z. B. *Amazon Linux 2 AMI (HVM)*. Diese AMIs sind als „Zur kostenlosen Nutzung berechtigt” gekennzeichnet.

1. Auf der Seite **Instance Type** können Sie die Hardware-Konfiguration Ihrer Instance auswählen. Wählen Sie den Typ `t2.micro` aus (Standardeinstellung). Beachten Sie, dass dieser Instance-Typ über die Berechtigung für das kostenlose Kontingent verfügt.

1. Wählen Sie im Abschnitt **Schlüsselpaar (Anmeldung)** einen Schlüsselpaar-Namen aus der Dropdown-Liste oder wählen Sie **Neues Schlüsselpaar erstellen**, um ein neues Schlüsselpaar zu erstellen. Wenn Sie ein neues Schlüsselpaar erstellen, stellen Sie sicher, dass Sie die private Schlüsseldatei herunterladen und an einem sicheren Ort speichern, da dies Ihre einzige Möglichkeit ist, sie herunterzuladen und zu speichern. Sie müssen den Namen für Ihr Schlüsselpaar beim Starten einer Instance angeben. Der entsprechende private Schlüssel muss jedes Mal angegeben werden, wenn Sie eine Verbindung mit der Instance herstellen.
**Warnung**  
Wählen Sie nicht die Option **Ohne Schlüsselpaar fortfahren** aus. Wenn Sie Ihre Instance ohne Schlüsselpaar starten, können Sie keine Verbindung zu ihr herstellen.

1. In den **Abschnitten Netzwerkeinstellungen** und **Speicher konfigurieren** können Sie die Standardeinstellungen beibehalten. Sobald Sie bereit sind, wählen Sie **Instance starten** aus.

1. Auf einer Bestätigungsseite wird Ihnen mitgeteilt, dass die Instance gestartet wird. Wählen Sie **View Instances** aus, um die Bestätigungsseite zu schließen und zur Konsole zurückzukehren.

1. Auf dem Bildschirm **Instances** können Sie den Status des Starts anzeigen. Es dauert einige Zeit, bis die Instance startet. Wenn Sie eine Instance starten, lautet ihr anfänglicher Status `pending`. Nachdem die Instance gestartet wurde, ändert sich der Status in `running`. Sie erhält dann einen öffentlichen DNS-Namen. (Wenn die Spalte **Public DNS (IPv4)** ausgeblendet ist, wählen Sie **Spalten ein-/ausblenden** (das zahnradförmige Symbol) in der oberen rechten Ecke der Seite und wählen Sie dann **Public** DNS () aus.) IPv4

1. Es kann einige Minuten dauern, bis die Instance für die Verbindungsherstellung bereit ist. Prüfen Sie, ob die Instance die Statusprüfungen bestanden hat. Sie finden diese Information in der Spalte **Status Checks**.

   Nachdem Ihre neue Instance die Statusprüfungen bestanden hat, fahren Sie mit dem nächsten Verfahren fort und stellen Sie eine Verbindung zu ihr her.

**So stellen Sie eine Verbindung zu Ihrer Instance her**

Sie können über die Amazon EC2-Konsole (browserbasierter Client) Verbindungen mit einer Instance herstellen, indem Sie die Instance in der Konsole auswählen und die Verbindung mittels Amazon EC2 Instance Connect festlegen. Instance Connect verarbeitet die Berechtigungen und stellt eine erfolgreiche Verbindung bereit.

1. Öffnen Sie die Amazon-EC2-Konsole unter [https://console.aws.amazon.com/ec2/](https://console.aws.amazon.com/ec2/).

1. Wählen Sie im linken Menü **Instances** aus.

1. Wählen Sie die Instance und **Connect (Verbinden)** aus.

1. Wählen Sie **Amazon EC2 Instance Connect**, **Connect**.

Sie sollten jetzt ein **Amazon EC2 Instance Connect**-Fenster haben, das bei Ihrer neuen Amazon EC2 Instance angemeldet ist.

## Installiere Git, Node.js und konfiguriere die AWS CLI
<a name="install-git-node"></a>

In diesem Abschnitt installieren Sie Git und Node.js auf Ihrer Linux-Instance.

**So installieren Sie Git**

1. Aktualisieren Sie Ihre **Instance in Ihrem Amazon EC2 Instance Connect**-Fenster mit dem folgenden Befehl.

   ```
   sudo yum update -y
   ```

1. Installieren Sie Git in Ihrem **Amazon EC2 Instance Connect**-Fenster mit dem folgenden Befehl.

   ```
   sudo yum install git -y
   ```

1. Führen Sie den folgenden Befehl aus, um zu überprüfen, ob Git installiert wurde und ob es sich um die aktuelle Version von Git handelt:

   ```
   git --version
   ```

**Installieren von Node.js**

1. Installieren Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster den Node Version Manager (nvm) mit dem folgenden Befehl.

   ```
   curl -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.34.0/install.sh | bash
   ```

   Wir verwenden nvm zum Installieren von Node.js, da nvm mehrere Versionen von Node.js installieren kann und die Möglichkeit bietet, zwischen diesen zu wechseln. 

1. Aktivieren Sie nvm in Ihrem **Amazon EC2 Instance Connect**-Fenster mit diesem Befehl.

   ```
   . ~/.nvm/nvm.sh
   ```

1. Verwenden Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster nvm, um die neueste Version von Node.js mit diesem Befehl zu installieren.

   ```
   nvm install 16
   ```
**Anmerkung**  
Dadurch wird die neueste LTS-Version von Node.js installiert.

   Beim Installieren von Node.js wird auch der Node Package Manager (npm) installiert, sodass Sie bei Bedarf zusätzliche Module installieren können.

1. Testen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster, ob Node.js installiert ist und ordnungsgemäß ausgeführt wird, indem Sie diesen Befehl verwenden.

   ```
   node -e "console.log('Running Node.js ' + process.version)"
   ```

    Dieses Tutorial erfordert Node v10.0 oder neuer. Weitere Informationen finden Sie unter [Tutorial: Einrichten von Node.js auf einer Amazon EC2-Instance](https://docs.aws.amazon.com/sdk-for-javascript/v2/developer-guide/setting-up-node-on-ec2-instance.html).

**Um zu konfigurieren AWS CLI**

Auf Ihrer Amazon EC2-Instance ist AWS CLI vorinstalliert. Sie müssen jedoch Ihr AWS CLI Profil vervollständigen. Weitere Informationen zum Konfigurieren Ihrer CLI finden Sie unter [Konfiguration von AWS CLI](https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-configure.html).

1. Das folgende Beispiel zeigt Beispielwerte. Ersetzen Sie sie mit Ihren eigenen Werten. Sie finden diese Werte in Ihrer [AWS -Konsole in Ihren Kontoinformationen unter **Sicherheitsanmeldedaten**](https://console.aws.amazon.com//iam/home#/security_credentials).

   Geben Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster diesen Befehl ein:

   ```
   aws configure
   ```

   Geben Sie dann an den angezeigten Eingabeaufforderungen die Werte aus Ihrem Konto ein.

   ```
   AWS Access Key ID [None]: AKIAIOSFODNN7EXAMPLE
   AWS Secret Access Key [None]: wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
   Default region name [None]: us-west-2
   Default output format [None]: json
   ```

1. Sie können Ihre AWS CLI Konfiguration mit diesem Befehl testen:

   ```
   aws iot describe-endpoint --endpoint-type iot:Data-ATS
   ```

   Wenn Ihr korrekt konfiguriert AWS CLI ist, sollte der Befehl eine Endpunktadresse von Ihrem zurückgeben AWS-Konto.

## Erstellen Sie AWS IoT Ressourcen für Ihr virtuelles Gerät
<a name="ec2-create-certificate"></a>

In diesem Abschnitt wird beschrieben, wie Sie AWS CLI das Ding-Objekt und seine Zertifikatsdateien direkt auf dem virtuellen Gerät erstellen können. Dies erfolgt direkt auf dem Gerät, um mögliche Komplikationen zu vermeiden, die entstehen könnten, wenn sie von einem anderen Computer auf das Gerät kopiert werden. In diesem Abschnitt erstellen Sie die folgenden Ressourcen für Ihr virtuelles Gerät:
+ Ein Ding-Objekt, in dem Ihr virtuelles Gerät dargestellt AWS IoT werden soll.
+ Ein Zertifikat zur Authentifizierung Ihres virtuellen Geräts.
+ Ein Richtliniendokument, mit dem Sie Ihr virtuelles Gerät autorisieren, eine Verbindung zu AWS IoT herzustellen und Nachrichten zu veröffentlichen, zu empfangen und zu abonnieren.

**Um ein AWS IoT Ding-Objekt in Ihrer Linux-Instanz zu erstellen**

Geräte, mit AWS IoT denen eine Verbindung besteht, werden *durch Ding-Objekte* in der AWS IoT Registrierung dargestellt. Ein *Objekt* stellt ein bestimmtes Gerät oder eine logische Entität dar. In diesem Fall repräsentiert Ihr *Objekt* Ihr virtuelles Gerät, diese Amazon EC2-Instance.

1. Führen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster den folgenden Befehl aus, um Ihr Objekt zu erstellen.

   ```
   aws iot create-thing --thing-name "MyIotThing"
   ```

1. Die JSON-Antwort sollte wie folgt aussehen:

   ```
   {
       "thingArn": "arn:aws:iot:your-region:your-aws-account:thing/MyIotThing", 
       "thingName": "MyIotThing",
       "thingId": "6cf922a8-d8ea-4136-f3401EXAMPLE"
   }
   ```

**Um AWS IoT Schlüssel und Zertifikate in Ihrer Linux-Instanz zu erstellen und anzuhängen**

Der Befehl **[create-keys-and-certificate](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/iot/create-keys-and-certificate.html)** erstellt Clientzertifikate, die von der Amazon Root-Zertifizierungsstelle signiert wurden. Dieses Zertifikat wird verwendet, um die Identität Ihres virtuellen Geräts zu authentifizieren.

1. Erstellen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster ein Verzeichnis zum Speichern Ihres Zertifikats und Ihrer Schlüsseldateien.

   ```
   mkdir ~/certs
   ```

1. Laden Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster mit diesem Befehl eine Kopie des Zertifikats der Amazon Certificate Authority (CA) herunter.

   ```
   curl -o ~/certs/Amazon-root-CA-1.pem \
       https://www.amazontrust.com/repository/AmazonRootCA1.pem
   ```

1. Führen Sie in Ihrem **Amazon EC2 Instance Connect-Fenster** den folgenden Befehl aus, um Ihre privaten Schlüssel-, öffentlichen Schlüssel- und X.509-Zertifikatsdateien zu erstellen. Dieser Befehl registriert und aktiviert auch das Zertifikat mit AWS IoT.

   ```
   aws iot create-keys-and-certificate \
       --set-as-active \
       --certificate-pem-outfile "~/certs/device.pem.crt" \
       --public-key-outfile "~/certs/public.pem.key" \
       --private-key-outfile "~/certs/private.pem.key"
   ```

   Die Antwort sieht wie folgt aus. Speichern Sie das `certificateArn`, damit Sie es in nachfolgenden Befehlen verwenden können. Sie benötigen es, um Ihr Zertifikat an Ihr Objekt anzuhängen und die Richtlinie in späteren Schritten an das Zertifikat anzuhängen.

   ```
   {
       "certificateArn": "arn:aws:iot:us-west-2:123456789012:cert/9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
       "certificateId": "9894ba17925e663f1d29c23af4582b8e3b7619c31f3fbd93adcb51ae54b83dc2",
       "certificatePem": "
   -----BEGIN CERTIFICATE-----
   MIICiTCCEXAMPLE6m7oRw0uXOjANBgkqhkiG9w0BAQUFADCBiDELMAkGA1UEBhMC
   VVMxCzAJBgNVBAgEXAMPLEAwDgYDVQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6
   b24xFDASBgNVBAsTC0lBTSEXAMPLE2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAd
   BgkqhkiG9w0BCQEWEG5vb25lQGFtYEXAMPLEb20wHhcNMTEwNDI1MjA0NTIxWhcN
   MTIwNDI0MjA0NTIxWjCBiDELMAkGA1UEBhMCEXAMPLEJBgNVBAgTAldBMRAwDgYD
   VQQHEwdTZWF0dGxlMQ8wDQYDVQQKEwZBbWF6b24xFDAEXAMPLEsTC0lBTSBDb25z
   b2xlMRIwEAYDVQQDEwlUZXN0Q2lsYWMxHzAdBgkqhkiG9w0BCQEXAMPLE25lQGFt
   YXpvbi5jb20wgZ8wDQYJKoZIhvcNAQEBBQADgY0AMIGJAoGBAMaK0dn+aEXAMPLE
   EXAMPLEfEvySWtC2XADZ4nB+BLYgVIk60CpiwsZ3G93vUEIO3IyNoH/f0wYK8m9T
   rDHudUZEXAMPLELG5M43q7Wgc/MbQITxOUSQv7c7ugFFDzQGBzZswY6786m86gpE
   Ibb3OhjZnzcvQAEXAMPLEWIMm2nrAgMBAAEwDQYJKoZIhvcNAQEFBQADgYEAtCu4
   nUhVVxYUntneD9+h8Mg9qEXAMPLEyExzyLwaxlAoo7TJHidbtS4J5iNmZgXL0Fkb
   FFBjvSfpJIlJ00zbhNYS5f6GuoEDEXAMPLEBHjJnyp378OD8uTs7fLvjx79LjSTb
   NYiytVbZPQUQ5Yaxu2jXnimvw3rrszlaEXAMPLE=
   -----END CERTIFICATE-----\n",
       "keyPair": {
           "PublicKey": "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkEXAMPLEQEFAAOCAQ8AMIIBCgKCAQEAEXAMPLE1nnyJwKSMHw4h\nMMEXAMPLEuuN/dMAS3fyce8DW/4+EXAMPLEyjmoF/YVF/gHr99VEEXAMPLE5VF13\n59VK7cEXAMPLE67GK+y+jikqXOgHh/xJTwo+sGpWEXAMPLEDz18xOd2ka4tCzuWEXAMPLEahJbYkCPUBSU8opVkR7qkEXAMPLE1DR6sx2HocliOOLtu6Fkw91swQWEXAMPLE\GB3ZPrNh0PzQYvjUStZeccyNCx2EXAMPLEvp9mQOUXP6plfgxwKRX2fEXAMPLEDa\nhJLXkX3rHU2xbxJSq7D+XEXAMPLEcw+LyFhI5mgFRl88eGdsAEXAMPLElnI9EesG\nFQIDAQAB\n-----END PUBLIC KEY-----\n",
           "PrivateKey": "-----BEGIN RSA PRIVATE KEY-----\nkey omitted for security reasons\n-----END RSA PRIVATE KEY-----\n"
       }
   }
   ```

1. Hängen Sie in Ihrem **Amazon EC2 Instance Connect-Fenster** Ihr Ding-Objekt mit dem Zertifikat an, das Sie gerade erstellt haben, indem Sie den *certificateArn* folgenden Befehl und die Antwort des vorherigen Befehls verwenden.

   ```
   aws iot attach-thing-principal \
       --thing-name "MyIotThing" \
       --principal "certificateArn"
   ```

   Dieser Befehl gibt keine Ausgabe zurück, wenn er erfolgreich ist.

**Erstellen und Anfügen einer Richtlinie**

1. Erstellen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster die Richtliniendatei, indem Sie dieses Richtliniendokument kopieren und in eine Datei mit dem Namen **\$1/policy.json** einfügen.

   Wenn Sie keinen bevorzugten Linux-Editor haben, können Sie **nano** mit diesem Befehl öffnen. 

   ```
   nano ~/policy.json
   ```

   Fügen Sie das Richtliniendokument für `policy.json` ein. Speichern Sie die Datei und beenden Sie den **nano**-Editor (Strg\$1X).

   Kopieren Sie den Inhalt des Richtliniendokuments für `policy.json`.  
****  

   ```
   {
       "Version":"2012-10-17",		 	 	 
       "Statement": [
           {
               "Effect": "Allow",
               "Action": [
                   "iot:Publish",
                   "iot:Subscribe",
                   "iot:Receive",
                   "iot:Connect"
               ],
               "Resource": [
                   "*"
               ]
           }
       ]
   }
   ```

1. Erstellen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster Ihre Richtlinie mithilfe des folgenden Befehls.

   ```
   aws iot create-policy \
       --policy-name "MyIotThingPolicy" \
       --policy-document "file://~/policy.json"
   ```

   Ausgabe:  
****  

   ```
   {
       "policyName": "MyIotThingPolicy",
       "policyArn": "arn:aws:iot:us-east-1:your-aws-account:policy/MyIotThingPolicy",
       "policyDocument": "{
           \"Version\": \"2012-10-17\",
           \"Statement\": [
               {
                   \"Effect\": \"Allow\",
                   \"Action\": [
                       \"iot:Publish\",
                       \"iot:Receive\",
                       \"iot:Subscribe\",
                       \"iot:Connect\"
                   ],
                   \"Resource\": [
                       \"*\"
                   ]
           }
           ]
       }",
       "policyVersionId": "1"
   }
   ```

1. Fügen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster die Richtlinie mithilfe des folgenden Befehls dem Zertifikat Ihres virtuellen Geräts hinzu.

   ```
   aws iot attach-policy \
       --policy-name "MyIotThingPolicy" \
       --target "certificateArn"
   ```

   Dieser Befehl gibt keine Ausgabe zurück, wenn er erfolgreich ist.

## Installieren Sie das AWS IoT Geräte-SDK für JavaScript
<a name="ec2-sdk"></a>

In diesem Abschnitt installieren Sie das AWS IoT Geräte-SDK für JavaScript. Es enthält den Code, mit dem Anwendungen kommunizieren können, AWS IoT sowie die Beispielprogramme. Weitere Informationen finden Sie im [AWS IoT Geräte-SDK für das JavaScript GitHub Repository](https://github.com/aws/aws-iot-device-sdk-js-v2).

**Um das AWS IoT Geräte-SDK für JavaScript auf Ihrer Linux-Instance zu installieren**

1. Klonen Sie in Ihrem **Amazon EC2 Instance Connect-Fenster mit** diesem Befehl das AWS IoT Geräte-SDK für das JavaScript Repository in das `aws-iot-device-sdk-js-v2` Verzeichnis Ihres Home-Verzeichnisses.

   ```
   cd ~
   git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
   ```

1. Navigieren Sie zum `aws-iot-device-sdk-js-v2`-Verzeichnis, das Sie im vorherigen Schritt erstellt haben.

   ```
   cd aws-iot-device-sdk-js-v2
   ```

1. Verwenden Sie zum Installieren der SDK npm.

   ```
   npm install
   ```

## Ausführen der Beispielanwendungen
<a name="ec2-run-app"></a>

 Bei den Befehlen im nächsten Abschnitt wird davon ausgegangen, dass Ihr Schlüssel und Ihr Zertifikatdateien wie in dieser Tabelle gezeigt auf Ihrem virtuellen Gerät gespeichert sind.


**Namen der Zertifikatsdateien**  

|  Datei  |  Dateipfad  | 
| --- | --- | 
|  Privater Schlüssel  |  `~/certs/private.pem.key`  | 
|  Gerätezertifikat  |  `~/certs/device.pem.crt`  | 
|  CA-Stammzertifikat  |  `~/certs/Amazon-root-CA-1.pem`  | 

In diesem Abschnitt installieren und führen Sie die `pub-sub.js` Beispiel-App aus, die Sie im `aws-iot-device-sdk-js-v2/samples/node` Verzeichnis des AWS IoT Geräte-SDK für JavaScript finden. Diese App zeigt, wie ein Gerät, Ihre Amazon EC2-Instance, die MQTT-Bibliothek verwendet, um MQTT-Nachrichten zu veröffentlichen und zu abonnieren. Die `pub-sub.js`-Beispiel-App abonniert ein Thema, `topic_1`, veröffentlicht 10 Nachrichten zu diesem Thema und zeigt die Nachrichten so an, wie sie vom Message Broker empfangen wurden.

**Um die Beispiel-App zu installieren und auszuführen**

1. Navigieren Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster zu dem Verzeichnis `aws-iot-device-sdk-js-v2/samples/node/pub_sub`, das das SDK erstellt hat, und installieren Sie die Beispiel-App mithilfe dieser Befehle.

   ```
   cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
   npm install
   ```

1. Rufen Sie in Ihrem **Amazon EC2 Instance Connect-Fenster** mit diesem Befehl AWS IoT von *your-iot-endpoint* ab.

   ```
   aws iot describe-endpoint --endpoint-type iot:Data-ATS
   ```

1. Fügen Sie in Ihrem **Amazon EC2 Instance Connect-Fenster** *your-iot-endpoint* wie angegeben den Befehl ein und führen Sie ihn aus.

   ```
   node dist/index.js --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
   ```

Die Beispiel-App:

1. Stellt eine Verbindung AWS IoT Core zu Ihrem Konto her.

1. Das Nachrichtenthema **topic\$11** abonniert und die Nachrichten anzeigt, die es zu diesem Thema erhält.

1. 10 Nachrichten zum Thema **topic\$11** veröffentlicht.

1. Ihre Ausgabe sieht ähnlich aus wie:

   ```
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":1}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":2}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":3}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":4}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":5}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":6}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":7}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":8}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":9}
   Publish received. topic:"topic_1" dup:false qos:1 retain:false
   {"message":"Hello world!","sequence":10}
   ```

Wenn Probleme bei der Ausführung der Beispiel-App auftreten, überprüfen Sie [Beheben Sie Probleme mit der Beispielanwendung](gs-device-troubleshoot.md).

Sie können den Parameter `--verbosity debug` auch zur Befehlszeile hinzufügen, sodass die Beispiel-App detaillierte Meldungen darüber anzeigt, was sie tut. Diese Informationen bieten Ihnen möglicherweise die Hilfe, die Sie zur Behebung des Problems benötigen.

## Nachrichten aus der Beispiel-App in der AWS IoT Konsole anzeigen
<a name="ec2-view-msg"></a>

Mithilfe des **MQTT-Testclients** in der **AWS IoT -Konsole** können Sie die Nachrichten der Beispiel-App sehen, während sie den Message Broker durchlaufen.

**Um die von der Beispiel-App veröffentlichten MQTT-Nachrichten anzuzeigen**

1. Sehen Sie sich [MQTT-Nachrichten mit dem AWS IoT MQTT-Client anzeigen](view-mqtt-messages.md) an. Auf diese Weise lernen Sie, wie Sie den **MQTT-Testclient** in der **AWS IoT -Konsole** verwenden, um MQTT-Nachrichten anzuzeigen, während sie den Message Broker passieren.

1. Öffnen Sie den **MQTT-Testclient** in der **AWS IoT -Konsole**.

1. Unter **Thema abonnieren**, Thema abonnieren, **topic\$11**.

1. Führen Sie in Ihrem **Amazon EC2 Instance Connect**-Fenster die Beispiel-App erneut aus und sehen Sie sich die Nachrichten im **MQTT-Testclient** in der **AWS IoT -Konsole an**.

   ```
   cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
   node dist/index.js --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
   ```

Weitere Informationen zu MQTT und zur AWS IoT Core Unterstützung des Protokolls finden Sie unter [MQTT](https://docs.aws.amazon.com//iot/latest/developerguide/mqtt.html).