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.
# Daten aufnehmen, um Dinge AWS IoT SiteWise zu erstellen AWS IoT
In diesem Tutorial erfahren Sie, wie Sie mithilfe AWS IoT SiteWise von AWS IoT Geräteschatten Daten aus einer Flotte von Geräten aufnehmen. *Geräteschatten* sind JSON-Objekte, die aktuelle Statusinformationen für ein AWS IoT Gerät speichern. Weitere Informationen finden Sie unter [Device Shadow Service](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) im *AWS IoT Entwicklerhandbuch*.
Nachdem Sie dieses Tutorial abgeschlossen haben, können Sie einen Vorgang einrichten, der auf AWS IoT Dingen AWS IoT SiteWise basiert. Indem Sie AWS IoT Dinge verwenden, können Sie Ihren Betrieb in andere nützliche Funktionen von integrieren AWS IoT. Sie können beispielsweise AWS IoT Funktionen für die folgenden Aufgaben konfigurieren:
+ Konfigurieren Sie zusätzliche Regeln für das Streamen von Daten zu [AWS IoT Events](https://docs.aws.amazon.com/iotevents/latest/developerguide/)[Amazon DynamoDB](https://docs.aws.amazon.com/dynamodb/) und anderen AWS Services. Weitere Informationen finden Sie unter [Regeln](https://docs.aws.amazon.com/iot/latest/developerguide/iot-rules.html) im *AWS IoT Entwicklerhandbuch*.
+ Indexieren, durchsuchen und aggregieren Sie Ihre Gerätedaten mit dem AWS IoT Fleet Indexing Service. Weitere Informationen finden Sie unter [Fleet Indexing Service](https://docs.aws.amazon.com/iot/latest/developerguide/iot-indexing.html) im *AWS IoT Entwicklerhandbuch*.
+ Prüfen und sichern Sie Ihre Geräte mit AWS IoT Device Defender. Weitere Informationen finden Sie unter [AWS IoT Device Defender](https://docs.aws.amazon.com/iot-device-defender/latest/devguide/what-is-device-defender.html) im *AWS IoT -Entwicklerhandbuch*.
In diesem Tutorial erfahren Sie, wie Sie Daten aus den Geräteschatten AWS IoT von Dingen in Assets aufnehmen. AWS IoT SiteWise Dazu erstellen Sie ein oder mehrere AWS IoT Dinge und führen ein Skript aus, das den Geräteshadow jedes Dings mit Daten zur CPU- und Speichernutzung aktualisiert. In diesem Tutorial verwenden Sie CPU- und Speichernutzungsdaten, um realistische Sensordaten zu imitieren. Anschließend erstellen Sie eine Regel mit einer AWS IoT SiteWise Aktion, die diese Daten bei AWS IoT SiteWise jeder Aktualisierung des Geräteshadows an ein Asset sendet. Weitere Informationen finden Sie unter [Daten AWS IoT SiteWise mithilfe AWS IoT Core von Regeln aufnehmen](iot-rules.md).
**Topics**
+ [
## Voraussetzungen
](#rule-ingestion-tutorial-prerequisites)
+ [
## Schritt 1: Erstellen Sie eine AWS IoT Richtlinie
](#ingestion-tutorial-create-iot-policy)
+ [
## Schritt 2: Erstellen und konfigurieren Sie ein AWS IoT Ding
](#rule-tutorial-create-iot-thing)
+ [
## Schritt 3: Erstellen Sie ein Geräte-Asset-Modell
](#rule-tutorial-create-device-model)
+ [
## Schritt 4: Erstellen Sie ein Geräteflotten-Asset-Modell
](#rule-tutorial-create-fleet-model)
+ [
## Schritt 5: Erstellen und konfigurieren Sie ein Geräte-Asset
](#rule-tutorial-create-device-assets)
+ [
## Schritt 6: Erstellen und konfigurieren Sie ein Geräteflotten-Asset
](#rule-tutorial-create-fleet-asset)
+ [
## Schritt 7: Erstellen Sie in AWS IoT Core eine Regel, um Daten an Geräteressourcen zu senden
](#rule-tutorial-create-iot-rule)
+ [
## Schritt 8: Führen Sie das Geräteclient-Skript aus
](#rule-tutorial-run-script)
+ [
## Schritt 9: Ressourcen nach dem Tutorial bereinigen
](#rule-tutorial-clean-up-resources)
## Voraussetzungen
Zum Durcharbeiten dieses Tutorials ist Folgendes erforderlich:
+ Ein AWS Konto. Falls Sie noch keines haben, beachten Sie die Informationen unter [Richten Sie ein Konto ein AWS](getting-started.md#set-up-aws-account).
+ Ein Entwicklungscomputer, auf demWindows, macOSLinux, oder ausgeführt wird, Unix um auf den zuzugreifen AWS-Managementkonsole. Weitere Informationen finden Sie unter [Erste Schritte mit AWS-Managementkonsole](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/getting-started.html).
+ Ein AWS Identity and Access Management (IAM-) Benutzer mit Administratorrechten.
+ Python3 ist auf Ihrem Entwicklungscomputer oder auf dem Gerät installiert, das Sie als Objekt registrieren möchten AWS IoT .
## Schritt 1: Erstellen Sie eine AWS IoT Richtlinie
Erstellen Sie in diesem Verfahren eine AWS IoT Richtlinie, die es Ihren AWS IoT Dingen ermöglicht, auf die in diesem Tutorial verwendeten Ressourcen zuzugreifen.
------
#### [ Console ]
Gehen Sie wie folgt vor, um mithilfe der AWS IoT Core Konsole eine AWS IoT Richtlinie zu erstellen:
**Um eine AWS IoT Richtlinie zu erstellen**
1. Melden Sie sich an der [AWS-Managementkonsole](https://docs.aws.amazon.com/awsconsolehelpdocs/latest/gsg/what-is.html) an.
1. Sehen Sie sich die [AWS Regionen](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html) an, in denen AWS IoT SiteWise es unterstützt wird. Wechseln Sie ggf. zu einer dieser unterstützten Regionen.
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iot/). Wenn die Schaltfläche **Gerät Connect** angezeigt wird, wählen Sie sie aus.
1. Wählen Sie im linken Navigationsbereich **Sicherheit** und dann **Richtlinien** aus.
1. Wählen Sie **Erstellen** aus.
1. Geben Sie einen Namen für die AWS IoT Richtlinie ein (z. B.**SiteWiseTutorialDevicePolicy**).
1. Wählen Sie unter **Richtliniendokument** die Option **JSON** aus, um die folgende Richtlinie im JSON-Format einzugeben. Ersetzen Sie *region* und *account-id* durch Ihre Region und Konto-ID, z. B. **us-east-1** und**123456789012**.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:us-east-1:123456789012:client/SiteWiseTutorialDevice*"
},
{
"Effect": "Allow",
"Action": "iot:Publish",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get"
]
},
{
"Effect": "Allow",
"Action": "iot:Receive",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/get/accepted",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/update/rejected",
"arn:aws:iot:us-east-1:123456789012:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/delete/rejected"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:us-east-1:123456789012:thing/SiteWiseTutorialDevice*"
}
]
}
```
------
1. Wählen Sie **Erstellen** aus.
------
#### [ AWS CLI ]
**Wichtig**
Diese Richtlinie verwendet Platzhalter, um die AWS IoT SiteWise CLI-Größenbeschränkungen einzuhalten. Für restriktivere Berechtigungen mit expliziten Themenpfaden erstellen Sie die Richtlinie stattdessen über die AWS IoT SiteWise Konsole. Weitere Informationen finden Sie im Beispiel für eine IoT-Richtlinie auf der Registerkarte.
Verwenden Sie den folgenden AWS CLI Befehl, um eine IoT-Richtlinie zu erstellen:
```
aws iot create-policy \
--policy-name "SiteWiseTutorialDevicePolicy" \
--policy-document '{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:Connect",
"Resource": "arn:aws:iot:region:account-id:client/SiteWiseTutorialDevice*"
},
{
"Effect": "Allow",
"Action": ["iot:Publish", "iot:Receive"],
"Resource": [
"arn:aws:iot:region:account-id:topic/$aws/things/${iot:Connection.Thing.ThingName}/shadow/*"
]
},
{
"Effect": "Allow",
"Action": "iot:Subscribe",
"Resource": [
"arn:aws:iot:region:account-id:topicfilter/$aws/things/${iot:Connection.Thing.ThingName}/shadow/*"
]
},
{
"Effect": "Allow",
"Action": [
"iot:GetThingShadow",
"iot:UpdateThingShadow",
"iot:DeleteThingShadow"
],
"Resource": "arn:aws:iot:region:account-id:thing/SiteWiseTutorialDevice*"
}
]
}'
```
Verwenden Sie den folgenden Befehl, um zu überprüfen, ob Ihre Richtlinie erfolgreich erstellt wurde:
```
aws iot get-policy --policy-name "SiteWiseTutorialDevicePolicy"
```
------
Diese Richtlinie ermöglicht es Ihren AWS IoT Geräten, mithilfe von MQTT-Nachrichten Verbindungen herzustellen und mit Geräteschatten zu kommunizieren. Weitere Informationen zu MQTT-Nachrichten finden Sie unter [Was ist](https://aws.amazon.com/what-is/mqtt/) MQTT? . Um mit Geräteschatten zu interagieren, veröffentlichen und empfangen Ihre AWS IoT Dinge MQTT-Nachrichten zu Themen, die mit `$aws/things/thing-name/shadow/` beginnen. Diese Richtlinie enthält eine Ding-Richtlinienvariable, die als`${iot:Connection.Thing.ThingName}`. Diese Variable ersetzt in jedem Thema den Namen der verbundenen Sache. Die `iot:Connect` Anweisung beschränkt, welche Geräte Verbindungen herstellen können, und stellt so sicher, dass die Richtlinienvariable thing nur Namen ersetzen kann, die mit `SiteWiseTutorialDevice` beginnen.
Weitere Informationen finden Sie unter [Ding-Richtlinienvariablen](https://docs.aws.amazon.com/iot/latest/developerguide/iot-policy-variables.html) im *AWS IoT Entwicklerhandbuch*.
**Anmerkung**
Diese Richtlinie gilt für Objekte, deren Namen mit `SiteWiseTutorialDevice` beginnen. Um einen anderen Namen für Ihre Objekte zu verwenden, müssen Sie die Richtlinie entsprechend aktualisieren.
## Schritt 2: Erstellen und konfigurieren Sie ein AWS IoT Ding
In diesem Verfahren erstellen und konfigurieren Sie ein AWS IoT Ding. Sie können Ihren Entwicklungscomputer als ein AWS IoT Ding bezeichnen. Denken Sie im weiteren Verlauf daran, dass die Prinzipien, die Sie hier lernen, auch auf konkrete Projekte angewendet werden können. Sie haben die Flexibilität, AWS IoT Dinge auf jedem Gerät zu erstellen und einzurichten, auf dem ein AWS IoT SDK ausgeführt werden kann, einschließlich AWS IoT Greengrass FreeRTOS. Weitere Informationen finden Sie unter [AWS IoT SDKs](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html) im *AWS IoT -Entwicklerhandbuch*.
------
#### [ Console ]
**Um etwas zu erstellen und zu konfigurieren AWS IoT**
1. Öffnen Sie eine Befehlszeile, und führen Sie den folgenden Befehl aus, um ein Verzeichnis für dieses Lernprogramm zu erstellen.
```
mkdir iot-sitewise-rule-tutorial
cd iot-sitewise-rule-tutorial
```
1. Führen Sie den folgenden Befehl aus, um ein Verzeichnis für die Zertifikate Ihres Objekts zu erstellen.
```
mkdir device1
```
Wenn Sie zusätzliche Objekte erstellen, erhöhen Sie die Nummer im Verzeichnisnamen entsprechend, um zu verfolgen, welche Zertifikate zu welchem Objekt gehören.
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iot/).
1. Wählen Sie im linken Navigationsbereich im Abschnitt **Verwalten** die Option **Alle Geräte** aus. Wählen Sie dann **Things (Objekte)** aus.
1. Wenn das Dialogfeld **You don‘t have any things yet (Sie haben noch keine Objekte)** angezeigt wird, wählen Sie **Create a thing (Objekt erstellen)** aus. Wählen Sie andernfalls **Dinge erstellen** aus.
1. Wählen Sie auf der Seite „**Dinge erstellen**“ die Option „**Ein einzelnes Ding erstellen**“ und dann „**Weiter**“ aus.
1. Geben Sie auf der Seite „**Dingeigenschaften angeben**“ einen Namen für Ihr AWS IoT Ding ein (z. B.**SiteWiseTutorialDevice1**) und wählen Sie dann **Weiter**. Wenn Sie zusätzliche Objekte erstellen, erhöhen Sie die Nummer im Namen des Objekts entsprechend.
**Wichtig**
Der Name des Dings muss mit dem Namen übereinstimmen, der in der Richtlinie verwendet wurde, die Sie in *Schritt 1: AWS IoT Richtlinie erstellen* erstellt haben. Andernfalls kann Ihr Gerät keine Verbindung zu herstellen AWS IoT.
1. Wählen Sie auf der Seite **Gerätezertifikat konfigurieren — *optional*** die Option **Neues Zertifikat automatisch generieren (empfohlen)** und anschließend **Weiter** aus. Mithilfe von Zertifikaten können AWS IoT Sie Ihre Geräte sicher identifizieren.
1. Wählen Sie auf der Seite **Richtlinien an Zertifikat anhängen — *optional*** die Richtlinie aus, die Sie in *Schritt 1: AWS IoT Richtlinie erstellen* erstellt haben, und wählen Sie **Ding erstellen** aus.
1. Gehen **Sie im Dialogfeld Zertifikate und Schlüssel herunterladen** wie folgt vor:
1. Wählen Sie die **Download**-Links, um das Zertifikat, den öffentlichen Schlüssel und den privaten Schlüssel Ihres Objekts herunterzuladen. Speichern Sie alle drei Dateien in dem Verzeichnis, das Sie für die Zertifikate Ihres Objekts erstellt haben (zum Beispiel **iot-sitewise-rule-tutorial/device1**).
**Wichtig**
Dies ist das einzige Mal, dass Sie das Zertifikat und die Schlüssel Ihres Objekts herunterladen können, die Sie benötigen, damit Ihr Gerät erfolgreich eine Verbindung mit AWS IoT herstellen kann.
1. Wählen Sie den Link **Herunterladen**, um ein Root-CA-Zertifikat herunterzuladen. Speichern Sie das CA-Stammzertifikat der Zertifizierungsstelle in **iot-sitewise-rule-tutorial**. Wir empfehlen Ihnen, Amazon Root CA 1 herunterzuladen.
1. Wählen Sie **Fertig** aus.
------
#### [ AWS CLI ]
Gehen Sie wie folgt vor, um ein Objekt zu erstellen und zu konfigurieren AWS IoT , indem Sie AWS CLI:
1. Öffnen Sie eine Befehlszeile und führen Sie den folgenden Befehl aus, um ein Verzeichnis für dieses Tutorial zu erstellen:
```
mkdir iot-sitewise-rule-tutorial
```
1. Navigieren Sie zum Verzeichnis für das Tutorial:
```
cd iot-sitewise-rule-tutorial
```
1. Führen Sie den folgenden Befehl aus, um ein Verzeichnis für die Zertifikate Ihres Dings zu erstellen:
```
mkdir device1
```
Wenn Sie zusätzliche Objekte erstellen, erhöhen Sie die Nummer im Verzeichnisnamen entsprechend, um zu verfolgen, welche Zertifikate zu welchem Objekt gehören.
1. Erstelle ein AWS IoT Ding:
```
aws iot create-thing --thing-name "SiteWiseTutorialDevice1"
```
**Wichtig**
Der Name des Dings muss dem Namensmuster entsprechen, das in der Richtlinie verwendet wurde, die Sie in Schritt 1 erstellt haben. Andernfalls kann Ihr Gerät keine Verbindung zu herstellen AWS IoT.
1. Erstellen Sie ein Zertifikat und speichern Sie die Dateien. Notieren Sie sich den Zertifikat-ARN aus der Ausgabe — Sie benötigen ihn in den nächsten Schritten:
```
aws iot create-keys-and-certificate \
--set-as-active \
--certificate-pem-outfile "device1/device.pem.crt" \
--public-key-outfile "device1/public.pem.key" \
--private-key-outfile "device1/private.pem.key"
```
1. Hängen Sie die Richtlinie, die Sie in Schritt 1 erstellt haben, an das Zertifikat an:
```
aws iot attach-policy \
--policy-name "SiteWiseTutorialDevicePolicy" \
--target "certificate-arn"
```
1. Hängen Sie das Zertifikat an das Ding an:
```
aws iot attach-thing-principal \
--thing-name "SiteWiseTutorialDevice1" \
--principal "certificate-arn"
```
1. Laden Sie das Amazon-Root-CA-Zertifikat herunter:
```
curl https://www.amazontrust.com/repository/AmazonRootCA1.pem > AmazonRootCA1.pem
```
Dieses Zertifikat ist erforderlich, damit Ihr Gerät erfolgreich eine Verbindung herstellen kann AWS IoT.
**Wichtig**
Bewahren Sie Ihre Zertifikate und Schlüssel sicher auf. Sie können diese Anmeldeinformationen nicht erneut herunterladen, nachdem Sie sie erstellt haben.
------
Sie haben jetzt AWS IoT etwas auf Ihrem Computer registriert. Führen Sie einen der folgenden nächsten Schritte aus:
+ Fahren Sie mit *Schritt 3 fort: Erstellen eines Geräte-Asset-Modells*, ohne zusätzliche AWS IoT Dinge zu erstellen. Sie können dieses Lernprogramm mit nur einem Objekt abschließen.
+ Wiederholen Sie die Schritte in diesem Abschnitt auf einem anderen Computer oder Gerät, um weitere AWS IoT -Objekte zu erstellen. Für dieses Tutorial empfehlen wir, diese Option zu befolgen, damit Sie eindeutige CPU- und Speicherauslastungsdaten von mehreren Geräten erfassen können.
+ Wiederholen Sie die Schritte in diesem Abschnitt auf demselben Gerät (Ihrem Computer), um weitere AWS IoT -Objekte zu erstellen. Jedes Gerät AWS IoT empfängt ähnliche CPU- und Speichernutzungsdaten von Ihrem Computer. Verwenden Sie daher diesen Ansatz, um zu demonstrieren, dass nicht eindeutige Daten von mehreren Geräten aufgenommen werden.
## Schritt 3: Erstellen Sie ein Geräte-Asset-Modell
In diesem Verfahren erstellen Sie ein Asset-Modell, das Ihre Geräte repräsentiert, die CPU- und Speichernutzungsdaten streamen. AWS IoT SiteWise Um Daten in Anlagen zu verarbeiten, die Gerätegruppen repräsentieren, setzen Asset-Modelle konsistente Informationen für mehrere Anlagen desselben Typs voraus. Weitere Informationen finden Sie unter [Modellieren Sie Industrieanlagen](industrial-asset-models.md).
**So erstellen Sie ein Komponentenmodell, das ein Gerät darstellt**
1. Navigieren Sie zur [AWS IoT SiteWise -Konsole](https://console.aws.amazon.com/iotsitewise/).
1. Wählen Sie im linken Navigationsbereich **Models (Modelle)** aus.
1. Wählen Sie **Asset-Modell erstellen** aus.
1. Geben Sie unter **Modelldetails** einen Namen für Ihr Modell ein. Beispiel, **SiteWise Tutorial Device Model**.
1. Führen Sie unter **Measurement definitions (Messungsdefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Name** **CPU Usage** ein.
1. Geben Sie unter **Unit (Einheit)** **%** ein.
1. Lassen Sie den **Data type (Datentyp)** bei **Double (Doppelt)**.
Messungseigenschaften stellen die Rohdatenströme eines Geräts dar. Weitere Informationen finden Sie unter [Definieren Sie Datenströme von Geräten (Messungen)](measurements.md).
1. Wählen Sie **Neue Messung hinzufügen**, um eine zweite Messeigenschaft hinzuzufügen.
1. Führen Sie in der zweiten Zeile unter **Measurement definitions (Messungsdefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Name** **Memory Usage** ein.
1. Geben Sie unter **Unit (Einheit)** **%** ein.
1. Lassen Sie den **Data type (Datentyp)** bei **Double (Doppelt)**.
1. Führen Sie unter **Metric definitions (Metrikdefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Name** **Average CPU Usage** ein.
1. Geben Sie unter **Formula (Formel)** **avg(CPU Usage)** ein. Wählen Sie **CPU Usage** aus der Autovervollständigungsliste aus, wenn sie angezeigt wird.
1. Geben Sie unter **Time interval (Zeitintervall)** **5 minutes** ein.
Metrikeigenschaften definieren Aggregationsberechnungen, die alle Eingabedatenpunkte über ein Intervall verarbeiten und einen einzelnen Datenpunkt pro Intervall ausgeben. Diese Metrikeigenschaft berechnet alle 5 Minuten die durchschnittliche CPU-Auslastung jedes Geräts. Weitere Informationen finden Sie unter [Aggregieren Sie Daten aus Immobilien und anderen Vermögenswerten (Metriken)](metrics.md).
1. Wählen Sie **Neue Metrik hinzufügen**, um eine zweite Metrikeigenschaft hinzuzufügen.
1. Führen Sie in der zweiten Zeile unter **Metric definitions (Metrikdefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Name** **Average Memory Usage** ein.
1. Geben Sie unter **Formula (Formel)** **avg(Memory Usage)** ein. Wählen Sie **Memory Usage** aus der Autovervollständigungsliste aus, wenn sie angezeigt wird.
1. Geben Sie unter **Time interval (Zeitintervall)** **5 minutes** ein.
Diese Metrikeigenschaft berechnet alle 5 Minuten die durchschnittliche Speicherbelegung jedes Geräts.
1. (Optional) Fügen Sie weitere zusätzliche Metriken hinzu, die Sie pro Gerät berechnen möchten. Einige interessante Funktionen sind `min` und `max`. Weitere Informationen finden Sie unter [Verwenden Sie Formelausdrücke](formula-expressions.md). In *Schritt 4: Erstellen eines Geräteflotten-Asset-Modells* erstellen Sie ein übergeordnetes Asset, das anhand von Daten aus Ihrer gesamten Geräteflotte Kennzahlen berechnen kann.
1. Wählen Sie **Modell erstellen** aus.
## Schritt 4: Erstellen Sie ein Geräteflotten-Asset-Modell
In diesem Verfahren erstellen Sie ein Asset-Modell, AWS IoT SiteWise das Ihre Sammlung von Geräten symbolisiert. Innerhalb dieses Asset-Modells legen Sie eine Struktur fest, die es Ihnen ermöglicht, zahlreiche Geräte-Assets zu einem übergeordneten Flotten-Asset zu verknüpfen. Anschließend skizzieren Sie Kennzahlen im Flotten-Asset-Modell, um Daten aus allen verbundenen Gerätebeständen zu konsolidieren. Dieser Ansatz bietet Ihnen umfassende Einblicke in die Gesamtleistung Ihrer gesamten Flotte.
**So erstellen Sie ein Komponentenmodell, das eine Geräteflotte darstellt:**
1. Navigieren Sie zur [AWS IoT SiteWise -Konsole](https://console.aws.amazon.com/iotsitewise/).
1. Wählen Sie im linken Navigationsbereich **Models (Modelle)** aus.
1. Wählen Sie **Asset-Modell erstellen** aus.
1. Geben Sie unter **Modelldetails** einen Namen für Ihr Modell ein. Beispiel, **SiteWise Tutorial Device Fleet Model**.
1. Führen Sie unter **Hierarchy definitions (Hierarchiedefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Hierarchy name (Hierarchiename)** **Device** ein.
1. Wählen Sie unter **Hierarchy model (Hierarchiemodell)** das Gerätekomponentenmodell (**SiteWise Tutorial Device Model**).
Eine Hierarchie definiert eine Beziehung zwischen einem übergeordneten (Flotten-) Komponentenmodell und einem untergeordneten (Geräte-) Komponentenmodell. Übergeordnete Komponenten können auf die Eigenschaftendaten von untergeordneten Komponenten zugreifen. Wenn Sie Komponenten später erstellen, müssen Sie untergeordnete Komponenten gemäß einer Hierarchiedefinition im übergeordneten Komponentenmodell den übergeordneten Komponenten zuordnen. Weitere Informationen finden Sie unter [Anlagenhierarchien stellen Gerätebeziehungen dar](industrial-asset-models.md#asset-hierarchies).
1. Führen Sie unter **Metric definitions (Metrikdefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Name** **Average CPU Usage** ein.
1. Geben Sie unter **Formula (Formel)** **avg(Device \$1 Average CPU Usage)** ein. Wenn die Autovervollständigungsliste angezeigt wird, wählen Sie **Device**, um eine Hierarchie auszuwählen, und dann **Average CPU Usage**, um die Metrik aus der zuvor erstellten Gerätekomponente auszuwählen.
1. Geben Sie unter **Time interval (Zeitintervall)** **5 minutes** ein.
Diese Metrikeigenschaft berechnet die durchschnittliche CPU-Auslastung aller Gerätekomponenten, die einer Flottenkomponente über die **Device**-Hierarchie zugeordnet sind.
1. Wählen Sie **Neue Metrik hinzufügen**, um eine zweite Metrikeigenschaft hinzuzufügen.
1. Führen Sie in der zweiten Zeile unter **Metric definitions (Metrikdefinitionen)** die folgenden Schritte aus:
1. Geben Sie unter **Name** **Average Memory Usage** ein.
1. Geben Sie unter **Formula (Formel)** **avg(Device \$1 Average Memory Usage)** ein. Wenn die Autovervollständigungsliste angezeigt wird, wählen Sie **Device**, um eine Hierarchie auszuwählen, und dann **Average Memory Usage**, um die Metrik aus der zuvor erstellten Gerätekomponente auszuwählen.
1. Geben Sie unter **Time interval (Zeitintervall)** **5 minutes** ein.
Diese Metrikeigenschaft berechnet die durchschnittliche Speicherbelegung aller Gerätekomponenten, die einer Flottenkomponente über die **Device**-Hierarchie zugeordnet sind.
1. (Optional) Fügen Sie weitere zusätzliche Metriken hinzu, die Sie für Ihre gesamte Geräteflotte berechnen möchten.
1. Wählen Sie **Modell erstellen** aus.
## Schritt 5: Erstellen und konfigurieren Sie ein Geräte-Asset
In diesem Verfahren generieren Sie ein Geräte-Asset, das auf Ihrem Geräte-Asset-Modell basiert. Anschließend definieren Sie Eigenschaftsaliase für jede Messungseigenschaft. Ein *Eigenschaftsalias* ist eine eindeutige Zeichenfolge, die eine Asset-Eigenschaft identifiziert. Später können Sie eine Eigenschaft für den Datenupload identifizieren, indem Sie die Aliase anstelle der Asset-ID und der Eigenschafts-ID verwenden. Weitere Informationen finden Sie unter [Datenströme verwalten für AWS IoT SiteWise](manage-data-streams.md).
**So erstellen Sie eine Gerätekomponente und definieren Eigenschaftsaliase**
1. Navigieren Sie zur [AWS IoT SiteWise -Konsole](https://console.aws.amazon.com/iotsitewise/).
1. Klicken Sie im linken Navigationsbereich auf **Assets (Komponenten)**.
1. Wählen Sie dann **Create asset (Komponente erstellen)** aus.
1. Wählen Sie unter **Modellinformationen** das Asset-Modell Ihres Geräts aus. **SiteWise Tutorial Device Model**
1. Geben Sie unter **Inventarinformationen** einen Namen für Ihr Asset ein. Beispiel, **SiteWise Tutorial Device 1**.
1. Wählen Sie dann **Create asset (Komponente erstellen)** aus.
1. Wählen Sie für Ihre neue Gerätekomponente **Edit (Bearbeiten)**.
1. Unter **Messungen**:
1. Geben Sie unter **CPU Usage** **/tutorial/device/SiteWiseTutorialDevice1/cpu** als Eigenschaftenalias ein. Sie nehmen den Namen der AWS IoT Sache in den Eigenschaftsalias auf, sodass Sie mithilfe einer einzigen AWS IoT Regel Daten von all Ihren Geräten aufnehmen können.
1. Geben Sie unter **Memory Usage** **/tutorial/device/SiteWiseTutorialDevice1/memory** als Eigenschaftenalias ein.
1. Wählen Sie **Speichern**.
Wenn Sie zuvor mehrere AWS IoT Dinge erstellt haben, wiederholen Sie die Schritte 3 bis 10 für jedes Gerät und erhöhen Sie die Zahl im Assetnamen und den Eigenschaftsaliasnamen entsprechend. Beispielsweise sollte der Name der zweiten Gerätekomponente **SiteWise Tutorial Device 2** sein und die Eigenschaftsaliase sollten **/tutorial/device/SiteWiseTutorialDevice2/cpu** und **/tutorial/device/SiteWiseTutorialDevice2/memory** sein.
## Schritt 6: Erstellen und konfigurieren Sie ein Geräteflotten-Asset
In diesem Verfahren erstellen Sie ein Geräteflotten-Asset, das von Ihrem Geräteflotten-Assetmodell abgeleitet ist. Anschließend verknüpfen Sie Ihre individuellen Geräte-Assets mit dem Flotten-Asset. Diese Zuordnung ermöglicht es, anhand der metrischen Eigenschaften der Flottenanlage Daten von mehreren Geräten zusammenzustellen und zu analysieren. Diese Daten bieten Ihnen einen konsolidierten Überblick über die Gesamtleistung der gesamten Flotte.
**So erstellen Sie eine Geräteflottenkomponente und ordnen ihr Gerätekomponenten zu:**
1. Navigieren Sie zur [AWS IoT SiteWise -Konsole](https://console.aws.amazon.com/iotsitewise/).
1. Klicken Sie im linken Navigationsbereich auf **Assets (Komponenten)**.
1. Wählen Sie dann **Create asset (Komponente erstellen)** aus.
1. Wählen Sie unter **Modellinformationen** das Asset-Modell Ihrer Geräteflotte aus**SiteWise Tutorial Device Fleet Model**.
1. Geben Sie unter **Inventarinformationen** einen Namen für Ihr Asset ein. Beispiel, **SiteWise Tutorial Device Fleet 1**.
1. Wählen Sie dann **Create asset (Komponente erstellen)** aus.
1. Wählen Sie für Ihre neue Geräteflottenkomponente **Edit (Bearbeiten)**.
1. Wählen Sie unter **Diesem Asset zugeordnete Assets** die Option **Verbundenes Asset hinzufügen** aus und gehen Sie wie folgt vor:
1. Wählen Sie unter **Hierarchy (Hierarchie)** die Option **Device** aus. Diese Hierarchie identifiziert die hierarchische Beziehung zwischen Geräte- und Geräteflottenkomponenten. Sie haben diese Hierarchie im Geräteflottenkomponentenmodell früher in diesem Tutorial definiert.
1. Wählen Sie unter **Asset (Komponente)** Ihre Gerätekomponente, **SiteWise Tutorial Device 1**, aus.
1. (Optional) Wenn Sie zuvor mehrere Geräte-Assets erstellt haben, wiederholen Sie die Schritte 8 bis 10 für jedes Geräte-Asset, das Sie erstellt haben.
1. Wählen Sie **Speichern**.
Sie sollten nun Ihre Gerätekomponenten als Hierarchie sehen.
## Schritt 7: Erstellen Sie in AWS IoT Core eine Regel, um Daten an Geräteressourcen zu senden
In diesem Verfahren richten Sie eine Regel in ein AWS IoT Core. Die Regel dient dazu, Benachrichtigungen aus Geräteschatten zu interpretieren und die Daten an Ihre Geräteressourcen in zu übertragen AWS IoT SiteWise. Jedes Mal, wenn der Shadow Ihres Geräts aktualisiert wird, wird eine MQTT-Nachricht AWS IoT gesendet. Sie können eine Regel erstellen, die aktiv wird, wenn sich Geräteschatten basierend auf der MQTT-Nachricht ändern. In diesem Fall besteht das Ziel darin, die Aktualisierungsnachricht zu verarbeiten, die Eigenschaftswerte zu extrahieren und sie an Ihre Geräteressourcen in AWS IoT SiteWise zu übertragen.
**Um eine Regel mit einer AWS IoT SiteWise Aktion zu erstellen**
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iot/).
1. Wählen Sie im linken Navigationsbereich **Nachrichtenweiterleitung** und dann **Regeln** aus.
1. Wählen Sie **Regel erstellen** aus.
1. Geben Sie einen Namen und eine Beschreibung für Ihre Regel ein und wählen Sie **dann Weiter**.
1. Geben Sie die folgende SQL-Anweisung ein und wählen Sie **dann Weiter**.
```
SELECT
*
FROM
'$aws/things/+/shadow/update/accepted'
WHERE
startsWith(topic(3), "SiteWiseTutorialDevice")
```
Diese Regelabfrageanweisung funktioniert, weil der Geräte-Schattenservice Schattenaktualisierungen in `$aws/things/thingName/shadow/update/accepted` veröffentlicht. Weitere Informationen zu Device Shadows finden Sie unter [Device Shadow Service](https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html) im *AWS IoT Entwicklerhandbuch*.
In der `WHERE`-Klausel verwendet diese Regelabfrageanweisung die `topic(3)`-Funktion, um den Namen des Objekts aus dem dritten Segment des Themas abzurufen. Anschließend filtert die Anweisung Geräte heraus, die Namen haben, die nicht mit denen der Geräte für das Tutorial übereinstimmen. Weitere Informationen zu AWS IoT SQL finden Sie in der [AWS IoT SQL-Referenz](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-reference.html) im *AWS IoT Entwicklerhandbuch*.
1. Wählen Sie unter **Regelaktionen** die Option **Nachrichtendaten an Asset-Eigenschaften senden in** aus AWS IoT SiteWise und gehen Sie wie folgt vor:
1. Wählen Sie **By property alias (Nach Eigenschaftenalias)**.
1. Geben Sie unter **Property alias (Eigenschaftenalias)** **/tutorial/device/\$1\$1topic(3)\$1/cpu** ein.
Die `${...}` Syntax ist eine Ersatzvorlage. AWS IoT wertet den Inhalt in den geschweiften Klammern aus. Diese Substitutionsvorlage ruft den Namen des Objekts aus dem Thema ab, um einen Alias zu erstellen, der für jedes Thema eindeutig ist. *Weitere Informationen finden Sie im [Entwicklerhandbuch unter AWS IoT Substitutionsvorlagen](https://docs.aws.amazon.com/iot/latest/developerguide/iot-substitution-templates.html).*
**Anmerkung**
Da ein Ausdruck in einer Substitutionsvorlage getrennt von der `SELECT`-Anweisung ausgewertet wird, können Sie keine Substitutionsvorlage verwenden, um auf einen Alias zu verweisen, der mit einer `AS`-Klausel erstellt wurde. Zusätzlich zu den unterstützten Funktionen und Operatoren können Sie nur in der ursprünglichen Nutzlast vorhandene Informationen referenzieren.
1. Geben **\$1\$1concat(topic(3), "-cpu-", floor(state.reported.timestamp))\$1** Sie im Feld **Eintrags-ID — *optional*** den Wert ein.
Der Eintrag identifiziert jeden Versuch, einen Wert einzugeben, IDs eindeutig. Wenn ein Eintrag einen Fehler zurückgibt, finden Sie die Eintrags-ID in der Fehlerausgabe, um das Problem zu beheben. Die Substitutionsvorlage in dieser Eintrags-ID kombiniert den Namen des Objekts und den gemeldeten Zeitstempel des Geräts. Beispielsweise könnte die resultierende Eintrags-ID wie `SiteWiseTutorialDevice1-cpu-1579808494` aussehen.
1. Geben Sie unter **Time in seconds (Zeit in Sekunden)** **\$1\$1floor(state.reported.timestamp)\$1** ein.
Diese Substitutionsvorlage berechnet die Zeit in Sekunden aus dem gemeldeten Zeitstempel des Geräts. In diesem Tutorial melden Geräte Zeitstempel in Sekunden nach Unix-Epoche als Gleitkommazahl.
1. Geben **\$1\$1floor((state.reported.timestamp % 1) \$1 1E9)\$1** Sie im Feld **Offset in Nanos — *optional*** den Wert ein.
Diese Substitutionsvorlage berechnet die Verschiebung in Nanosekunden aus der Zeit in Sekunden, indem der Dezimalteil des gemeldeten Zeitstempels des Geräts konvertiert wird.
**Anmerkung**
AWS IoT SiteWise setzt voraus, dass Ihre Daten einen aktuellen Zeitstempel in der Unix-Epochenzeit haben. Wenn Ihre Geräte die Zeit nicht genau melden, können Sie die aktuelle Zeit von der AWS IoT -Regelengine mit [timestamp()](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sql-functions.html#iot-function-timestamp)abrufen. Diese Funktion meldet die Zeit in Millisekunden. Daher müssen Sie die Zeitparameter Ihrer Regelaktion auf die folgenden Werte aktualisieren:
Geben Sie unter **Time in seconds (Zeit in Sekunden)** **\$1\$1floor(timestamp() / 1E3)\$1** ein.
Geben Sie unter **Offset in Nanos (Verschiebung in Nanosekunden)** **\$1\$1(timestamp() % 1E3) \$1 1E6\$1** ein.
1. Wählen Sie unter **Data type (Datentyp)** die Option **Double (Doppelt)**.
Dieser Datentyp muss mit dem Datentyp der Komponenteneigenschaft übereinstimmen, die Sie im Komponentenmodell definiert haben.
1. Geben Sie unter **Value (Wert)** **\$1\$1state.reported.cpu\$1** ein. In Substitutionsvorlagen verwenden Sie den `.`-Operator, um einen Wert aus einer JSON-Struktur abzurufen.
1. Wählen Sie **Add entry (Eintrag hinzufügen)**, um einen neuen Eintrag für die Speicherbelegungseigenschaft hinzuzufügen, und führen Sie die folgenden Schritte für diese Eigenschaft erneut aus:
1. Wählen Sie **By property alias (Nach Eigenschaftenalias)**.
1. Geben Sie unter **Property alias (Eigenschaftenalias)** **/tutorial/device/\$1\$1topic(3)\$1/memory** ein.
1. Geben Sie im **Feld Eintrags-ID — *optional*** den Wert ein. **\$1\$1concat(topic(3), "-memory-", floor(state.reported.timestamp))\$1**
1. Geben Sie unter **Time in seconds (Zeit in Sekunden)** **\$1\$1floor(state.reported.timestamp)\$1** ein.
1. Geben **\$1\$1floor((state.reported.timestamp % 1) \$1 1E9)\$1** Sie im Feld **Offset in Nanos — *optional*** den Wert ein.
1. Wählen Sie unter **Data type (Datentyp)** die Option **Double (Doppelt)**.
1. Geben Sie unter **Value (Wert)** **\$1\$1state.reported.memory\$1** ein.
1. Wählen Sie unter **IAM-Rolle** die Option **Neue Rolle erstellen** aus, um eine IAM-Rolle für diese Regelaktion zu erstellen. Diese Rolle ermöglicht AWS IoT die Übertragung von Daten auf Eigenschaften in Ihrer Geräteflotte und deren Asset-Hierarchie.
1. Geben Sie einen Rollennamen ein und wählen Sie **Create**.
1. (Optional) Konfigurieren Sie eine Fehleraktion, die Sie zur Problembehandlung Ihrer Regel verwenden können. Weitere Informationen finden Sie unter [Problembehandlung bei einer Regel ()AWS IoT SiteWise](troubleshoot-rule.md#rule-tutorial-troubleshoot-rule).
1. Wählen Sie **Weiter** aus.
1. Überprüfen Sie die Einstellungen und wählen Sie **Erstellen**, um die Regel zu erstellen.
## Schritt 8: Führen Sie das Geräteclient-Skript aus
In diesem Tutorial verwenden Sie kein echtes Gerät, um Daten zu melden. Stattdessen führen Sie ein Skript aus, um den Geräteschatten AWS IoT Ihres Geräts mit der CPU- und Speicherauslastung zu aktualisieren, um echte Sensordaten nachzuahmen. Um das Skript auszuführen, müssen Sie zuerst die erforderlichen Python Pakete installieren. In diesem Verfahren installieren Sie die erforderlichen Python Pakete und führen dann das Geräteclientskript aus.
**So konfigurieren und führen Sie das Geräte-Clientskript aus**
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iot/).
1. Wählen Sie unten im linken Navigationsbereich **Settings (Einstellungen)** aus.
1. Speichern Sie Ihren benutzerdefinierten Endpunkt zur Verwendung mit dem Geräte-Clientskript. Sie verwenden diesen Endpunkt, um mit den Schatten Ihres Objekts zu interagieren. Dieser Endpunkt ist eindeutig für Ihr Konto in der aktuellen Region.
Ihr benutzerdefinierter Endpunkt sollte wie im folgenden Beispiel aussehen.
```
identifier.iot.region.amazonaws.com
```
1. Öffnen Sie eine Befehlszeile, und führen Sie den folgenden Befehl aus, um zu dem zuvor erstellten Tutorialverzeichnis zu navigieren.
```
cd iot-sitewise-rule-tutorial
```
1. Führen Sie den folgenden Befehl aus, um das AWS IoT-Geräte-SDK for Python zu installieren:
```
pip3 install AWSIoTPythonSDK
```
Weitere Informationen finden Sie [AWS IoT-Geräte-SDK for Python](https://docs.aws.amazon.com/iot/latest/developerguide/iot-sdks.html#iot-python-sdk)im *AWS IoT Entwicklerhandbuch*
1. Führen Sie den folgenden Befehl aus, um psutil, eine plattformübergreifende Prozess- und Systemdienstprogrammbibliothek, zu installieren.
```
pip3 install psutil
```
Weitere Informationen finden Sie unter [psutil](https://pypi.org/project/psutil/) im *Python-Paketindex*.
1. Erstellen Sie eine Datei mit dem Namen `thing_performance.py` im Verzeichnis `iot-sitewise-rule-tutorial`, und kopieren Sie dann den folgenden Python-Code in diese Datei.
```
import AWSIoTPythonSDK.MQTTLib as AWSIoTPyMQTT
import json
import psutil
import argparse
import logging
import time
# Configures the argument parser for this program.
def configureParser():
parser = argparse.ArgumentParser()
parser.add_argument(
"-e",
"--endpoint",
action="store",
required=True,
dest="host",
help="Your AWS IoT custom endpoint",
)
parser.add_argument(
"-r",
"--rootCA",
action="store",
required=True,
dest="rootCAPath",
help="Root CA file path",
)
parser.add_argument(
"-c",
"--cert",
action="store",
required=True,
dest="certificatePath",
help="Certificate file path",
)
parser.add_argument(
"-k",
"--key",
action="store",
required=True,
dest="privateKeyPath",
help="Private key file path",
)
parser.add_argument(
"-p",
"--port",
action="store",
dest="port",
type=int,
default=8883,
help="Port number override",
)
parser.add_argument(
"-n",
"--thingName",
action="store",
required=True,
dest="thingName",
help="Targeted thing name",
)
parser.add_argument(
"-d",
"--requestDelay",
action="store",
dest="requestDelay",
type=float,
default=1,
help="Time between requests (in seconds)",
)
parser.add_argument(
"-v",
"--enableLogging",
action="store_true",
dest="enableLogging",
help="Enable logging for the AWS IoT Device SDK for Python",
)
return parser
# An MQTT shadow client that uploads device performance data to AWS IoT at a regular interval.
class PerformanceShadowClient:
def __init__(
self,
thingName,
host,
port,
rootCAPath,
privateKeyPath,
certificatePath,
requestDelay,
):
self.thingName = thingName
self.host = host
self.port = port
self.rootCAPath = rootCAPath
self.privateKeyPath = privateKeyPath
self.certificatePath = certificatePath
self.requestDelay = requestDelay
# Updates this thing's shadow with system performance data at a regular interval.
def run(self):
print("Connecting MQTT client for {}...".format(self.thingName))
mqttClient = self.configureMQTTClient()
mqttClient.connect()
print("MQTT client for {} connected".format(self.thingName))
deviceShadowHandler = mqttClient.createShadowHandlerWithName(
self.thingName, True
)
print("Running performance shadow client for {}...\n".format(self.thingName))
while True:
performance = self.readPerformance()
print("[{}]".format(self.thingName))
print("CPU:\t{}%".format(performance["cpu"]))
print("Memory:\t{}%\n".format(performance["memory"]))
payload = {"state": {"reported": performance}}
deviceShadowHandler.shadowUpdate(
json.dumps(payload), self.shadowUpdateCallback, 5
)
time.sleep(args.requestDelay)
# Configures the MQTT shadow client for this thing.
def configureMQTTClient(self):
mqttClient = AWSIoTPyMQTT.AWSIoTMQTTShadowClient(self.thingName)
mqttClient.configureEndpoint(self.host, self.port)
mqttClient.configureCredentials(
self.rootCAPath, self.privateKeyPath, self.certificatePath
)
mqttClient.configureAutoReconnectBackoffTime(1, 32, 20)
mqttClient.configureConnectDisconnectTimeout(10)
mqttClient.configureMQTTOperationTimeout(5)
return mqttClient
# Returns the local device's CPU usage, memory usage, and timestamp.
def readPerformance(self):
cpu = psutil.cpu_percent()
memory = psutil.virtual_memory().percent
timestamp = time.time()
return {"cpu": cpu, "memory": memory, "timestamp": timestamp}
# Prints the result of a shadow update call.
def shadowUpdateCallback(self, payload, responseStatus, token):
print("[{}]".format(self.thingName))
print("Update request {} {}\n".format(token, responseStatus))
# Configures debug logging for the AWS IoT Device SDK for Python.
def configureLogging():
logger = logging.getLogger("AWSIoTPythonSDK.core")
logger.setLevel(logging.DEBUG)
streamHandler = logging.StreamHandler()
formatter = logging.Formatter(
"%(asctime)s - %(name)s - %(levelname)s - %(message)s"
)
streamHandler.setFormatter(formatter)
logger.addHandler(streamHandler)
# Runs the performance shadow client with user arguments.
if __name__ == "__main__":
parser = configureParser()
args = parser.parse_args()
if args.enableLogging:
configureLogging()
thingClient = PerformanceShadowClient(
args.thingName,
args.host,
args.port,
args.rootCAPath,
args.privateKeyPath,
args.certificatePath,
args.requestDelay,
)
thingClient.run()
```
1. Führen Sie **thing\$1performance.py** über die Befehlszeile mit den folgenden Parametern aus:
+ `-n`, `--thingName` — Der Name Ihres Dings, z. **SiteWiseTutorialDevice1** B.
+ `-e`, `--endpoint` — Ihr benutzerdefinierter AWS IoT Endpunkt, den Sie zuvor in diesem Verfahren gespeichert haben.
+ `-r`, `--rootCA` — Der Pfad zu Ihrem AWS IoT Root-CA-Zertifikat.
+ `-c`, `--cert` — Der Pfad zu deinem AWS IoT Ding-Zertifikat.
+ `-k`, `--key` — Der Pfad zu Ihrem privaten Schlüssel AWS IoT für Ihr Ding-Zertifikat.
+ `-d`, `--requestDelay` — (Optional) Die Wartezeit in Sekunden zwischen den einzelnen Device-Shadow-Updates. Standard ist 1 Sekunde.
+ `-v`, `--enableLogging` — (Optional) Wenn dieser Parameter vorhanden ist, druckt das Skript Debug-Meldungen von. AWS IoT-Geräte-SDK for Python
Ihr Befehl sollte ähnlich wie im folgenden Beispiel aussehen.
```
python3 thing_performance.py \
--thingName SiteWiseTutorialDevice1 \
--endpoint identifier.iot.region.amazonaws.com \
--rootCA AmazonRootCA1.pem \
--cert device1/thing-id-certificate.pem.crt \
--key device1/thing-id-private.pem.key
```
Wenn Sie das Skript für zusätzliche AWS IoT Dinge ausführen, aktualisieren Sie den Namen und das Zertifikatsverzeichnis entsprechend.
1. Versuchen Sie, Programme auf Ihrem Gerät zu öffnen und zu schließen, um zu sehen, wie sich die CPU- und Speichernutzung ändern. Das Skript druckt jede Ablesung von CPU- und Speichernutzung. Wenn das Skript Daten erfolgreich zum Geräteschattenservice hochlädt, sollte die Ausgabe des Skripts wie im folgenden Beispiel aussehen.
```
[SiteWiseTutorialDevice1]
CPU: 24.6%
Memory: 85.2%
[SiteWiseTutorialDevice1]
Update request e6686e44-fca0-44db-aa48-3ca81726f3e3 accepted
```
1. Gehen Sie folgendermaßen vor, um zu überprüfen, ob das Skript den Geräteschatten aktualisiert:
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iot/).
1. Wählen Sie im linken Navigationsbereich **Alle Geräte** und dann **Dinge** aus.
1. Wähle dein Ding, **SiteWiseTutorialDevice**.
1. Wählen Sie die Registerkarte **Geräteschatten**, wählen Sie **Classic Shadow** und vergewissern Sie sich, dass der **Shadow-Status** wie im folgenden Beispiel aussieht.
```
{
"reported": {
"cpu": 24.6,
"memory": 85.2,
"timestamp": 1579567542.2835066
}
}
```
Wenn der Schattenstatus Ihres Dings leer ist oder nicht wie im vorherigen Beispiel aussieht, überprüfen Sie, ob das Skript ausgeführt wird und ob die Verbindung erfolgreich hergestellt wurde AWS IoT. Wenn das Skript beim Herstellen einer Verbindung zu weiterhin zu einem Timeout kommt AWS IoT, überprüfen Sie, ob Ihre [Ding-Richtlinie](#ingestion-tutorial-create-iot-policy) gemäß dieser Anleitung konfiguriert ist.
1. Gehen Sie folgendermaßen vor, um zu überprüfen, ob die Regelaktion Daten an AWS IoT SiteWise sendet:
1. Navigieren Sie zur [AWS IoT SiteWise -Konsole](https://console.aws.amazon.com/iotsitewise/).
1. Klicken Sie im linken Navigationsbereich auf **Assets (Komponenten)**.
1. Klicken Sie auf den Pfeil neben Ihrem Geräteflotten-Asset (**SiteWise Tutorial Device Fleet 1**), um dessen Asset-Hierarchie zu erweitern, und wählen Sie dann Ihr Geräte-Asset (**SiteWise Tutorial Device1**) aus.
1. Wählen Sie **Measurements (Messungen)**.
1. Stellen Sie sicher, dass die Zellen **Latest value (Letzter Wert)** Werte für die Eigenschaften **CPU Usage** und **Memory Usage** aufweisen.
![\[Screenshot mit hervorgehobenem „Messungen“.\]](http://docs.aws.amazon.com/de_de/iot-sitewise/latest/userguide/images/rule-ingestion/sitewise-view-measurement-values-console.png)
1. Wenn die Eigenschaften **CPU Usage** und **Memory Usage** nicht über die neuesten Werte verfügen, aktualisieren Sie die Seite. Wenn nach einigen Minuten keine Werte angezeigt werden, finden Sie weitere Informationen unter [Problembehandlung bei einer Regel ()AWS IoT SiteWise](troubleshoot-rule.md#rule-tutorial-troubleshoot-rule).
Sie haben dieses Tutorial abgeschlossen. Wenn Sie Live-Visualisierungen Ihrer Daten untersuchen möchten, können Sie ein Portal in AWS IoT SiteWise Monitor konfigurieren. Weitere Informationen finden Sie unter [Überwachen Sie Daten mit AWS IoT SiteWise Monitor](monitor-data.md). Andernfalls können Sie **STRG\$1C** in der Eingabeaufforderung betätigen, um das Geräte-Clientskript zu stoppen. Es ist unwahrscheinlich, dass das Python-Programm so viele Nachrichten sendet, dass Kosten anfallen, aber es hat sich bewährt, das Programm zu beenden, wenn Sie fertig sind.
## Schritt 9: Ressourcen nach dem Tutorial bereinigen
**Anmerkung**
Die in diesem Tutorial erstellten Ressourcen sind für das Tutorial [Daten in SiteWise Edge integrieren](integrate_sitewise_edge_mqtt.md) erforderlich. Bereinigen Sie die Ressourcen in diesem Schritt nicht, wenn Sie ihn abschließen möchten.
Nachdem Sie das Tutorial zur Erfassung von Daten aus AWS IoT Dingen abgeschlossen haben, sollten Sie Ihre Ressourcen bereinigen, um zusätzliche Kosten zu vermeiden.
**So löschen Sie hierarchische Objekte in AWS IoT SiteWise**
1. [Navigieren Sie zur Konsole AWS IoT SiteWise](https://console.aws.amazon.com/iotsitewise/)
1. Klicken Sie im linken Navigationsbereich auf **Assets (Komponenten)**.
1. Wenn Sie Elemente in löschen AWS IoT SiteWise, müssen Sie sie zunächst trennen.
Führen Sie die folgenden Schritte aus, um die Zuordnung Ihrer Gerätekomponenten zu Ihrer Geräteflottenkomponente aufzuheben:
1. Wählen Sie Ihr Geräteflotten-Asset (**SiteWise Tutorial Device Fleet 1**) aus.
1. Wählen Sie **Bearbeiten** aus.
1. Wählen Sie unter **Assets associated to this asset (Dieser Komponente zugeordnete Komponenten)** die Option **Disassociate (Zuordnung aufheben)** für jede Gerätekomponente, die dieser Geräteflottenkomponente zugeordnet ist.
1. Wählen Sie **Speichern**.
Sie sollten nun Ihre Gerätekomponenten nicht mehr als Hierarchie organisiert sehen.
1. Wählen Sie Ihre Gerätekomponente ( **SiteWise Tutorial Device 1**).
1. Wählen Sie **Löschen** aus.
1. Geben Sie in das Bestätigungsfeld **Delete** ein, und wählen Sie dann **Delete (Löschen)**.
1. Wiederholen Sie die Schritte 4 bis 6 für jedes Geräte-Asset und das Geräteflotten-Asset (**SiteWise Tutorial Device Fleet 1**).
**Um hierarchische Asset-Modelle zu löschen in AWS IoT SiteWise**
1. Navigieren Sie zur [AWS IoT SiteWise -Konsole](https://console.aws.amazon.com/iotsitewise/).
1. Wenn Sie dies noch nicht getan haben, löschen Sie Ihre Geräte- und Geräteflottenkomponenten. Weitere Informationen finden Sie im [vorhergehenden Verfahren](#rule-tutorial-delete-assets). Sie können ein Modell nicht löschen, wenn Sie Komponenten haben, die aus diesem Modell erstellt wurden.
1. Wählen Sie im linken Navigationsbereich **Models (Modelle)** aus.
1. Wählen Sie Ihr Geräteflottenkomponentenmodell (**SiteWise Tutorial Device Fleet Model**).
Wenn Sie hierarchische Anlagenmodelle löschen, löschen Sie zunächst das übergeordnete Anlagenmodell.
1. Wählen Sie **Löschen** aus.
1. Geben Sie in das Bestätigungsfeld **Delete** ein, und wählen Sie dann **Delete (Löschen)**.
1. Wiederholen Sie die Schritte 4 bis 6 für Ihr Gerätekomponentenmodell (**SiteWise Tutorial Device Model**).
**Um eine Regel zu deaktivieren oder zu löschen in AWS IoT Core**
1. Navigieren Sie zur [AWS IoT -Konsole](https://console.aws.amazon.com/iot/).
1. Wählen Sie im linken Navigationsbereich **Nachrichtenweiterleitung** und dann **Regeln** aus.
1. Wählen Sie Ihre Regel aus und klicken Sie auf **Löschen**.
1. Geben Sie im Bestätigungsdialogfeld den Namen der Regel ein und wählen Sie dann **Löschen**.