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.
# Konfigurieren Ihres Geräts
In diesem Abschnitt wird beschrieben, wie Sie Ihr Gerät für die Verbindung mit AWS IoT Core konfigurieren. Wenn Sie damit beginnen möchten, AWS IoT Core aber noch kein Gerät haben, können Sie mithilfe von Amazon EC2 ein virtuelles Gerät erstellen oder Ihren Windows-PC oder Mac als IoT-Gerät verwenden.
Wählen Sie die beste Geräteoption aus, die Sie ausprobieren AWS IoT Core möchten. Natürlich können Sie alle ausprobieren, aber versuchen Sie es jeweils nur mit einer. Wenn Sie sich nicht sicher sind, welche Geräteoption für Sie am besten geeignet ist, lesen Sie, wie Sie [die beste Geräteoption](iot-gs-first-thing.md#choosing-a-gs-system) auswählen können, und kehren Sie dann zu dieser Seite zurück.
**Geräteoptionen**
+ [Erstellen Sie ein virtuelles Gerät mit Amazon EC2](creating-a-virtual-thing.md)
+ [Verwenden Sie Ihren Windows- oder Linux-PC oder Mac als Gerät AWS IoT](using-laptop-as-device.md)
+ [Verbinden eines Raspberry Pi oder eines anderes Gerätes](connecting-to-existing-device.md)
# Erstellen Sie ein virtuelles Gerät mit Amazon EC2
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
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
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
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
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
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
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).
# Verwenden Sie Ihren Windows- oder Linux-PC oder Mac als Gerät AWS IoT
In diesem Tutorial konfigurieren Sie einen PC für die Verwendung mit AWS IoT. Diese Anweisungen unterstützen Windows, Linux PCs und Macs. Um dies zu erreichen, müssen Sie einige Software auf Ihrem Computer installieren. Wenn Sie keine Software auf Ihrem Computer installieren möchten, können Sie mit [Erstellen Sie ein virtuelles Gerät mit Amazon EC2](creating-a-virtual-thing.md) versuchen, die gesamte Software auf einer virtuellen Maschine zu installieren.
**Topics**
+ [Einrichten Ihres PCs](#gs-pc-prereqs)
+ [Installieren Sie Git, Python und das AWS IoT Geräte-SDK für Python](#gs-pc-sdk-node)
+ [Konfigurieren Sie die Richtlinie und führen Sie die Beispielanwendung aus](#gs-pc-python-app-run)
+ [Nachrichten aus der Beispiel-App in der AWS IoT Konsole anzeigen](#gs-pc-view-msg)
+ [Führen Sie das Beispiel „Shared Subscription“ in Python aus](#gs-pc-shared-subscription-example)
## Einrichten Ihres PCs
Um dieses Tutorial abzuschließen, benötigen Sie einen Windows- oder Linux-PC oder einen Mac mit Internetverbindung.
Bevor Sie mit dem nächsten Schritt fortfahren, stellen Sie sicher, dass Sie ein Befehlszeilenfenster auf Ihrem Computer öffnen können. **cmd.exe** auf einem Windows-PC verwenden. Verwenden Sie auf einem Linux-PC oder Mac **Terminal**.
## Installieren Sie Git, Python und das AWS IoT Geräte-SDK für Python
In diesem Abschnitt installieren Sie Python und das AWS IoT Device SDK für Python auf Ihrem Computer.
### Installieren Sie die neueste Version von Git und Python
In diesem Verfahren wird erklärt, wie Sie die neueste Version von Git und Python auf Ihrem PC installieren.
**Um Git und Python herunterzuladen und auf Ihrem Computer zu installieren**
1. Überprüfen Sie, ob Git auf Ihrem Computer installiert ist. Geben Sie an der Befehlszeile den folgenden Befehl ein.
```
git --version
```
Wird mit dem Befehl die Git-Version angezeigt, ist Git installiert und Sie können mit dem nächsten Schritt fortfahren.
Wenn der Befehl einen Fehler anzeigt, öffnen Sie [https://git-scm.com/download](https://git-scm.com/download) und installieren Sie Git für Ihren Computer.
1. Überprüfen Sie, ob Python bereits installiert ist. Geben Sie in der Kommandozeile den Befehl ein.
```
python -V
```
**Anmerkung**
Wenn dieser Befehl einen Fehler: `Python was not found` ausgibt, liegt das möglicherweise daran, dass Ihr Betriebssystem die ausführbare Python v3.x-Datei als `Python3` aufruft. Ersetzen Sie in diesem Fall alle Instanzen von `python` durch `python3` und fahren Sie mit dem Rest dieses Tutorials fort.
Wenn der Befehl die Python-Version anzeigt, ist Python bereits installiert. Dieses Skript erfordert Python 3.7 oder höher.
1. Wenn Python installiert ist, können Sie die restlichen Schritte in diesem Abschnitt überspringen. Wenn nicht, fahren Sie fort.
1. Öffnen Sie [https://www.python.org/downloads/](https://www.python.org/downloads/) und laden Sie das Installationsprogramm für Ihren Computer herunter.
1. Wenn der Download nicht automatisch mit der Installation gestartet wurde, führen Sie das heruntergeladene Programm aus, um Python zu installieren.
1. Überprüfen Sie die Installation von Python.
```
python -V
```
Vergewissern Sie sich, dass der Befehl die Python-Version anzeigt. Wenn die Python-Version nicht angezeigt wird, versuchen Sie erneut, Python herunterzuladen und zu installieren.
### Installieren Sie das AWS IoT Geräte-SDK für Python
**So installieren Sie das AWS IoT Device SDK für Python auf Ihrem Computer**
1. Installieren Sie Version 2 des AWS IoT Geräte-SDK für Python.
```
python3 -m pip install awsiotsdk
```
1. Klonen Sie das AWS IoT Device SDK for Python-Repository in das Verzeichnis aws-iot-device-sdk -python-v2 Ihres Home-Verzeichnisses. Dieses Verfahren bezieht sich auf das Basisverzeichnis für die Dateien, unter denen Sie die Installation durchführen. *home*
Der tatsächliche Speicherort des *home* Verzeichnisses hängt von Ihrem Betriebssystem ab.
------
#### [ Linux/macOS ]
In macOS und Linux ist das *home* Verzeichnis`~`.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ Windows ]
In Windows können Sie den *home* Verzeichnispfad finden, indem Sie diesen Befehl im `cmd` Fenster ausführen.
```
echo %USERPROFILE%
cd %USERPROFILE%
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
**Anmerkung**
Wenn Sie Windows PowerShell anstelle von verwenden**cmd.exe**, verwenden Sie den folgenden Befehl.
```
echo $home
```
Weitere Informationen finden Sie im [ GitHub Repository AWS IoT Device SDK for Python](https://github.com/aws/aws-iot-device-sdk-python-v2).
### Vorbereiten der Ausführung von Beispielanwendungen
**Vorbereiten der Ausführung von Beispielanwendungen**
+ Erstellen des `certs` Verzeichnisses. Kopieren Sie die Dateien für den privaten Schlüssel, das Gerätezertifikat und das Stammzertifikat der Zertifizierungsstelle, die Sie bei der Erstellung und Registrierung des Objekts gespeichert haben, in [AWS IoT Ressourcen erstellen](create-iot-resources.md) des `certs` Verzeichnisses. Die Dateinamen der einzelnen Dateien im Zielverzeichnis sollten mit denen in der Tabelle übereinstimmen.
Bei den Befehlen im nächsten Abschnitt wird davon ausgegangen, dass Ihr Schlüssel und Ihre Zertifikatdateien wie in dieser Tabelle gezeigt auf dem Gerät gespeichert sind.
------
#### [ Linux/macOS ]
Führen Sie diesen Befehl aus, um das Unterverzeichnis `certs` zu erstellen, das Sie beim Ausführen der Beispielanwendungen verwenden werden.
```
mkdir ~/certs
```
Kopieren Sie die Dateien in das neue Unterverzeichnis in die Zieldateipfade, die in der folgenden Tabelle aufgeführt sind.
**Namen der Zertifikatsdateien**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/using-laptop-as-device.html)
Führen Sie diesen Befehl aus, um die Dateien im Verzeichnis `certs` aufzulisten und sie mit den in der Tabelle aufgeführten Dateien zu vergleichen.
```
ls -l ~/certs
```
------
#### [ Windows ]
Führen Sie diesen Befehl aus, um das Unterverzeichnis `certs` zu erstellen, das Sie beim Ausführen der Beispielanwendungen verwenden werden.
```
mkdir %USERPROFILE%\certs
```
Kopieren Sie die Dateien in das neue Unterverzeichnis in die Zieldateipfade, die in der folgenden Tabelle aufgeführt sind.
**Namen der Zertifikatsdateien**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/using-laptop-as-device.html)
Führen Sie diesen Befehl aus, um die Dateien im Verzeichnis `certs` aufzulisten und sie mit den in der Tabelle aufgeführten Dateien zu vergleichen.
```
dir %USERPROFILE%\certs
```
------
## Konfigurieren Sie die Richtlinie und führen Sie die Beispielanwendung aus
In diesem Abschnitt richten Sie Ihre Richtlinie ein und führen das `pubsub.py` Beispielskript aus, das sich im `aws-iot-device-sdk-python-v2/samples` Verzeichnis von befindet AWS IoT-Geräte-SDK for Python. Dieses Skript zeigt, wie Ihr Gerät die MQTT-Bibliothek verwendet, um MQTT-Nachrichten zu veröffentlichen und zu abonnieren.
Die `pubsub.py` Beispiel-App abonniert ein Thema, `test/topic`, veröffentlicht 10 Nachrichten zu diesem Thema und zeigt die Nachrichten so an, wie sie vom Message Broker empfangen wurden.
Zur Ausführung der Beispielanwendung `pubsub.py` benötigen Sie die folgenden Informationen:
**Anwendungsparameterwerte**
| Parameter | Wo der Wert gefunden werden kann |
| --- | --- |
| your-iot-endpoint | [\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/using-laptop-as-device.html) |
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`.
Bevor Sie das Skript ausführen, stellen Sie sicher, dass die Richtlinie für Ihr Objekt die Berechtigungen für das Beispielskript zum Herstellen einer Verbindung, zum Abonnieren, Veröffentlichen und Empfangen vorsieht.
**Um das Richtliniendokument für eine Objektressource zu finden und zu überprüfen**
1. Suchen Sie in der [AWS IoT -Konsole](https://console.aws.amazon.com//iot/home#/thinghub) in der Liste **Objekte** nach der Objektressource, die Ihrem Gerät entspricht.
1. Wählen Sie den Link **Name** der Objektressource, die für Ihr Gerät steht, um die Seite mit den **Objektdetails** zu öffnen.
1. Wählen Sie auf der Seite mit den **Objektdetails** auf der Registerkarte **Zertifikate** das Zertifikat aus, das an die Objektressource angehängt ist. Die Liste sollte nur ein Zertifikat enthalten. Wenn es mehrere gibt, wählen Sie das Zertifikat aus, dessen Dateien auf Ihrem Gerät installiert sind und mit dem eine Verbindung zu AWS IoT Core hergestellt werden soll.
Wählen Sie auf der Seite mit den **Zertifikatsdetails** auf der Registerkarte **Richtlinien** die Richtlinie aus, die mit dem Zertifikat verknüpft ist. Es sollte nur eine geben. Wenn es mehrere gibt, wiederholen Sie den nächsten Schritt für alle, um sicherzustellen, dass mindestens eine Richtlinie den erforderlichen Zugriff gewährt.
1. Suchen Sie auf der Seite mit der **Richtlinienübersicht** den JSON-Editor und wählen Sie **Richtliniendokument bearbeiten** aus, um das Richtliniendokument nach Bedarf zu überprüfen und zu bearbeiten.
1. Das Richtlinien-JSON wird im folgenden Beispiel angezeigt. Ersetzen Sie das `"Resource"` Element `region:account` durch Ihr AWS-Region und AWS-Konto in jedem der `Resource` Werte.
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iot:Publish",
"iot:Receive"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Subscribe"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/test/topic"
]
},
{
"Effect": "Allow",
"Action": [
"iot:Connect"
],
"Resource": [
"arn:aws:iot:us-east-1:123456789012:client/test-*"
]
}
]
}
```
------
#### [ Linux/macOS ]
**Um das Beispielskript unter Linux/macOS auszuführen**
1. Navigieren Sie in Ihrem Befehlszeilenfenster zu dem `~/aws-iot-device-sdk-python-v2/samples/node/pub_sub`-Verzeichnis, das das SDK mithilfe dieser Befehle erstellt hat.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Ersetzen Sie in Ihrem Befehlszeilenfenster *your-iot-endpoint* wie angegeben und führen Sie diesen Befehl aus.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key
```
------
#### [ Windows ]
**Um die Beispiel-App auf einem Windows-PC auszuführen**
1. Navigieren Sie in Ihrem Befehlszeilenfenster zu dem `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples`-Verzeichnis, das das SDK erstellt hat, und installieren Sie die Beispiel-App mithilfe dieser Befehle.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Ersetzen Sie in Ihrem Befehlszeilenfenster *your-iot-endpoint* wie angegeben und führen Sie diesen Befehl aus.
```
python3 pubsub.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key
```
------
Das Beispielskript:
1. Stellt eine Verbindung mit dem AWS IoT Core für Ihr Konto her.
1. Abonniert das Nachrichtenthema **test/topic** und zeigt die Nachrichten an, die es zu diesem Thema erhält.
1. Veröffentlicht 10 Nachrichten zum Thema **test/topic**.
1. Die Ausgabe sieht ähnlich aus wie:
```
Connected!
Subscribing to topic 'test/topic'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'test/topic': Hello World! [1]
Received message from topic 'test/topic': b'"Hello World! [1]"'
Publishing message to topic 'test/topic': Hello World! [2]
Received message from topic 'test/topic': b'"Hello World! [2]"'
Publishing message to topic 'test/topic': Hello World! [3]
Received message from topic 'test/topic': b'"Hello World! [3]"'
Publishing message to topic 'test/topic': Hello World! [4]
Received message from topic 'test/topic': b'"Hello World! [4]"'
Publishing message to topic 'test/topic': Hello World! [5]
Received message from topic 'test/topic': b'"Hello World! [5]"'
Publishing message to topic 'test/topic': Hello World! [6]
Received message from topic 'test/topic': b'"Hello World! [6]"'
Publishing message to topic 'test/topic': Hello World! [7]
Received message from topic 'test/topic': b'"Hello World! [7]"'
Publishing message to topic 'test/topic': Hello World! [8]
Received message from topic 'test/topic': b'"Hello World! [8]"'
Publishing message to topic 'test/topic': Hello World! [9]
Received message from topic 'test/topic': b'"Hello World! [9]"'
Publishing message to topic 'test/topic': Hello World! [10]
Received message from topic 'test/topic': b'"Hello World! [10]"'
10 message(s) received.
Disconnecting...
Disconnected!
```
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 können Ihnen bei der Behebung des Problems helfen.
## Nachrichten aus der Beispiel-App in der AWS IoT Konsole anzeigen
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. Abonnieren Sie unter **Thema abonnieren** das Thema **Test/Thema.**
1. Führen Sie in Ihrem Befehlszeilenfenster die Beispiel-App erneut aus und sehen Sie sich die Nachrichten im **MQTT-Client** in der **AWS IoT -Konsole** an.
------
#### [ Linux/macOS ]
```
cd ~/aws-iot-device-sdk-python-v2/samples
python3 pubsub.py --topic test/topic --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --endpoint your-iot-endpoint
```
------
#### [ Windows ]
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
python3 pubsub.py --topic test/topic --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\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).
## Führen Sie das Beispiel „Shared Subscription“ in Python aus
AWS IoT Core unterstützt [Shared Subscriptions](mqtt.md#mqtt5-shared-subscription) sowohl für MQTT 3 als auch für MQTT 5. Gemeinsame Abonnements ermöglichen es mehreren Clients, ein Abonnement für ein Thema gemeinsam zu nutzen, und nur ein Client erhält Nachrichten, die zu diesem Thema veröffentlicht wurden, nach dem Zufallsprinzip. Um gemeinsame Abonnements zu verwenden, abonnieren Clients den [Themenfilter](https://docs.aws.amazon.com//iot/latest/developerguide/topics.html#topicfilters) eines gemeinsamen Abonnements: `$share/{ShareName}/{TopicFilter}`.
**So konfigurieren Sie die Richtlinie und führen das Beispiel für ein geteiltes Abonnement aus**
1. Um das Beispiel Gemeinsame Abonnements auszuführen, müssen Sie die Richtlinie Ihres Objekts so einrichten, wie es in [MQTT 5 Gemeinsame Abonnements](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription) dokumentiert ist.
1. Führen Sie die folgenden Befehle aus, um das Gemeinsame Abonnements-Beispiel auszuführen.
------
#### [ Linux/macOS ]
**Um das Beispielskript unter Linux/macOS auszuführen**
1. Navigieren Sie in Ihrem Befehlszeilenfenster zu dem `~/aws-iot-device-sdk-python-v2/samples`-Verzeichnis, das das SDK mithilfe dieser Befehle erstellt hat.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Ersetzen Sie in Ihrem Befehlszeilenfenster *your-iot-endpoint* wie angegeben und führen Sie diesen Befehl aus.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file ~/certs/Amazon-root-CA-1.pem --cert ~/certs/device.pem.crt --key ~/certs/private.pem.key --group_identifier consumer
```
------
#### [ Windows ]
**Um die Beispiel-App auf einem Windows-PC auszuführen**
1. Navigieren Sie in Ihrem Befehlszeilenfenster zu dem `%USERPROFILE%\aws-iot-device-sdk-python-v2\samples`-Verzeichnis, das das SDK erstellt hat, und installieren Sie die Beispiel-App mithilfe dieser Befehle.
```
cd %USERPROFILE%\aws-iot-device-sdk-python-v2\samples
```
1. Ersetzen Sie in Ihrem Befehlszeilenfenster *your-iot-endpoint* wie angegeben und führen Sie diesen Befehl aus.
```
python3 mqtt5_shared_subscription.py --endpoint your-iot-endpoint --ca_file %USERPROFILE%\certs\Amazon-root-CA-1.pem --cert %USERPROFILE%\certs\device.pem.crt --key %USERPROFILE%\certs\private.pem.key --group_identifier consumer
```
------
**Anmerkung**
Sie können optional eine Gruppen-ID angeben, die Ihren Anforderungen entspricht, wenn Sie das Beispiel ausführen (z. B. `--group_identifier consumer`). Wenn Sie kein angeben, ist `python-sample` der Standardgruppen-Identifier.
1. Die Ausgabe in Ihrer Befehlszeile kann wie folgt aussehen:
```
Publisher]: Lifecycle Connection Success
[Publisher]: Connected
Subscriber One]: Lifecycle Connection Success
[Subscriber One]: Connected
Subscriber Two]: Lifecycle Connection Success
[Subscriber Two]: Connected
[Subscriber One]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Subscriber Two]: Subscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full subscribed topic is: '$share/consumer/test/topic' with SubAck code: []
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [1]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [2]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [3]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [4]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [5]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [6]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [7]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [8]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber Two] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [9]"'
[Publisher]: Sent publish and got PubAck code:
[Subscriber One] Received a publish
Publish received message on topic: test/topic
Message: b'"Hello World! [10]"'
[Subscriber One]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber One]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code: []
[Subscriber Two]: Unsubscribed to topic 'test/topic' in shared subscription group 'consumer'.
[Subscriber Two]: Full unsubscribed topic is: '$share/consumer/test/topic' with UnsubAck code []
Publisher]: Lifecycle Disconnected
[Publisher]: Lifecycle Stopped
[Publisher]: Fully stopped
Subscriber One]: Lifecycle Disconnected
[Subscriber One]: Lifecycle Stopped
[Subscriber One]: Fully stopped
Subscriber Two]: Lifecycle Disconnected
[Subscriber Two]: Lifecycle Stopped
[Subscriber Two]: Fully stopped
Complete!
```
1. Öffnen Sie den **MQTT-Testclient** in der **AWS IoT -Konsole**. Abonnieren Sie unter **Thema abonnieren** das Thema des gemeinsamen Abonnements, z. B.: `$share/consumer/test/topic`. Sie können bei der Ausführung des Beispiels eine Gruppen-ID angeben, die Ihren Anforderungen entspricht (z. B. `--group_identifier consumer`). Wenn Sie keine Gruppen-ID angeben, ist der Standardwert `python-sample`. Weitere Informationen finden Sie im [Python-Beispiel für MQTT 5 Shared Subscription](https://github.com/aws/aws-iot-device-sdk-python-v2/blob/main/samples/mqtt5_shared_subscription.md#mqtt5-shared-subscription) und im *AWS IoT Core Developer Guide* unter [Shared Subscriptions](mqtt.md#mqtt5-shared-subscription).
Führen Sie in Ihrem Befehlszeilenfenster die Beispiel-App erneut aus und beobachten Sie die Verteilung der Nachrichten in Ihrem **MQTT-Testclient** der **AWS IoT -Konsole** und der Befehlszeile.
![\[Die Ausgabeseite für gemeinsame Abonnements.\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/images/shared-subscription-output.png)
# Verbinden eines Raspberry Pi oder eines anderes Gerätes
In diesem Abschnitt konfigurieren wir einen Raspberry Pi für die Verwendung mit AWS IoT. Wenn Sie ein anderes Gerät haben, das Sie anschließen möchten, finden Sie in der Anleitung für den Raspberry Pi Hinweise, die Ihnen helfen können, diese Anweisungen an Ihr Gerät anzupassen.
Dies dauert normalerweise etwa 20 Minuten, kann aber länger dauern, wenn Sie viele Systemsoftware-Upgrades installieren müssen.
**Topics**
+ [Einrichten Ihres Geräts](#gs-device-prereqs)
+ [Installieren Sie die erforderlichen Tools und Bibliotheken für das AWS IoT Geräte-SDK](#gs-device-sdk-tools)
+ [Installieren Sie AWS IoT das Geräte-SDK](#gs-device-install-sdk)
+ [Installieren und Ausführen der Beispiel-App](#gs-device-node-app-run)
+ [Nachrichten aus der Beispiel-App in der AWS IoT Konsole anzeigen](#gs-device-view-msg)
**Wichtig**
Die Anpassung dieser Anweisungen an andere Geräte und Betriebssysteme kann schwierig 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 bei der Konfiguration Ihres Geräts für auf Schwierigkeiten stoßen AWS IoT, 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).
## Einrichten Ihres Geräts
Ziel dieses Schritts ist es, alles zu sammeln, was Sie benötigen, um Ihr Gerät so zu konfigurieren, dass es das Betriebssystem (OS) starten, eine Verbindung zum Internet herstellen und Ihnen die Interaktion mit dem Gerät über eine Befehlszeilenschnittstelle ermöglichen kann.
Zum Durcharbeiten dieses Tutorials ist Folgendes erforderlich:
+ 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.
+ Ein [Raspberry Pi 3 Modell B](https://www.raspberrypi.com/products/) oder ein neueres Modell. Dies funktioniert möglicherweise auf früheren Versionen des Raspberry Pi, diese wurden jedoch 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, wurden jedoch nicht getestet.
Um dieses Beispiel auszuführen, müssen Sie den Desktop nicht mit der grafischen Benutzeroberfläche (GUI) installieren. Wenn Sie jedoch mit dem Raspberry Pi noch nicht vertraut sind und Ihre Raspberry Pi-Hardware ihn unterstützt, ist es möglicherweise einfacher, den Desktop mit der GUI zu verwenden.
+ Ein Ethernet oder eine WiFi Verbindung.
+ Tastatur, Maus, Monitor, Kabel, Netzteile und andere Hardware, die für Ihr Gerät erforderlich ist.
**Wichtig**
Bevor Sie mit dem nächsten Schritt fortfahren, muss das Betriebssystem Ihres Geräts installiert, konfiguriert und ausgeführt werden. Das Gerät muss mit dem Internet verbunden sein und Sie müssen über die Befehlszeilenschnittstelle auf das Gerät zugreifen können. Der Befehlszeilenzugriff kann über eine direkt verbundene Tastatur, Maus und einen Monitor oder über eine SSH-Terminal-Fernschnittstelle erfolgen.
Wenn Sie auf Ihrem Raspberry Pi ein Betriebssystem mit grafischer Benutzeroberfläche (GUI) ausführen, öffnen Sie ein Terminalfenster auf dem Gerät und führen Sie in diesem Fenster die folgenden Anweisungen aus. Andernfalls, wenn Sie über ein Remote-Terminal wie PuTTY eine Verbindung zu Ihrem Gerät herstellen, öffnen Sie ein Remote-Terminal für Ihr Gerät und verwenden Sie dieses.
## Installieren Sie die erforderlichen Tools und Bibliotheken für das AWS IoT Geräte-SDK
Bevor Sie das AWS IoT Geräte-SDK und den Beispielcode installieren, stellen Sie sicher, dass Ihr System auf dem neuesten Stand ist und über die erforderlichen Tools und Bibliotheken für die Installation von verfügt SDKs.
1.
**Aktualisieren Sie das Betriebssystem und installieren Sie die erforderlichen Bibliotheken**
Bevor Sie ein AWS IoT Geräte-SDK installieren, führen Sie diese Befehle in einem Terminalfenster auf Ihrem Gerät aus, um das Betriebssystem zu aktualisieren und die erforderlichen Bibliotheken zu installieren.
```
sudo apt-get update
```
```
sudo apt-get upgrade
```
```
sudo apt-get install cmake
```
```
sudo apt-get install libssl-dev
```
1.
**Installieren Sie Git**
Wenn auf dem Betriebssystem Ihres Geräts Git nicht installiert ist, müssen Sie es installieren, um das AWS IoT Geräte-SDK für zu installieren JavaScript.
1. Testen Sie, ob Git bereits installiert ist, indem Sie diesen Befehl ausführen.
```
git --version
```
1. Wenn der vorherige Befehl die Git-Version anzeigt, ist Git bereits installiert und Sie können mit Schritt 3 fortfahren.
1. Wenn bei der Ausführung des Befehls **git** ein Fehler angezeigt wird, installieren Sie Git, indem Sie diesen Befehl ausführen.
```
sudo apt-get install git
```
1. Testen Sie erneut, ob Git installiert ist, indem Sie diesen Befehl ausführen.
```
git --version
```
1. Wenn Git installiert ist, fahren Sie mit dem nächsten Abschnitt fort. Wenn nicht, beheben Sie den Fehler und korrigieren Sie ihn, bevor Sie fortfahren. Sie benötigen Git, um das AWS IoT Device SDK für zu installieren JavaScript.
## Installieren Sie AWS IoT das Geräte-SDK
Installieren Sie das AWS IoT Geräte-SDK.
------
#### [ Python ]
In diesem Abschnitt installieren Sie Python, seine Entwicklungstools und das AWS IoT Device SDK für Python auf Ihrem Gerät. Diese Anweisungen gelten für einen Raspberry Pi, auf dem das neueste Raspberry Pi-Betriebssystem ausgeführt wird. Wenn Sie mit einem anderen Gerät arbeiten oder ein anderes Betriebssystem verwenden, müssen Sie diese Anweisungen für Ihr Gerät anpassen.
1.
**Installieren Sie Python und seine Entwicklungstools**
Für das AWS IoT Device SDK für Python muss Python v3.5 oder höher auf Ihrem Raspberry Pi installiert sein.
Führen Sie diese Befehle in einem Terminalfenster auf Ihrem Gerät aus.
1. Führen Sie diesen Befehl aus, um die auf Ihrem Gerät installierte Python-Version zu bestimmen.
```
python3 --version
```
Wenn Python installiert ist, wird seine Version angezeigt.
1. Wenn die angezeigte Version `Python 3.5` oder höher ist, können Sie mit Schritt 2 fortfahren.
1. Wenn die angezeigte Version niedriger als `Python 3.5` ist, können Sie die richtige Version installieren, indem Sie diesen Befehl ausführen.
```
sudo apt install python3
```
1. Führen Sie diesen Befehl aus, um zu bestätigen, dass die richtige Version von Python jetzt installiert ist.
```
python3 --version
```
1.
**Testen Sie auf pip3**
Führen Sie diese Befehle in einem Terminalfenster Ihres Geräts aus.
1. Führen Sie diesen Befehl aus, um zu sehen, ob **pip3** installiert ist.
```
pip3 --version
```
1. Wenn der Befehl eine Versionsnummer zurückgibt, ist **pip3** installiert und Sie können mit Schritt 3 fortfahren.
1. Wenn der vorherige Befehl einen Fehler zurückgibt, führen Sie diesen Befehl zur Installation von **pip3** aus.
```
sudo apt install python3-pip
```
1. Führen Sie diesen Befehl aus, um zu sehen, ob **pip3** installiert ist.
```
pip3 --version
```
1.
**Installieren Sie das aktuelle AWS IoT Geräte-SDK für Python**
Installieren Sie das AWS IoT Device SDK für Python und laden Sie die Beispiel-Apps auf Ihr Gerät herunter.
Führen Sie diese Befehle auf Ihrem Gerät aus.
```
cd ~
python3 -m pip install awsiotsdk
```
```
git clone https://github.com/aws/aws-iot-device-sdk-python-v2.git
```
------
#### [ JavaScript ]
In diesem Abschnitt installieren Sie Node.js, den npm-Paketmanager und das AWS IoT Geräte-SDK für JavaScript auf Ihrem Gerät. Diese Anweisungen gelten für einen Raspberry Pi, auf dem das Raspberry Pi OS ausgeführt wird. Wenn Sie mit einem anderen Gerät arbeiten oder ein anderes Betriebssystem verwenden, müssen Sie diese Anweisungen für Ihr Gerät anpassen.
1.
**Installieren der neuesten Version von Node.js**
Für das AWS IoT Geräte-SDK für JavaScript müssen Node.js und der npm-Paketmanager auf Ihrem Raspberry Pi installiert sein.
1. Laden Sie die aktuelle Version des Knoten-Repositorys herunter, indem Sie einen der folgenden Befehle eingeben.
```
cd ~
curl -sL https://deb.nodesource.com/setup_12.x | sudo -E bash -
```
1. Installieren Sie Node und npm.
```
sudo apt-get install -y nodejs
```
1. Überprüfen Sie die Installation von Node.
```
node -v
```
Vergewissern Sie sich, dass der Befehl die Node-Version anzeigt. Dieses Tutorial erfordert Node v10.0 oder neuer. Wenn die Node-Version nicht angezeigt wird, versuchen Sie erneut, das Node-Repository herunterzuladen.
1. Überprüfen Sie die Installation von npm.
```
npm -v
```
Vergewissern Sie sich, dass der Befehl die npm-Version anzeigt. Wenn die npm-Version nicht angezeigt wird, versuchen Sie erneut, Node und npm zu installieren.
1. Starten Sie das Gerät neu.
```
sudo shutdown -r 0
```
Fahren Sie nach dem Neustart des Geräts fort.
1.
**Installieren Sie das AWS IoT Geräte-SDK für JavaScript**
Installieren Sie das AWS IoT Geräte-SDK für JavaScript auf Ihrem Raspberry Pi.
1. Klonen Sie das AWS IoT Geräte-SDK für das JavaScript Repository in das `aws-iot-device-sdk-js-v2` Verzeichnis Ihres *home* Verzeichnisses. Auf dem Raspberry Pi ist das *home* Verzeichnis`~/`, das in den folgenden Befehlen als *home* Verzeichnis verwendet wird. Wenn Ihr Gerät einen anderen Pfad für das *home* Verzeichnis verwendet, müssen Sie es in `~/` den folgenden Befehlen durch den richtigen Pfad für Ihr Gerät ersetzen.
Diese Befehle erstellen das Verzeichnis `~/aws-iot-device-sdk-js-v2` und kopieren den SDK-Code hinein.
```
cd ~
git clone https://github.com/aws/aws-iot-device-sdk-js-v2.git
```
1. Wechseln Sie zu dem Verzeichnis `aws-iot-device-sdk-js-v2`, das Sie im vorherigen Schritt erstellt haben, und führen Sie `npm install` aus, um das SDK zu installieren. Der Befehl `npm install` ruft den Build der Bibliothek `aws-crt` auf, der einige Minuten in Anspruch nehmen kann.
```
cd ~/aws-iot-device-sdk-js-v2
npm install
```
------
## Installieren und Ausführen der Beispiel-App
In diesem Abschnitt installieren und führen Sie die `pubsub` Beispiel-App aus dem AWS IoT Geräte-SDK aus. Diese App zeigt, wie Ihr Gerät die MQTT-Bibliothek verwendet, um MQTT-Nachrichten zu veröffentlichen und zu abonnieren. Die 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.
**Installieren Sie die Zertifikatdateien**
Für die Beispiel-App müssen die Zertifikatsdateien, die das Gerät authentifizieren, auf dem Gerät installiert sein.
**Um die Gerätezertifikatsdateien für die Beispiel-App zu installieren**
1. Erstellen Sie ein `certs` Unterverzeichnis in Ihrem *home* Verzeichnis, indem Sie diese Befehle ausführen.
```
cd ~
mkdir certs
```
1. Kopieren Sie das Zertifikat, den privaten Schlüssel und das Stammzertifikat, das Sie in `~/certs` erstellt haben, in das Verzeichnis [AWS IoT Ressourcen erstellen](create-iot-resources.md).
Wie Sie die Zertifikatsdateien auf Ihr Gerät kopieren, hängt vom Gerät und Betriebssystem ab und wird hier nicht beschrieben. Wenn Ihr Gerät jedoch eine grafische Benutzeroberfläche (GUI) unterstützt und über einen Webbrowser verfügt, können Sie das unter [AWS IoT Ressourcen erstellen](create-iot-resources.md) beschriebene Verfahren vom Webbrowser Ihres Geräts aus ausführen, um die resultierenden Dateien direkt auf Ihr Gerät herunterzuladen.
Bei den Befehlen im nächsten Abschnitt wird davon ausgegangen, dass Ihr Schlüssel und Ihr Zertifikatdateien wie in dieser Tabelle gezeigt auf dem Gerät gespeichert sind.
**Namen der Zertifikatsdateien**
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/iot/latest/developerguide/connecting-to-existing-device.html)
Zur Ausführung der Beispielanwendung benötigen Sie die folgenden Informationen:
**Anwendungsparameterwerte**
| Parameter | Wo der Wert gefunden werden kann |
| --- | --- |
| your-iot-endpoint | Wählen Sie in der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home) **Alle Geräte** und dann **Objekte** aus. Auf der **Einstellungsseite** im AWS IoT Menü. Ihr Endpunkt wird im Abschnitt **Gerätedaten-Endpunkt** angezeigt. |
Der *your-iot-endpoint* Wert hat ein Format von:`endpoint_id-ats.iot.region.amazonaws.com`, zum Beispiel`a3qj468EXAMPLE-ats.iot.us-west-2.amazonaws.com`.
------
#### [ Python ]
**Um die Beispiel-App zu installieren und auszuführen**
1. Navigieren Sie zum Beispielverzeichnis.
```
cd ~/aws-iot-device-sdk-python-v2/samples
```
1. Ersetzen Sie im Befehlszeilenfenster *your-iot-endpoint* wie angegeben und führen Sie diesen Befehl aus.
```
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
```
1. Beachten Sie, dass die Beispiel-App:
1. Stellt eine Verbindung mit dem AWS IoT Dienst für Ihr 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:
```
Connecting to a3qEXAMPLEffp-ats.iot.us-west-2.amazonaws.com with client ID 'test-0c8ae2ff-cc87-49d2-a82a-ae7ba1d0ca5a'...
Connected!
Subscribing to topic 'topic_1'...
Subscribed with QoS.AT_LEAST_ONCE
Sending 10 message(s)
Publishing message to topic 'topic_1': Hello World! [1]
Received message from topic 'topic_1': b'Hello World! [1]'
Publishing message to topic 'topic_1': Hello World! [2]
Received message from topic 'topic_1': b'Hello World! [2]'
Publishing message to topic 'topic_1': Hello World! [3]
Received message from topic 'topic_1': b'Hello World! [3]'
Publishing message to topic 'topic_1': Hello World! [4]
Received message from topic 'topic_1': b'Hello World! [4]'
Publishing message to topic 'topic_1': Hello World! [5]
Received message from topic 'topic_1': b'Hello World! [5]'
Publishing message to topic 'topic_1': Hello World! [6]
Received message from topic 'topic_1': b'Hello World! [6]'
Publishing message to topic 'topic_1': Hello World! [7]
Received message from topic 'topic_1': b'Hello World! [7]'
Publishing message to topic 'topic_1': Hello World! [8]
Received message from topic 'topic_1': b'Hello World! [8]'
Publishing message to topic 'topic_1': Hello World! [9]
Received message from topic 'topic_1': b'Hello World! [9]'
Publishing message to topic 'topic_1': Hello World! [10]
Received message from topic 'topic_1': b'Hello World! [10]'
10 message(s) received.
Disconnecting...
Disconnected!
```
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.
------
#### [ JavaScript ]
**Um die Beispiel-App zu installieren und auszuführen**
1. Navigieren Sie in Ihrem Befehlszeilenfenster zu dem `~/aws-iot-device-sdk-js-v2/samples/node/pub_sub`-Verzeichnis, das das SDK erstellt hat, und installieren Sie die Beispiel-App mithilfe dieser Befehle. Der Befehl `npm install` ruft den Build der `aws-crt` Bibliothek auf, der einige Minuten in Anspruch nehmen kann.
```
cd ~/aws-iot-device-sdk-js-v2/samples/node/pub_sub
npm install
```
1. Ersetzen Sie im Befehlszeilenfenster *your-iot-endpoint* wie angegeben und führen Sie diesen Befehl 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
```
1. Beachten Sie, dass die Beispiel-App:
1. Stellt eine Verbindung mit dem AWS IoT Dienst für Ihr 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 on topic topic_1
{"message":"Hello world!","sequence":1}
Publish received on topic topic_1
{"message":"Hello world!","sequence":2}
Publish received on topic topic_1
{"message":"Hello world!","sequence":3}
Publish received on topic topic_1
{"message":"Hello world!","sequence":4}
Publish received on topic topic_1
{"message":"Hello world!","sequence":5}
Publish received on topic topic_1
{"message":"Hello world!","sequence":6}
Publish received on topic topic_1
{"message":"Hello world!","sequence":7}
Publish received on topic topic_1
{"message":"Hello world!","sequence":8}
Publish received on topic topic_1
{"message":"Hello world!","sequence":9}
Publish received on topic topic_1
{"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
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. Abonnieren Sie das Thema **topic\$11**.
1. Führen Sie in Ihrem Befehlszeilenfenster die Beispiel-App erneut aus und sehen Sie sich die Nachrichten im **MQTT-Client** in der **AWS IoT -Konsole** an.
------
#### [ Python ]
```
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
```
------
#### [ JavaScript ]
```
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
```
------
# Beheben Sie Probleme mit der Beispielanwendung
Wenn beim Versuch, die Beispiel-App auszuführen, ein Fehler auftritt, sollten Sie Folgendes überprüfen.
## Überprüfen Sie das Zertifikat
Wenn das Zertifikat nicht aktiv ist, AWS IoT werden keine Verbindungsversuche akzeptiert, bei denen es für die Autorisierung verwendet wird. Bei der Erstellung Ihres Zertifikats ist es leicht, die Schaltfläche **Aktivieren** zu übersehen. Zum Glück können Sie Ihr Zertifikat von der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home) aus aktivieren.
**Um die Aktivierung Ihres Zertifikats zu überprüfen**
1. Wählen Sie in der [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home) im linken Menü die Option **Sicher** und dann **Zertifikate** aus.
1. Suchen Sie in der Liste der Zertifikate nach dem Zertifikat, das Sie für die Übung erstellt haben, und überprüfen Sie seinen Status in der Spalte **Status**.
Wenn Sie sich nicht an den Namen des Zertifikats erinnern, suchen Sie nach den Zertifikaten, die **inaktiv** sind, um festzustellen, ob es sich dabei möglicherweise um das Zertifikat handelt, das Sie verwenden.
Wählen Sie das Zertifikat in der Liste aus, um die Detailseite zu öffnen. Auf der Detailseite können Sie das **Erstellungsdatum** sehen, damit Sie das Zertifikat leichter identifizieren können.
1. **Um ein inaktives Zertifikat zu aktivieren**, wählen Sie auf der Detailseite des Zertifikats **Aktionen** und dann **Aktivieren** aus.
Wenn Sie das richtige Zertifikat gefunden haben und es aktiv ist, Sie aber immer noch Probleme beim Ausführen der Beispiel-App haben, überprüfen Sie die Richtlinien, wie im nächsten Schritt beschrieben.
Sie können auch versuchen, eine neue Sache und ein neues Zertifikat zu erstellen, indem Sie die Schritte unter [Dies erstellt ein Objekt](create-iot-resources.md#create-aws-thing) befolgen. Wenn Sie eine neue Sache erstellen, müssen Sie ihr einen neuen Namen geben und die neuen Zertifikatsdateien auf Ihr Gerät herunterladen.
## Prüfen Sie die dem Zertifikat angefügte Richtlinie
Richtlinien autorisieren Aktionen in AWS IoT. Wenn das Zertifikat, mit dem eine Verbindung zu AWS IoT hergestellt wird, keine Richtlinie hat oder nicht über eine Richtlinie verfügt, die das Herstellen einer Verbindung ermöglicht, wird die Verbindung verweigert, auch wenn das Zertifikat aktiv ist.
**Um die einem Zertifikat beigefügten Richtlinien zu überprüfen**
1. Suchen Sie das Zertifikat, wie im vorherigen Artikel beschrieben, und öffnen Sie die zugehörige Detailseite.
1. Wählen Sie im linken Menü der Detailseite des Zertifikats die Option **Richtlinien** aus, um die mit dem Zertifikat verknüpften Richtlinien anzuzeigen.
1. Wenn dem Zertifikat keine Richtlinien zugeordnet sind, fügen Sie eine hinzu, indem Sie das Menü **Aktionen** und dann **Richtlinie anhängen** wählen.
Wählen Sie die Regel aus, die Sie zuvor in [AWS IoT Ressourcen erstellen](create-iot-resources.md) erstellt haben.
1. Wenn eine Richtlinie angehängt ist, wählen Sie die Richtlinienkachel aus, um die Detailseite zu öffnen.
Überprüfen Sie auf der Detailseite das **Richtliniendokument**, um sicherzustellen, dass es dieselben Informationen enthält wie das, in dem Sie es in [Erstellen Sie eine AWS IoT Richtlinie](create-iot-resources.md#create-iot-policy) erstellt haben.
## Überprüfen Sie die Befehlszeile
Stellen Sie sicher, dass Sie die richtige Befehlszeile für Ihr System verwendet haben. Die auf Linux- und MacOS-Systemen verwendeten Befehle unterscheiden sich häufig von denen, die auf Windows-Systemen verwendet werden.
## Überprüfen Sie die Endpunktadresse
Überprüfen Sie den Befehl, den Sie eingegeben haben, und überprüfen Sie die Endpunktadresse in Ihrem Befehl noch einmal mit der Adresse in Ihrer [AWS IoT -Konsole](https://console.aws.amazon.com/iot/home).
## Überprüfen Sie die Dateinamen der Zertifikatsdateien
Vergleichen Sie die Dateinamen in dem Befehl, den Sie eingegeben haben, mit den Dateinamen der Zertifikatsdateien im Verzeichnis `certs`.
Bei einigen Systemen müssen die Dateinamen möglicherweise in Anführungszeichen gesetzt werden, damit sie korrekt funktionieren.
## Überprüfen Sie die SDK-Installation
Stellen Sie sicher, dass Ihre SDK-Installation vollständig und korrekt ist.
Installieren Sie im Zweifelsfall das SDK erneut auf Ihrem Gerät. In den meisten Fällen müssen Sie den Abschnitt des Tutorials mit dem Titel **Installieren des AWS IoT Geräte-SDK für** finden **SDK language** und das Verfahren erneut ausführen.
Wenn Sie das **AWS IoT Geräte-SDK für** verwenden JavaScript, denken Sie daran, die Beispiel-Apps zu installieren, bevor Sie versuchen, sie auszuführen. Durch die Installation des SDK werden die Beispiel-Apps nicht automatisch installiert. Die Beispiel-Apps müssen nach der Installation des SDK manuell installiert werden.