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.
# Datenströme auf Greengrass-Kerngeräten verwalten
AWS IoT Greengrass Stream Manager macht es effizienter und zuverlässiger, großvolumige IoT-Daten auf den AWS Cloud zu übertragen. Stream Manager verarbeitet Datenströme auf dem AWS IoT Greengrass Core, bevor er sie in den AWS Cloud exportiert. Stream Manager lässt sich in gängige Szenarien wie maschinelles Lernen (ML) -Inferenz integrieren, bei denen das AWS IoT Greengrass Core-Gerät Daten verarbeitet und analysiert, bevor es die Daten an die AWS Cloud oder lokale Speicherziele exportiert.
Stream Manager bietet eine gemeinsame Schnittstelle zur Vereinfachung der Entwicklung benutzerdefinierter Komponenten, sodass Sie keine benutzerdefinierten Stream-Management-Funktionen erstellen müssen. Ihre Komponenten können einen standardisierten Mechanismus verwenden, um Streams mit hohem Volumen zu verarbeiten und lokale Datenaufbewahrungsrichtlinien zu verwalten. Sie können Richtlinien für Speichertyp, Größe und Datenspeicherung für jeden Stream definieren, um zu steuern, wie Stream Manager Daten verarbeitet und exportiert.
Stream Manager funktioniert in Umgebungen mit intermittierender oder eingeschränkter Konnektivität. Sie können die Bandbreitennutzung, das Timeout-Verhalten und die Art und Weise definieren, wie der AWS IoT Greengrass Core mit Stream-Daten umgeht, wenn er verbunden oder getrennt wird. Sie können auch Prioritäten festlegen, um die Reihenfolge zu steuern, in der der AWS IoT Greengrass Core Streams in die exportiert. AWS Cloud Auf diese Weise können Sie kritische Daten früher verarbeiten als andere Daten.
Sie können den Stream-Manager so konfigurieren, dass Daten automatisch AWS Cloud zur Speicherung oder Weiterverarbeitung und Analyse in den exportiert werden. Stream Manager unterstützt Exporte an die folgenden AWS Cloud Ziele:
+ Kanäle rein AWS IoT Analytics. AWS IoT Analytics ermöglicht es Ihnen, erweiterte Analysen Ihrer Daten durchzuführen, um Geschäftsentscheidungen zu treffen und Modelle für maschinelles Lernen zu verbessern. Weitere Informationen finden Sie unter [Was ist AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) im *AWS IoT Analytics -Benutzerhandbuch*.
+ Streams in Amazon Kinesis Data Streams. Sie können Kinesis Data Streams verwenden, um große Datenmengen zu aggregieren und in ein Data Warehouse oder MapReduce Cluster zu laden. Weitere Informationen finden Sie unter [Was ist Amazon Kinesis Data Streams?](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html) im *Entwicklerhandbuch für Amazon Kinesis Data Streams*.
+ Eigenschaften von Vermögenswerten in. AWS IoT SiteWise AWS IoT SiteWise ermöglicht das Sammeln, Organisieren und Analysieren von Daten aus Industrieanlagen in großem Maßstab. Weitere Informationen finden Sie unter [Was ist AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) im *AWS IoT SiteWise Benutzerhandbuch*.
+ Objekte in Amazon Simple Storage Service Amazon S3. Sie können Amazon S3 verwenden, um große Datenmengen zu speichern und abzurufen. Weitere Informationen finden Sie unter [Was ist Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) im *Amazon Simple Storage Service Developer Guide*.
## Stream-Management-Workflow
Ihre IoT-Anwendungen interagieren über das Stream Manager SDK mit dem Stream Manager.
In einem einfachen Arbeitsablauf verwendet eine Komponente im AWS IoT Greengrass Kern IoT-Daten, wie z. B. Temperatur- und Druckmesswerte in Zeitreihen. Die Komponente könnte die Daten filtern oder komprimieren und dann das Stream Manager SDK aufrufen, um die Daten in einen Stream im Stream Manager zu schreiben. Stream Manager kann den Stream auf der Grundlage der Richtlinien, die Sie für den Stream definieren, AWS Cloud automatisch in den exportieren. Komponenten können Daten auch direkt an lokale Datenbanken oder Speicher-Repositorys senden.
Ihre IoT-Anwendungen können mehrere benutzerdefinierte Komponenten enthalten, die Streams lesen oder in sie schreiben. Diese Komponenten können Streams lesen und in sie schreiben, um Daten auf dem AWS IoT Greengrass Kerngerät zu filtern, zu aggregieren und zu analysieren. Dies ermöglicht es, schnell auf lokale Ereignisse zu reagieren und wertvolle Informationen zu extrahieren, bevor die Daten vom Core zu den AWS Cloud oder lokalen Zielen übertragen werden.
Stellen Sie zunächst die Stream Manager-Komponente auf Ihrem AWS IoT Greengrass Kerngerät bereit. Konfigurieren Sie bei der Bereitstellung die Parameter der Stream Manager-Komponente, um Einstellungen zu definieren, die für alle Streams auf dem Greengrass-Core-Gerät gelten. Verwenden Sie diese Parameter, um zu steuern, wie Stream Manager Streams auf der Grundlage Ihrer Geschäftsanforderungen und Umgebungsbeschränkungen speichert, verarbeitet und exportiert.
Nachdem Sie den Stream Manager konfiguriert haben, können Sie Ihre IoT-Anwendungen erstellen und bereitstellen. Dabei handelt es sich in der Regel um benutzerdefinierte Komponenten, die `StreamManagerClient` im Stream Manager SDK verwendet werden, um Streams zu erstellen und mit ihnen zu interagieren. Wenn Sie einen Stream erstellen, können Sie Richtlinien pro Stream definieren, z. B. Exportziele, Priorität und Persistenz.
## Voraussetzungen
Die folgenden Anforderungen gelten für die Verwendung von Stream Manager:
+ Stream Manager benötigt zusätzlich zur AWS IoT Greengrass Core-Software mindestens 70 MB RAM. Ihr gesamter Speicherbedarf hängt von Ihrer Arbeitslast ab.
+ AWS IoT Greengrass Komponenten müssen das Stream Manager SDK verwenden, um mit dem Stream Manager zu interagieren. Das Stream Manager SDK ist in den folgenden Sprachen verfügbar:
+ [Stream Manager SDK for Java](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-java/) (v1.1.0 oder höher)
+ [Stream Manager SDK für Node.js](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-js/) (v1.1.0 oder höher)
+ [Stream Manager SDK für Python](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-python/) (v1.1.0 oder höher)
+ AWS IoT Greengrass Komponenten müssen die Stream-Manager-Komponente (`aws.greengrass.StreamManager`) als Abhängigkeit in ihrem Rezept angeben, um den Stream-Manager verwenden zu können.
**Anmerkung**
Wenn Sie den Stream Manager verwenden, um Daten in die Cloud zu exportieren, können Sie Version 2.0.7 der Stream Manager-Komponente nicht auf eine Version zwischen v2.0.8 und v2.0.11 aktualisieren. Wenn Sie Stream Manager zum ersten Mal bereitstellen, empfehlen wir dringend, die neueste Version der Stream Manager-Komponente bereitzustellen.
+ Wenn Sie AWS Cloud Exportziele für einen Stream definieren, müssen Sie Ihre Exportziele erstellen und Zugriffsberechtigungen in der [Greengrass-Geräterolle](device-service-role.md) gewähren. Je nach Ziel können auch andere Anforderungen gelten. Weitere Informationen finden Sie unter:
+ [AWS IoT Analytics Kanäle](stream-export-configurations.md#export-to-iot-analytics)
+ [Amazon Kinesis Kinesis-Datenströme](stream-export-configurations.md#export-to-kinesis)
+ [AWS IoT SiteWise Eigenschaften von Vermögenswerten](stream-export-configurations.md#export-to-iot-sitewise)
+ [Amazon-S3-Objekte](stream-export-configurations.md#export-to-s3)
Sie sind für die Wartung dieser AWS Cloud Ressourcen verantwortlich.
## Datensicherheit
Beachten Sie bei der Verwendung des Stream-Managers die folgenden Sicherheitsüberlegungen.
### Lokale Datensicherheit
AWS IoT Greengrass verschlüsselt keine Stream-Daten im Ruhezustand oder bei der Übertragung zwischen lokalen Komponenten auf dem Kerngerät.
+ **Daten im Ruhezustand**. Streamdaten werden lokal in einem Speicherverzeichnis gespeichert. Verlässt sich aus Gründen der Datensicherheit AWS IoT Greengrass auf Dateiberechtigungen und vollständige Festplattenverschlüsselung, sofern diese Option aktiviert ist. Sie können den optionalen Parameter [STREAM\$1MANAGER\$1STORE\$1ROOT\$1DIR](configure-stream-manager.md#STREAM_MANAGER_STORE_ROOT_DIR) verwenden, um das Speicherverzeichnis anzugeben. Wenn Sie diesen Parameter später ändern, um ein anderes Speicherverzeichnis zu verwenden, werden das vorherige Speicherverzeichnis und sein Inhalt AWS IoT Greengrass nicht gelöscht.
+ **Daten werden lokal übertragen**. AWS IoT Greengrass verschlüsselt keine Stream-Daten bei der lokalen Übertragung zwischen Datenquellen, AWS IoT Greengrass Komponenten, dem Stream Manager SDK und Stream Manager.
+ **Daten bei der Übertragung zum AWS Cloud**. Datenströme, die vom Stream Manager exportiert werden, AWS Cloud verwenden die standardmäßige AWS Service-Client-Verschlüsselung mit Transport Layer Security (TLS).
### Client-Authentifizierung
Stream Manager-Clients verwenden das Stream Manager SDK, um mit dem Stream Manager zu kommunizieren. Wenn die Client-Authentifizierung aktiviert ist, können nur Greengrass-Komponenten mit Streams im Stream Manager interagieren. Wenn die Client-Authentifizierung deaktiviert ist, kann jeder Prozess, der auf dem Greengrass-Core-Gerät ausgeführt wird, mit Streams im Stream Manager interagieren. Sie sollten die Authentifizierung nur deaktivieren, wenn Ihr Geschäftsfall dies erfordert.
Sie verwenden den Parameter [STREAM\$1MANAGER\$1AUTHENTICATE\$1CLIENT](configure-stream-manager.md#STREAM_MANAGER_AUTHENTICATE_CLIENT), um den Clientauthentifizierungsmodus festzulegen. Sie können diesen Parameter konfigurieren, wenn Sie die Stream Manager-Komponente auf Kerngeräten bereitstellen.
****
| | Enabled | Disabled |
| --- | --- | --- |
| Parameterwert | `true` (Standard und empfohlen) | `false` |
| Zulässige Clients | Greengrass-Komponenten auf dem Kerngerät | Greengrass-Komponenten auf dem Kerngerät Andere Prozesse, die auf dem Greengrass Core-Gerät ausgeführt werden |
## Weitere Informationen finden Sie auch unter
+ [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md)
+ [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
# AWS IoT Greengrass Streammanager konfigurieren
Auf Greengrass-Core-Geräten kann Stream Manager IoT-Gerätedaten speichern, verarbeiten und exportieren. Stream Manager stellt Parameter bereit, mit denen Sie Laufzeiteinstellungen konfigurieren. Diese Einstellungen gelten für alle Streams auf dem Greengrass-Core-Gerät. Sie können die AWS IoT Greengrass Konsole oder API verwenden, um die Stream Manager-Einstellungen zu konfigurieren, wenn Sie die Komponente bereitstellen. Änderungen werden nach Abschluss der Bereitstellung wirksam.
## Stream-Manager-Parameter
Stream Manager stellt die folgenden Parameter bereit, die Sie konfigurieren können, wenn Sie die Komponente auf Ihren Kerngeräten bereitstellen. Alle Parameter sind optional.
**Speicherverzeichnis**
Parametername: `STREAM_MANAGER_STORE_ROOT_DIR`
Der absolute Pfad des lokalen Ordners, der zum Speichern von Streams verwendet wird. Dieser Wert muss mit einem Schrägstrich (z. B. `/data`) beginnen.
Sie müssen einen vorhandenen Ordner angeben, und der [Systembenutzer, der die Stream Manager-Komponente ausführt,](configure-greengrass-core-v2.md#configure-component-user) muss über Lese- und Schreibberechtigungen für diesen Ordner verfügen. Sie können beispielsweise die folgenden Befehle ausführen, um einen Ordner zu erstellen und zu konfigurieren`/var/greengrass/streams`, den Sie als Stream-Manager-Stammordner angeben. Mit diesen Befehlen kann der Standardsystembenutzer,`ggc_user`, in diesen Ordner lesen und in ihn schreiben.
```
sudo mkdir /var/greengrass/streams
sudo chown ggc_user /var/greengrass/streams
sudo chmod 700 /var/greengrass/streams
```
Hinweise zum Sichern von Streamdaten finden Sie unter [Lokale Datensicherheit](manage-data-streams.md#stream-manager-security-stream-data).
Standard: `/greengrass/v2/work/aws.greengrass.StreamManager`
**Server port**
Parametername: `STREAM_MANAGER_SERVER_PORT`
Die lokale Portnummer, die für die Kommunikation mit dem Stream-Manager verwendet wird. Der Standardwert ist `8088`.
Sie können angeben`0`, dass ein zufälliger verfügbarer Port verwendet werden soll.
**Client authentifizieren**
Parametername: `STREAM_MANAGER_AUTHENTICATE_CLIENT`
Gibt an, ob Clients authentifiziert werden müssen, um mit dem Stream-Manager zu interagieren. Die gesamte Interaktion zwischen Clients und Stream Manager wird vom Stream Manager SDK gesteuert. Dieser Parameter bestimmt, welche Clients das Stream Manager SDK aufrufen können, um mit Streams zu arbeiten. Weitere Informationen finden Sie unter [Client-Authentifizierung](manage-data-streams.md#stream-manager-security-client-authentication).
Gültige Werte sind `true` oder `false`. Der Standardwert ist `true` (empfohlen).
+ `true`. Erlaubt nur Greengrass-Komponenten als Clients. Komponenten verwenden interne AWS IoT Greengrass Core-Protokolle, um sich mit dem Stream Manager SDK zu authentifizieren.
+ `false`. Ermöglicht es jedem Prozess, der auf dem AWS IoT Greengrass Core läuft, ein Client zu sein. Setzen Sie den Wert nicht auf, `false` es sei denn, Ihr Geschäftsszenario erfordert dies. Verwenden Sie diese Option beispielsweise `false` nur, wenn Prozesse, die keine Komponenten sind, auf dem Kerngerät direkt mit dem Stream Manager kommunizieren müssen.
**Maximale Bandbreite**
Parametername: `STREAM_MANAGER_EXPORTER_MAX_BANDWIDTH`
Die durchschnittliche maximale Bandbreite (in Kilobit pro Sekunde), die zum Exportieren von Daten verwendet werden kann. Die Standardeinstellung erlaubt die unbegrenzte Nutzung der verfügbaren Bandbreite.
**Größe des Threadpools**
Parametername: `STREAM_MANAGER_EXPORTER_THREAD_POOL_SIZE`
Die maximale Anzahl der aktiven Threads, die zum Exportieren von Daten verwendet werden können. Der Standardwert ist `5`.
Die optimale Größe hängt von der Hardware, dem Stream-Volume und der geplanten Anzahl der Exportstreams ab. Wenn die Exportgeschwindigkeit langsam ist, können Sie diese Einstellung anpassen, um die optimale Größe für Ihre Hardware und Ihren Geschäftsfall zu ermitteln. Die CPU und der Arbeitsspeicher Ihrer Core-Geräte-Hardware sind begrenzende Faktoren. Um zu starten, können Sie versuchen, diesen Wert gleich der Anzahl der Prozessorkerne auf dem Gerät festzulegen.
Achten Sie darauf, keine Größe festzulegen, die höher ist, als Ihre Hardware unterstützen kann. Jeder Stream verbraucht Hardwareressourcen. Versuchen Sie daher, die Anzahl der Exportstreams auf beschränkten Geräten zu begrenzen.
**JVM-Argumente**
Parametername: `JVM_ARGS`
Benutzerdefinierte Java Virtual Machine-Argumente, die beim Start an den Stream-Manager übergeben werden. Mehrere Argumente sollten durch Leerzeichen getrennt werden.
Verwenden Sie diesen Parameter nur, wenn Sie die von der JVM verwendeten Standardeinstellungen außer Kraft setzen müssen. Beispielsweise müssen Sie möglicherweise die Standard-Heap-Größe erhöhen, wenn Sie eine große Anzahl von Streams exportieren möchten.
**Protokollierungsstufe**
Parametername: `LOG_LEVEL`
Die Protokollierungsebene für die Komponente. Wählen Sie aus den folgenden Protokollebenen, die hier in der Reihenfolge der Stufen aufgeführt sind:
+ `TRACE`
+ `DEBUG`
+ `INFO`
+ `WARN`
+ `ERROR`
Standard: `INFO`
**Mindestgröße für mehrteiligen Upload**
Parametername: `STREAM_MANAGER_EXPORTER_S3_DESTINATION_MULTIPART_UPLOAD_MIN_PART_SIZE_BYTES`
Die Mindestgröße (in Byte) eines Teils in einem mehrteiligen Upload auf Amazon S3. Stream Manager verwendet diese Einstellung und die Größe der Eingabedatei, um zu bestimmen, wie Daten in einer mehrteiligen PUT-Anfrage gebündelt werden. Der Standard- und Mindestwert ist `5242880` Byte (5 MB).
Stream Manager verwendet die `sizeThresholdForMultipartUploadBytes` Eigenschaft des Streams, um zu bestimmen, ob ein- oder mehrteiliger Upload nach Amazon S3 exportiert werden soll. Benutzerdefinierte Greengrass-Komponenten legen diesen Schwellenwert fest, wenn sie einen Stream erstellen, der nach Amazon S3 exportiert wird. Der Standardschwellenwert ist 5 MB.
## Weitere Informationen finden Sie auch unter
+ [Datenströme auf Greengrass-Kerngeräten verwalten](manage-data-streams.md)
+ [Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
# Erstellen Sie benutzerdefinierte Komponenten, die den Stream-Manager verwenden
Verwenden Sie Stream Manager in benutzerdefinierten Greengrass-Komponenten, um IoT-Gerätedaten zu speichern, zu verarbeiten und zu exportieren. Verwenden Sie die Verfahren und Beispiele in diesem Abschnitt, um Komponentenrezepte, Artefakte und Anwendungen zu erstellen, die mit dem Stream Manager funktionieren. Weitere Informationen zum Entwickeln und Testen von Komponenten finden Sie unter[AWS IoT Greengrass Komponenten erstellen](create-components.md).
**Topics**
+ [Definieren Sie Komponentenrezepte, die den Stream-Manager verwenden](#stream-manager-recipes)
+ [Stellen Sie im Anwendungscode eine Connect zum Stream Manager her](#connect-to-stream-manager)
## Definieren Sie Komponentenrezepte, die den Stream-Manager verwenden
Um den Stream-Manager in einer benutzerdefinierten Komponente zu verwenden, müssen Sie die `aws.greengrass.StreamManager` Komponente als Abhängigkeit definieren. Sie müssen auch das Stream Manager SDK bereitstellen. Führen Sie die folgenden Aufgaben aus, um das Stream Manager SDK in der Sprache Ihrer Wahl herunterzuladen und zu verwenden.
### Verwenden Sie das Stream Manager SDK for Java
Das Stream Manager SDK for Java ist als JAR-Datei verfügbar, mit der Sie Ihre Komponente kompilieren können. Anschließend können Sie eine Anwendungs-JAR erstellen, die das Stream Manager-SDK enthält, die Anwendungs-JAR als Komponentenartefakt definieren und die Anwendungs-JAR im Komponentenlebenszyklus ausführen.
**So verwenden Sie das Stream Manager SDK for Java**
1. Laden Sie die [Stream Manager SDK for Java JAR-Datei](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-java/blob/main/sdk/aws-greengrass-stream-manager-sdk-java.jar) herunter.
1. Gehen Sie wie folgt vor, um Komponentenartefakte aus Ihrer Java-Anwendung und der Stream Manager SDK-JAR-Datei zu erstellen:
+ Erstellen Sie Ihre Anwendung als JAR-Datei, die das Stream Manager-SDK-JAR enthält, und führen Sie diese JAR-Datei in Ihrem Komponentenrezept aus.
+ Definieren Sie das Stream Manager SDK JAR als Komponentenartefakt. Fügen Sie dieses Artefakt dem Klassenpfad hinzu, wenn Sie Ihre Anwendung in Ihrem Komponentenrezept ausführen.
Ihr Komponentenrezept könnte wie das folgende Beispiel aussehen. Diese Komponente führt eine modifizierte Version des Beispiels [StreamManagerS3.java](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-java/blob/main/samples/StreamManagerS3/src/main/java/com/amazonaws/greengrass/examples/StreamManagerS3.java) aus, das das Stream Manager SDK JAR `StreamManagerS3.jar` enthält.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.StreamManagerS3Java",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses stream manager to upload a file to an S3 bucket.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0"
}
},
"Manifests": [
{
"Lifecycle": {
"Run": "java -jar {artifacts:path}/StreamManagerS3.jar"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Java/1.0.0/StreamManagerS3.jar"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.StreamManagerS3Java
ComponentVersion: 1.0.0
ComponentDescription: Uses stream manager to upload a file to an S3 bucket.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: "^2.0.0"
Manifests:
- Lifecycle:
Run: java -jar {artifacts:path}/StreamManagerS3.jar
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Java/1.0.0/StreamManagerS3.jar
```
------
Weitere Informationen zum Entwickeln und Testen von Komponenten finden Sie unter[AWS IoT Greengrass Komponenten erstellen](create-components.md).
### Verwenden Sie das Stream Manager SDK für Python
Das Stream Manager SDK für Python ist als Quellcode verfügbar, den Sie in Ihre Komponente aufnehmen können. Erstellen Sie eine ZIP-Datei des Stream Manager SDK, definieren Sie die ZIP-Datei als Komponentenartefakt und installieren Sie die Anforderungen des SDK im Komponentenlebenszyklus.
**So verwenden Sie das Stream Manager SDK für Python**
1. Klonen Sie das [aws-greengrass-stream-manager-sdk-python-Repository](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-python) oder laden Sie es herunter.
```
git clone git@github.com:aws-greengrass/aws-greengrass-stream-manager-sdk-python.git
```
1. Erstellen Sie eine ZIP-Datei, die den `stream_manager` Ordner enthält, der den Quellcode des Stream Manager SDK für Python enthält. Sie können diese ZIP-Datei als Komponentenartefakt bereitstellen, das die AWS IoT Greengrass Core-Software bei der Installation Ihrer Komponente entpackt. Gehen Sie wie folgt vor:
1. Öffnen Sie den Ordner, der das Repository enthält, das Sie im vorherigen Schritt geklont oder heruntergeladen haben.
```
cd aws-greengrass-stream-manager-sdk-python
```
1. Komprimieren `stream_manager` Sie den Ordner in eine ZIP-Datei mit dem Namen`stream_manager_sdk.zip`.
------
#### [ Linux or Unix ]
```
zip -rv stream_manager_sdk.zip stream_manager
```
------
#### [ Windows Command Prompt (CMD) ]
```
tar -acvf stream_manager_sdk.zip stream_manager
```
------
#### [ PowerShell ]
```
Compress-Archive stream_manager stream_manager_sdk.zip
```
------
1. Stellen Sie sicher, dass die `stream_manager_sdk.zip` Datei den `stream_manager` Ordner und seinen Inhalt enthält. Führen Sie den folgenden Befehl aus, um den Inhalt der ZIP-Datei aufzulisten.
------
#### [ Linux or Unix ]
```
unzip -l stream_manager_sdk.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
tar -tf stream_manager_sdk.zip
```
------
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
Archive: aws-greengrass-stream-manager-sdk-python/stream_manager.zip
Length Date Time Name
--------- ---------- ----- ----
0 02-24-2021 20:45 stream_manager/
913 02-24-2021 20:45 stream_manager/__init__.py
9719 02-24-2021 20:45 stream_manager/utilinternal.py
1412 02-24-2021 20:45 stream_manager/exceptions.py
1004 02-24-2021 20:45 stream_manager/util.py
0 02-24-2021 20:45 stream_manager/data/
254463 02-24-2021 20:45 stream_manager/data/__init__.py
26515 02-24-2021 20:45 stream_manager/streammanagerclient.py
--------- -------
294026 8 files
```
1. Kopieren Sie die Stream Manager SDK-Artefakte in den Artefaktordner Ihrer Komponente. Zusätzlich zur Stream Manager SDK-ZIP-Datei verwendet Ihre Komponente die `requirements.txt` SDK-Datei, um die Abhängigkeiten des Stream Manager SDK zu installieren. *\$1/greengrass-components*Ersetzen Sie es durch den Pfad zu dem Ordner, den Sie für die lokale Entwicklung verwenden.
------
#### [ Linux or Unix ]
```
cp {stream_manager_sdk.zip,requirements.txt} ~/greengrass-components/artifacts/com.example.StreamManagerS3Python/1.0.0/
```
------
#### [ Windows Command Prompt (CMD) ]
```
robocopy . %USERPROFILE%\greengrass-components\artifacts\com.example.StreamManagerS3Python\1.0.0 stream_manager_sdk.zip
robocopy . %USERPROFILE%\greengrass-components\artifacts\com.example.StreamManagerS3Python\1.0.0 requirements.txt
```
------
#### [ PowerShell ]
```
cp .\stream_manager_sdk.zip,.\requirements.txt ~\greengrass-components\artifacts\com.example.StreamManagerS3Python\1.0.0\
```
------
1. Erstellen Sie Ihr Komponentenrezept. Gehen Sie im Rezept wie folgt vor:
1. Definieren Sie `stream_manager_sdk.zip` und `requirements.txt` als Artefakte.
1. Definieren Sie Ihre Python-Anwendung als Artefakt.
1. Installieren Sie im Installationszyklus die Stream Manager SDK-Anforderungen von`requirements.txt`.
1. Fügen Sie im Run-Lebenszyklus das Stream Manager-SDK an Ihre Python-Anwendung an `PYTHONPATH` und führen Sie sie aus.
Ihr Komponentenrezept könnte wie das folgende Beispiel aussehen. Diese Komponente führt das Beispiel [stream\$1manager\$1s3.py](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-python/blob/main/samples/stream_manager_s3.py) aus.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.StreamManagerS3Python",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses stream manager to upload a file to an S3 bucket.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "pip3 install --user -r {artifacts:path}/requirements.txt",
"Run": "export PYTHONPATH=$PYTHONPATH:{artifacts:decompressedPath}/stream_manager_sdk; python3 {artifacts:path}/stream_manager_s3.py"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_sdk.zip",
"Unarchive": "ZIP"
},
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_s3.py"
},
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/requirements.txt"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"install": "pip3 install --user -r {artifacts:path}/requirements.txt",
"Run": "set \"PYTHONPATH=%PYTHONPATH%;{artifacts:decompressedPath}/stream_manager_sdk\" & py -3 {artifacts:path}/stream_manager_s3.py"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_sdk.zip",
"Unarchive": "ZIP"
},
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_s3.py"
},
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/requirements.txt"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.StreamManagerS3Python
ComponentVersion: 1.0.0
ComponentDescription: Uses stream manager to upload a file to an S3 bucket.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: "^2.0.0"
Manifests:
- Platform:
os: linux
Lifecycle:
install: pip3 install --user -r {artifacts:path}/requirements.txt
Run: |
export PYTHONPATH=$PYTHONPATH:{artifacts:decompressedPath}/stream_manager_sdk
python3 {artifacts:path}/stream_manager_s3.py
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_sdk.zip
Unarchive: ZIP
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_s3.py
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/requirements.txt
- Platform:
os: windows
Lifecycle:
install: pip3 install --user -r {artifacts:path}/requirements.txt
Run: |
set "PYTHONPATH=%PYTHONPATH%;{artifacts:decompressedPath}/stream_manager_sdk"
py -3 {artifacts:path}/stream_manager_s3.py
Artifacts:
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_sdk.zip
Unarchive: ZIP
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/stream_manager_s3.py
- URI: s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3Python/1.0.0/requirements.txt
```
------
Weitere Informationen zum Entwickeln und Testen von Komponenten finden Sie unter[AWS IoT Greengrass Komponenten erstellen](create-components.md).
### Verwenden Sie das Stream Manager SDK für JavaScript
Das Stream Manager SDK für JavaScript ist als Quellcode verfügbar, den Sie in Ihre Komponente aufnehmen können. Erstellen Sie eine ZIP-Datei des Stream Manager SDK, definieren Sie die ZIP-Datei als Komponentenartefakt und installieren Sie das SDK im Komponentenlebenszyklus.
**Um das Stream Manager SDK zu verwenden für JavaScript**
1. Klonen Sie das [aws-greengrass-stream-manager-sdk-js-Repository](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-js) oder laden Sie es herunter.
```
git clone git@github.com:aws-greengrass/aws-greengrass-stream-manager-sdk-js.git
```
1. Erstellen Sie eine ZIP-Datei, die den `aws-greengrass-stream-manager-sdk` Ordner enthält, der den Quellcode des Stream Manager-SDK für enthält. JavaScript Sie können diese ZIP-Datei als Komponentenartefakt bereitstellen, das die AWS IoT Greengrass Core-Software bei der Installation Ihrer Komponente entpackt. Gehen Sie wie folgt vor:
1. Öffnen Sie den Ordner, der das Repository enthält, das Sie im vorherigen Schritt geklont oder heruntergeladen haben.
```
cd aws-greengrass-stream-manager-sdk-js
```
1. Komprimieren `aws-greengrass-stream-manager-sdk` Sie den Ordner in eine ZIP-Datei mit dem Namen`stream-manager-sdk.zip`.
------
#### [ Linux or Unix ]
```
zip -rv stream-manager-sdk.zip aws-greengrass-stream-manager-sdk
```
------
#### [ Windows Command Prompt (CMD) ]
```
tar -acvf stream-manager-sdk.zip aws-greengrass-stream-manager-sdk
```
------
#### [ PowerShell ]
```
Compress-Archive aws-greengrass-stream-manager-sdk stream-manager-sdk.zip
```
------
1. Stellen Sie sicher, dass die `stream-manager-sdk.zip` Datei den `aws-greengrass-stream-manager-sdk` Ordner und seinen Inhalt enthält. Führen Sie den folgenden Befehl aus, um den Inhalt der ZIP-Datei aufzulisten.
------
#### [ Linux or Unix ]
```
unzip -l stream-manager-sdk.zip
```
------
#### [ Windows Command Prompt (CMD) ]
```
tar -tf stream-manager-sdk.zip
```
------
Die Ausgabe sollte in etwa folgendermaßen aussehen:
```
Archive: stream-manager-sdk.zip
Length Date Time Name
--------- ---------- ----- ----
0 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/
369 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/package.json
1017 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/util.js
8374 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/utilInternal.js
1937 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/exceptions.js
0 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/data/
353343 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/data/index.js
22599 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/client.js
216 02-24-2021 22:36 aws-greengrass-stream-manager-sdk/index.js
--------- -------
387855 9 files
```
1. Kopieren Sie das Stream Manager SDK-Artefakt in den Artefaktordner Ihrer Komponente. *\$1/greengrass-components*Ersetzen Sie es durch den Pfad zu dem Ordner, den Sie für die lokale Entwicklung verwenden.
------
#### [ Linux or Unix ]
```
cp stream-manager-sdk.zip ~/greengrass-components/artifacts/com.example.StreamManagerS3JS/1.0.0/
```
------
#### [ Windows Command Prompt (CMD) ]
```
robocopy . %USERPROFILE%\greengrass-components\artifacts\com.example.StreamManagerS3JS\1.0.0 stream-manager-sdk.zip
```
------
#### [ PowerShell ]
```
cp .\stream-manager-sdk.zip ~\greengrass-components\artifacts\com.example.StreamManagerS3JS\1.0.0\
```
------
1. Erstellen Sie Ihr Komponentenrezept. Gehen Sie im Rezept wie folgt vor:
1. Definiere `stream-manager-sdk.zip` als Artefakt.
1. Definieren Sie Ihre JavaScript Anwendung als Artefakt.
1. Installieren Sie im Installationszyklus das Stream Manager-SDK vom `stream-manager-sdk.zip` Artefakt aus. `npm install`Mit diesem Befehl wird ein `node_modules` Ordner erstellt, der das Stream Manager-SDK und seine Abhängigkeiten enthält.
1. Fügen Sie im Run-Lebenszyklus den `node_modules` Ordner an `NODE_PATH` und führen Sie Ihre JavaScript Anwendung aus.
Ihr Komponentenrezept könnte wie das folgende Beispiel aussehen. Diese Komponente führt das [StreamManagerS3-Beispiel](https://github.com/aws-greengrass/aws-greengrass-stream-manager-sdk-js/blob/main/samples/StreamManagerS3/index.js) aus.
------
#### [ JSON ]
```
{
"RecipeFormatVersion": "2020-01-25",
"ComponentName": "com.example.StreamManagerS3JS",
"ComponentVersion": "1.0.0",
"ComponentDescription": "Uses stream manager to upload a file to an S3 bucket.",
"ComponentPublisher": "Amazon",
"ComponentDependencies": {
"aws.greengrass.StreamManager": {
"VersionRequirement": "^2.0.0"
}
},
"Manifests": [
{
"Platform": {
"os": "linux"
},
"Lifecycle": {
"install": "npm install {artifacts:decompressedPath}/stream-manager-sdk/aws-greengrass-stream-manager-sdk",
"Run": "export NODE_PATH=$NODE_PATH:{work:path}/node_modules; node {artifacts:path}/index.js"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3JS/1.0.0/stream-manager-sdk.zip",
"Unarchive": "ZIP"
},
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3JS/1.0.0/index.js"
}
]
},
{
"Platform": {
"os": "windows"
},
"Lifecycle": {
"install": "npm install {artifacts:decompressedPath}/stream-manager-sdk/aws-greengrass-stream-manager-sdk",
"Run": "set \"NODE_PATH=%NODE_PATH%;{work:path}/node_modules\" & node {artifacts:path}/index.js"
},
"Artifacts": [
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3JS/1.0.0/stream-manager-sdk.zip",
"Unarchive": "ZIP"
},
{
"URI": "s3://amzn-s3-demo-bucket/artifacts/com.example.StreamManagerS3JS/1.0.0/index.js"
}
]
}
]
}
```
------
#### [ YAML ]
```
---
RecipeFormatVersion: '2020-01-25'
ComponentName: com.example.StreamManagerS3JS
ComponentVersion: 1.0.0
ComponentDescription: Uses stream manager to upload a file to an S3 bucket.
ComponentPublisher: Amazon
ComponentDependencies:
aws.greengrass.StreamManager:
VersionRequirement: "^2.0.0"
Manifests:
- Platform:
os: linux
Lifecycle:
install: npm install {artifacts:decompressedPath}/stream-manager-sdk/aws-greengrass-stream-manager-sdk
Run: |
export NODE_PATH=$NODE_PATH:{work:path}/node_modules
node {artifacts:path}/index.js
Artifacts:
- URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.StreamManagerS3JS/1.0.0/stream-manager-sdk.zip
Unarchive: ZIP
- URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.StreamManagerS3JS/1.0.0/index.js
- Platform:
os: windows
Lifecycle:
install: npm install {artifacts:decompressedPath}/stream-manager-sdk/aws-greengrass-stream-manager-sdk
Run: |
set "NODE_PATH=%NODE_PATH%;{work:path}/node_modules"
node {artifacts:path}/index.js
Artifacts:
- URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.StreamManagerS3JS/1.0.0/stream-manager-sdk.zip
Unarchive: ZIP
- URI: s3://DOC-EXAMPLE-BUCKET/artifacts/com.example.StreamManagerS3JS/1.0.0/index.js
```
------
Weitere Informationen zum Entwickeln und Testen von Komponenten finden Sie unter[AWS IoT Greengrass Komponenten erstellen](create-components.md).
## Stellen Sie im Anwendungscode eine Connect zum Stream Manager her
Um eine Verbindung zum Stream Manager in Ihrer Anwendung herzustellen, erstellen Sie eine Instanz von `StreamManagerClient` aus dem Stream Manager SDK. Dieser Client stellt über seinen Standardport 8088 oder den von Ihnen angegebenen Port eine Verbindung zur Stream Manager-Komponente her. Weitere Informationen zur Verwendung `StreamManagerClient` nach dem Erstellen einer Instanz finden Sie unter[Wird verwendet StreamManagerClient , um mit Streams zu arbeiten](work-with-streams.md).
**Example Beispiel: Connect zum Stream-Manager mit Standardport herstellen**
```
import com.amazonaws.greengrass.streammanager.client.StreamManagerClient;
public class MyStreamManagerComponent {
void connectToStreamManagerWithDefaultPort() {
StreamManagerClient client = StreamManagerClientFactory.standard().build();
// Use the client.
}
}
```
```
from stream_manager import (
StreamManagerClient
)
def connect_to_stream_manager_with_default_port():
client = StreamManagerClient()
# Use the client.
```
```
const {
StreamManagerClient
} = require('aws-greengrass-stream-manager-sdk');
function connectToStreamManagerWithDefaultPort() {
const client = new StreamManagerClient();
// Use the client.
}
```
**Example Beispiel: Connect zum Stream-Manager mit einem nicht standardmäßigen Port her**
Wenn Sie den Stream-Manager mit einem anderen Port als dem Standardport konfigurieren, müssen Sie die [Interprozesskommunikation](interprocess-communication.md) verwenden, um den Port aus der Komponentenkonfiguration abzurufen.
Der `port` Konfigurationsparameter enthält den Wert, den Sie `STREAM_MANAGER_SERVER_PORT` bei der Bereitstellung von Stream Manager angeben.
```
void connectToStreamManagerWithCustomPort() {
EventStreamRPCConnection eventStreamRpcConnection = IPCUtils.getEventStreamRpcConnection();
GreengrassCoreIPCClient greengrassCoreIPCClient = new GreengrassCoreIPCClient(eventStreamRpcConnection);
List keyPath = new ArrayList<>();
keyPath.add("port");
GetConfigurationRequest request = new GetConfigurationRequest();
request.setComponentName("aws.greengrass.StreamManager");
request.setKeyPath(keyPath);
GetConfigurationResponse response =
greengrassCoreIPCClient.getConfiguration(request, Optional.empty()).getResponse().get();
String port = response.getValue().get("port").toString();
System.out.print("Stream Manager is running on port: " + port);
final StreamManagerClientConfig config = StreamManagerClientConfig.builder()
.serverInfo(StreamManagerServerInfo.builder().port(Integer.parseInt(port)).build()).build();
StreamManagerClient client = StreamManagerClientFactory.standard().withClientConfig(config).build();
// Use the client.
}
```
```
import awsiot.greengrasscoreipc
from awsiot.greengrasscoreipc.model import (
GetConfigurationRequest
)
from stream_manager import (
StreamManagerClient
)
TIMEOUT = 10
def connect_to_stream_manager_with_custom_port():
# Use IPC to get the port from the stream manager component configuration.
ipc_client = awsiot.greengrasscoreipc.connect()
request = GetConfigurationRequest()
request.component_name = "aws.greengrass.StreamManager"
request.key_path = ["port"]
operation = ipc_client.new_get_configuration()
operation.activate(request)
future_response = operation.get_response()
response = future_response.result(TIMEOUT)
stream_manager_port = str(response.value["port"])
# Use port to create a stream manager client.
stream_client = StreamManagerClient(port=stream_manager_port)
# Use the client.
```
# Wird verwendet StreamManagerClient , um mit Streams zu arbeiten
Benutzerdefinierte Greengrass-Komponenten, die auf dem Greengrass-Core-Gerät ausgeführt werden, können das `StreamManagerClient` Objekt im Stream Manager SDK verwenden, um Streams im [Stream Manager](manage-data-streams.md) zu erstellen und dann mit den Streams zu interagieren. Wenn eine Komponente einen Stream erstellt, definiert sie die AWS Cloud Ziele, die Priorisierung und andere Export- und Datenaufbewahrungsrichtlinien für den Stream. Um Daten an den Stream Manager zu senden, hängen Komponenten die Daten an den Stream an. Wenn ein Exportziel für den Stream definiert ist, exportiert der Stream Manager den Stream automatisch.
**Anmerkung**
In der Regel handelt es sich bei den Clients von Stream Manager um benutzerdefinierte Greengrass-Komponenten. Wenn Ihr Geschäftsszenario dies erfordert, können Sie auch zulassen, dass Prozesse, die keine Komponenten sind, die auf dem Greengrass-Kern ausgeführt werden (z. B. ein Docker-Container), mit dem Stream Manager interagieren. Weitere Informationen finden Sie unter [Client-Authentifizierung](manage-data-streams.md#stream-manager-security-client-authentication).
Die Auszüge in diesem Thema zeigen Ihnen, wie Clients `StreamManagerClient` Methoden aufrufen, um mit Streams zu arbeiten. Implementierungsdetails zu den Methoden und ihren Argumenten finden Sie unter den Links zur SDK-Referenz, die hinter jedem Codeausschnitt aufgeführt sind.
Wenn Sie den Stream-Manager in einer Lambda-Funktion verwenden, sollte Ihre Lambda-Funktion `StreamManagerClient` außerhalb des Funktionshandlers instanziiert werden. Wenn sie in dem Handler instanziiert wird, erstellt die Funktion bei jedem Aufruf eine `client` und eine Verbindung zum Stream-Manager.
**Anmerkung**
Wenn Sie `StreamManagerClient` in dem Handler instanziieren, müssen Sie die `close()`-Methode explizit aufrufen, wenn die `client` seine Arbeit abschließt. Andernfalls hält der `client` die Verbindung offen, und ein anderer Thread läuft, bis das Skript beendet wird.
`StreamManagerClient` unterstützt die folgenden Operationen:
+ [Erstellen eines Nachrichten-Streams](#streammanagerclient-create-message-stream)
+ [Anhängen einer Nachricht](#streammanagerclient-append-message)
+ [Lesen von Nachrichten](#streammanagerclient-read-messages)
+ [Auflisten von Streams](#streammanagerclient-list-streams)
+ [Beschreiben eines Nachrichten-Streams](#streammanagerclient-describe-message-stream)
+ [Nachrichtenstream aktualisieren](#streammanagerclient-update-message-stream)
+ [Löschen eines Nachrichten-Streams](#streammanagerclient-delete-message-stream)
## Erstellen eines Nachrichten-Streams
Um einen Stream zu erstellen, ruft eine benutzerdefinierte Greengrass-Komponente die Methode create auf und übergibt ein `MessageStreamDefinition` Objekt. Dieses Objekt gibt den eindeutigen Namen für den Stream an und definiert, wie der Stream-Manager mit neuen Daten umgehen soll, wenn die maximale Streamgröße erreicht ist. Sie können mit `MessageStreamDefinition` seinen Datentypen (z. B. `ExportDefinition`, `StrategyOnFull`, und `Persistence`) andere Stream-Eigenschaften definieren. Dazu zählen:
+ Das Ziel AWS IoT Analytics, Kinesis Data Streams und Amazon S3 S3-Ziele für automatische Exporte. AWS IoT SiteWise Weitere Informationen finden Sie unter [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md).
+ Export-Priorität. Stream-Manager exportiert Streams mit höherer Priorität vor Streams mit niedrigerer Priorität.
+ Maximale Batchgröße und Batch-Intervall für AWS IoT Analytics Kinesis Data Streams und AWS IoT SiteWise Ziele. Der Stream-Manager exportiert Nachrichten, wenn eine der Bedingungen erfüllt ist.
+ Time-to-live (TTL). Die Zeitspanne, um sicherzustellen, dass die Streamdaten für die Verarbeitung verfügbar sind. Sie sollten sicherstellen, dass die Daten innerhalb dieses Zeitraums verbraucht werden können. Dies ist keine Löschrichtlinie. Die Daten werden möglicherweise nicht unmittelbar nach dem TTL-Zeitraum gelöscht.
+ Streampersistenz. Wählen Sie, ob Streams im Dateisystem gespeichert werden sollen, um Daten über Core-Neustarts hinweg zu speichern oder Streams im Speicher zu speichern.
+ Startsequenznummer. Geben Sie die Sequenznummer der Nachricht an, die als Startnachricht im Export verwendet werden soll.
Weitere Informationen zu `MessageStreamDefinition` finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)im Java-SDK
+ [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)im SDK von Node.js
+ [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.MessageStreamDefinition)im Python-SDK
**Anmerkung**
`StreamManagerClient`bietet auch ein Zielziel, mit dem Sie Streams auf einen HTTP-Server exportieren können. Dieses Ziel dient nur zu Testzwecken. Es ist weder stabil noch wird es für die Verwendung in Produktionsumgebungen unterstützt.
Nachdem ein Stream erstellt wurde, können Ihre Greengrass-Komponenten [Nachrichten an den Stream anhängen](#streammanagerclient-append-message), um Daten für den Export zu senden, und [Nachrichten aus dem Stream für die lokale Verarbeitung lesen](#streammanagerclient-read-messages). Die Anzahl der Streams, die Sie erstellen, hängt von Ihren Hardwarefunktionen und Ihrem Geschäftsfall ab. Eine Strategie besteht darin, für jeden Zielkanal im AWS IoT Analytics oder Kinesis-Datenstream einen Stream zu erstellen. Sie können jedoch mehrere Ziele für einen Stream definieren. Ein Stream hat eine dauerhafte Lebensdauer.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
Das folgende Snippet erstellt einen Stream mit dem Namen `StreamName`. Es definiert Stream-Eigenschaften in den `MessageStreamDefinition` und untergeordneten Datentypen.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.create_message_stream(MessageStreamDefinition(
name="StreamName", # Required.
max_size=268435456, # Default is 256 MB.
stream_segment_size=16777216, # Default is 16 MB.
time_to_live_millis=None, # By default, no TTL is enabled.
strategy_on_full=StrategyOnFull.OverwriteOldestData, # Required.
persistence=Persistence.File, # Default is File.
flush_on_write=False, # Default is false.
export_definition=ExportDefinition( # Optional. Choose where/how the stream is exported to the AWS Cloud.
kinesis=None,
iot_analytics=None,
iot_sitewise=None,
s3_task_executor=None
)
))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [create\$1message\$1stream \$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.MessageStreamDefinition)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.create_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456L) // Default is 256 MB.
.withStreamSegmentSize(16777216L) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the AWS Cloud.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSitewise(null)
.withS3(null)
)
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: \$1 [createMessageStream[MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#createMessageStream-com.amazonaws.greengrass.streammanager.model.MessageStreamDefinition-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.createMessageStream(
new MessageStreamDefinition()
.withName("StreamName") // Required.
.withMaxSize(268435456) // Default is 256 MB.
.withStreamSegmentSize(16777216) // Default is 16 MB.
.withTimeToLiveMillis(null) // By default, no TTL is enabled.
.withStrategyOnFull(StrategyOnFull.OverwriteOldestData) // Required.
.withPersistence(Persistence.File) // Default is File.
.withFlushOnWrite(false) // Default is false.
.withExportDefinition( // Optional. Choose where/how the stream is exported to the AWS Cloud.
new ExportDefinition()
.withKinesis(null)
.withIotAnalytics(null)
.withIotSiteWise(null)
.withS3(null)
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: [createMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#createMessageStream)\$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)
------
Weitere Informationen zur Konfiguration von Exportzielen finden Sie unter[Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md).
## Anhängen einer Nachricht
Um Daten zum Export an den Stream Manager zu senden, hängen Ihre Greengrass-Komponenten die Daten an den Zielstream an. Das Exportziel bestimmt den Datentyp, der an diese Methode übergeben wird.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
#### AWS IoT Analytics oder Kinesis Data Streams Streams-Exportziele
Das folgende Snippet fügt eine Nachricht an den Stream namens `StreamName` an. Für AWS IoT Analytics unsere Kinesis Data Streams Streams-Ziele hängen Ihre Greengrass-Komponenten einen Datenblob an.
Für dieses Snippet gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
sequence_number = client.append_message(stream_name="StreamName", data=b'Arbitrary bytes data')
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [append\$1message](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
long sequenceNumber = client.appendMessage("StreamName", "Arbitrary byte array".getBytes());
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [appendMessage](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const sequenceNumber = await client.appendMessage("StreamName", Buffer.from("Arbitrary byte array"));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [appendMessage](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### AWS IoT SiteWise Ziele exportieren
Das folgende Snippet fügt eine Nachricht an den Stream namens `StreamName` an. Für AWS IoT SiteWise Ziele hängen Ihre Greengrass-Komponenten ein `PutAssetPropertyValueEntry` serialisiertes Objekt an. Weitere Informationen finden Sie unter [Exportieren nach AWS IoT SiteWise](stream-export-configurations.md#export-streams-to-sitewise).
**Anmerkung**
Wenn Sie Daten an senden AWS IoT SiteWise, müssen Ihre Daten die Anforderungen der Aktion erfüllen. `BatchPutAssetPropertyValue` Weitere Informationen finden Sie unter [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) in der *AWS IoT SiteWise -API-Referenz*.
Für dieses Snippet gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# SiteWise requires unique timestamps in all messages and also needs timestamps not earlier
# than 10 minutes in the past. Add some randomness to time and offset.
# Note: To create a new asset property data, you should use the classes defined in the
# greengrasssdk.stream_manager module.
time_in_nanos = TimeInNanos(
time_in_seconds=calendar.timegm(time.gmtime()) - random.randint(0, 60), offset_in_nanos=random.randint(0, 10000)
)
variant = Variant(double_value=random.random())
asset = [AssetPropertyValue(value=variant, quality=Quality.GOOD, timestamp=time_in_nanos)]
putAssetPropertyValueEntry = PutAssetPropertyValueEntry(entry_id=str(uuid.uuid4()), property_alias="PropertyAlias", property_values=asset)
sequence_number = client.append_message(stream_name="StreamName", Util.validate_and_serialize_to_json_bytes(putAssetPropertyValueEntry))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [append\$1message \$1 [PutAssetPropertyValueEntry](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.PutAssetPropertyValueEntry)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.append_message)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
Random rand = new Random();
// Note: To create a new asset property data, you should use the classes defined in the
// com.amazonaws.greengrass.streammanager.model.sitewise package.
List entries = new ArrayList<>() ;
// IoTSiteWise requires unique timestamps in all messages and also needs timestamps not earlier
// than 10 minutes in the past. Add some randomness to time and offset.
final int maxTimeRandomness = 60;
final int maxOffsetRandomness = 10000;
double randomValue = rand.nextDouble();
TimeInNanos timestamp = new TimeInNanos()
.withTimeInSeconds(Instant.now().getEpochSecond() - rand.nextInt(maxTimeRandomness))
.withOffsetInNanos((long) (rand.nextInt(maxOffsetRandomness)));
AssetPropertyValue entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
entries.add(entry);
PutAssetPropertyValueEntry putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(UUID.randomUUID().toString())
.withPropertyAlias("PropertyAlias")
.withPropertyValues(entries);
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [appendMessage \$1 [PutAssetPropertyValueEntry](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/sitewise/PutAssetPropertyValueEntry.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const maxTimeRandomness = 60;
const maxOffsetRandomness = 10000;
const randomValue = Math.random();
// Note: To create a new asset property data, you should use the classes defined in the
// aws-greengrass-core-sdk StreamManager module.
const timestamp = new TimeInNanos()
.withTimeInSeconds(Math.round(Date.now() / 1000) - Math.floor(Math.random() - maxTimeRandomness))
.withOffsetInNanos(Math.floor(Math.random() * maxOffsetRandomness));
const entry = new AssetPropertyValue()
.withValue(new Variant().withDoubleValue(randomValue))
.withQuality(Quality.GOOD)
.withTimestamp(timestamp);
const putAssetPropertyValueEntry = new PutAssetPropertyValueEntry()
.withEntryId(`${ENTRY_ID_PREFIX}${i}`)
.withPropertyAlias("PropertyAlias")
.withPropertyValues([entry]);
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(putAssetPropertyValueEntry));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [appendMessage \$1 [PutAssetPropertyValueEntry](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.PutAssetPropertyValueEntry.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage)
------
#### Amazon S3 S3-Exportziele
Das folgende Snippet hängt eine Exportaufgabe an den genannten Stream an. `StreamName` Für Amazon S3 S3-Ziele hängen Ihre Greengrass-Komponenten ein serialisiertes `S3ExportTaskDefinition` Objekt an, das Informationen über die Quell-Eingabedatei und das Amazon S3 S3-Zielobjekt enthält. Wenn das angegebene Objekt nicht existiert, erstellt Stream Manager es für Sie. Weitere Informationen finden Sie unter [Exportieren nach Amazon S3](stream-export-configurations.md#export-streams-to-s3).
Für dieses Snippet gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
------
#### [ Python ]
```
client = StreamManagerClient()
try:
# Append an Amazon S3 Task definition and print the sequence number.
s3_export_task_definition = S3ExportTaskDefinition(input_url="URLToFile", bucket="BucketName", key="KeyName")
sequence_number = client.append_message(stream_name="StreamName", Util.validate_and_serialize_to_json_bytes(s3_export_task_definition))
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
[Python-SDK-Referenz: [append\$1message \$1 S3](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.append_message) ExportTaskDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.S3ExportTaskDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
// Append an Amazon S3 export task definition and print the sequence number.
S3ExportTaskDefinition s3ExportTaskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
long sequenceNumber = client.appendMessage("StreamName", ValidateAndSerialize.validateAndSerializeToJsonBytes(s3ExportTaskDefinition));
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
[Java-SDK-Referenz: [appendMessage \$1 S3](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#appendMessage-java.lang.String-byte:A-) ExportTaskDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/S3ExportTaskDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
// Append an Amazon S3 export task definition and print the sequence number.
const taskDefinition = new S3ExportTaskDefinition()
.withBucket("BucketName")
.withKey("KeyName")
.withInputUrl("URLToFile");
const sequenceNumber = await client.appendMessage("StreamName", util.validateAndSerializeToJsonBytes(taskDefinition)));
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
[SDK-Referenz für Node.js: [appendMessage \$1 S3](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#appendMessage) ExportTaskDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskDefinition.html)
------
## Lesen von Nachrichten
Lesen Sie Nachrichten aus einem Stream.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
Das folgende Snippet liest Nachrichten aus dem Stream namens `StreamName`. Die Read-Methode verwendet ein optionales `ReadMessagesOptions`-Objekt, das die Sequenznummer angibt, von der aus mit dem Lesen begonnen werden soll, die minimale und maximale Anzahl zu lesen und ein Timeout für das Lesen von Nachrichten.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_list = client.read_messages(
stream_name="StreamName",
# By default, if no options are specified, it tries to read one message from the beginning of the stream.
options=ReadMessagesOptions(
desired_start_sequence_number=100,
# Try to read from sequence number 100 or greater. By default, this is 0.
min_message_count=10,
# Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
max_message_count=100, # Accept up to 100 messages. By default this is 1.
read_timeout_millis=5000
# Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
)
)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [read\$1messages \$1 [ReadMessagesOptions](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.ReadMessagesOptions)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
List messages = client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100L)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is raised. By default, this is 1.
.withMinMessageCount(10L)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100L)
// Try to wait at most 5 seconds for the min_messsage_count to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(Duration.ofSeconds(5L).toMillis())
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [readMessages \$1 [ReadMessagesOptions](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/ReadMessagesOptions.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messages = await client.readMessages("StreamName",
// By default, if no options are specified, it tries to read one message from the beginning of the stream.
new ReadMessagesOptions()
// Try to read from sequence number 100 or greater. By default this is 0.
.withDesiredStartSequenceNumber(100)
// Try to read 10 messages. If 10 messages are not available, then NotEnoughMessagesException is thrown. By default, this is 1.
.withMinMessageCount(10)
// Accept up to 100 messages. By default this is 1.
.withMaxMessageCount(100)
// Try to wait at most 5 seconds for the minMessageCount to be fulfilled. By default, this is 0, which immediately returns the messages or an exception.
.withReadTimeoutMillis(5 * 1000)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [readMessages \$1 [ReadMessagesOptions](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.ReadMessagesOptions.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------
## Auflisten von Streams
Ruft die Liste der Streams im Stream-Manager ab.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
Das folgende Snippet ruft eine Liste der Streams (nach Namen) im Stream-Manager ab.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_names = client.list_streams()
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [list\$1streams](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.list_streams)
------
#### [ Java ]
```
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
List streamNames = client.listStreams();
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [ListStreams](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#listStreams--)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const streams = await client.listStreams();
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [ListStreams](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#listStreams)
------
## Beschreiben eines Nachrichten-Streams
Ruft Metadaten zu einem Stream ab, einschließlich der Stream-Definition, -Größe und des Exportstatus.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
Das folgende Snippet ruft Metadaten über den Stream mit dem Namen `StreamName` ab, einschließlich Definition, Größe und Exporterstatus des Streams.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
stream_description = client.describe_message_stream(stream_name="StreamName")
if stream_description.export_statuses[0].error_message:
# The last export of export destination 0 failed with some error
# Here is the last sequence number that was successfully exported
stream_description.export_statuses[0].last_exported_sequence_number
if (stream_description.storage_status.newest_sequence_number >
stream_description.export_statuses[0].last_exported_sequence_number):
pass
# The end of the stream is ahead of the last exported sequence number
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [describe\$1message\$1stream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.describe_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
MessageStreamInfo description = client.describeMessageStream("StreamName");
String lastErrorMessage = description.getExportStatuses().get(0).getErrorMessage();
if (lastErrorMessage != null && !lastErrorMessage.equals("")) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.getExportStatuses().get(0).getLastExportedSequenceNumber();
}
if (description.getStorageStatus().getNewestSequenceNumber() >
description.getExportStatuses().get(0).getLastExportedSequenceNumber()) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [describeMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#describeMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const description = await client.describeMessageStream("StreamName");
const lastErrorMessage = description.exportStatuses[0].errorMessage;
if (lastErrorMessage) {
// The last export of export destination 0 failed with some error.
// Here is the last sequence number that was successfully exported.
description.exportStatuses[0].lastExportedSequenceNumber;
}
if (description.storageStatus.newestSequenceNumber >
description.exportStatuses[0].lastExportedSequenceNumber) {
// The end of the stream is ahead of the last exported sequence number.
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: [describeMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#describeMessageStream)
------
## Nachrichtenstream aktualisieren
Aktualisieren Sie die Eigenschaften eines vorhandenen Streams. Möglicherweise möchten Sie einen Stream aktualisieren, wenn sich Ihre Anforderungen nach der Erstellung des Streams ändern. Beispiel:
+ Fügen Sie eine neue [Exportkonfiguration](stream-export-configurations.md) für ein AWS Cloud Ziel hinzu.
+ Erhöhen Sie die maximale Größe eines Streams, um zu ändern, wie Daten exportiert oder aufbewahrt werden. Beispielsweise kann die Stream-Größe in Kombination mit Ihrer Strategie bei vollen Einstellungen dazu führen, dass Daten gelöscht oder zurückgewiesen werden, bevor der Stream-Manager sie verarbeiten kann.
+ Unterbrechen Sie Exporte und setzen Sie sie fort, z. B. wenn Exportaufgaben lange dauern und Sie Ihre Upload-Daten rationieren möchten.
Ihre Greengrass-Komponenten folgen diesem allgemeinen Prozess, um einen Stream zu aktualisieren:
1. [Rufen Sie die Beschreibung des Streams ab.](#streammanagerclient-describe-message-stream)
1. Aktualisieren Sie die Zieleigenschaften der entsprechenden `MessageStreamDefinition` und untergeordneten Objekte.
1. Übergeben Sie das Aktualisierte`MessageStreamDefinition`. Stellen Sie sicher, dass Sie die vollständigen Objektdefinitionen für den aktualisierten Stream angeben. Undefinierte Eigenschaften werden auf die Standardwerte zurückgesetzt.
Sie können die Sequenznummer der Nachricht angeben, die als Startnachricht im Export verwendet werden soll.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
Das folgende Snippet aktualisiert den Stream mit dem Namen. `StreamName` Es aktualisiert mehrere Eigenschaften eines Streams, der in Kinesis Data Streams exportiert wird.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
message_stream_info = client.describe_message_stream(STREAM_NAME)
message_stream_info.definition.max_size=536870912
message_stream_info.definition.stream_segment_size=33554432
message_stream_info.definition.time_to_live_millis=3600000
message_stream_info.definition.strategy_on_full=StrategyOnFull.RejectNewData
message_stream_info.definition.persistence=Persistence.Memory
message_stream_info.definition.flush_on_write=False
message_stream_info.definition.export_definition.kinesis=
[KinesisConfig(
# Updating Export definition to add a Kinesis Stream configuration.
identifier=str(uuid.uuid4()), kinesis_stream_name=str(uuid.uuid4()))]
client.update_message_stream(message_stream_info.definition)
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [updateMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.update_message_stream)\$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.MessageStreamDefinition)
------
#### [ Java ]
```
try (final StreamManagerClient client = GreengrassClientBuilder.streamManagerClient().build()) {
MessageStreamInfo messageStreamInfo = client.describeMessageStream(STREAM_NAME);
// Update the message stream with new values.
client.updateMessageStream(
messageStreamInfo.getDefinition()
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912L) // Update Max Size to 512 MB.
.withStreamSegmentSize(33554432L) // Update Segment Size to 32 MB.
.withFlushOnWrite(true) // Update flush on write to true.
.withPersistence(Persistence.Memory) // Update the persistence to Memory.
.withTimeToLiveMillis(3600000L) // Update TTL to 1 hour.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the AWS Cloud.
messageStreamInfo.getDefinition().getExportDefinition().
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis(new ArrayList() {{
add(new KinesisConfig()
.withIdentifier(EXPORT_IDENTIFIER)
.withKinesisStreamName("test"));
}})
);
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [update\$1message\$1stream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#updateMessageStream-java.lang.String-) \$1 [MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/MessageStreamDefinition.html)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
const messageStreamInfo = await c.describeMessageStream(STREAM_NAME);
await client.updateMessageStream(
messageStreamInfo.definition
// Max Size update should be greater than initial Max Size defined in Create Message Stream request
.withMaxSize(536870912) // Default is 256 MB. Updating Max Size to 512 MB.
.withStreamSegmentSize(33554432) // Default is 16 MB. Updating Segment Size to 32 MB.
.withTimeToLiveMillis(3600000) // By default, no TTL is enabled. Update TTL to 1 hour.
.withStrategyOnFull(StrategyOnFull.RejectNewData) // Required. Updating Strategy on full to reject new data.
.withPersistence(Persistence.Memory) // Default is File. Update the persistence to Memory
.withFlushOnWrite(true) // Default is false. Updating to true.
.withExportDefinition(
// Optional. Choose where/how the stream is exported to the AWS Cloud.
messageStreamInfo.definition.exportDefinition
// Updating Export definition to add a Kinesis Stream configuration.
.withKinesis([new KinesisConfig().withIdentifier(uuidv4()).withKinesisStreamName(uuidv4())])
)
);
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: \$1 [updateMessageStream[MessageStreamDefinition](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.MessageStreamDefinition.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#updateMessageStream)
------
### Einschränkungen für die Aktualisierung von Streams
Die folgenden Einschränkungen gelten für die Aktualisierung von Streams. Sofern in der folgenden Liste nicht anders angegeben, werden Aktualisierungen sofort wirksam.
+ Sie können die Persistenz eines Streams nicht aktualisieren. Um dieses Verhalten zu ändern, [löschen Sie den Stream](#streammanagerclient-delete-message-stream) und [erstellen Sie einen Stream](#streammanagerclient-create-message-stream), der die neue Persistenzrichtlinie definiert.
+ Sie können die maximale Größe eines Streams nur unter den folgenden Bedingungen aktualisieren:
+ Die maximale Größe muss größer oder gleich der aktuellen Größe des Streams sein. Um diese Informationen zu finden, [beschreiben Sie den Stream](#streammanagerclient-describe-message-stream) und überprüfen Sie dann den Speicherstatus des zurückgegebenen `MessageStreamInfo` Objekts.
+ Die maximale Größe muss größer oder gleich der Segmentgröße des Streams sein.
+ Sie können die Stream-Segmentgröße auf einen Wert aktualisieren, der unter der maximalen Größe des Streams liegt. Die aktualisierte Einstellung gilt für neue Segmente.
+ Aktualisierungen der Eigenschaft Time to Live (TTL) gelten für neue Anfügevorgänge. Wenn Sie diesen Wert verringern, löscht Stream Manager möglicherweise auch vorhandene Segmente, die die TTL überschreiten.
+ Aktualisierungen der Strategie für die vollständige Eigenschaft gelten auch für neue Anfügevorgänge. Wenn Sie die Strategie so einrichten, dass die ältesten Daten überschrieben werden, überschreibt Stream Manager möglicherweise auch bestehende Segmente, die auf der neuen Einstellung basieren.
+ Aktualisierungen der Eigenschaft „Flush on Write“ gelten für neue Nachrichten.
+ Aktualisierungen der Exportkonfigurationen gelten für neue Exporte. Die Aktualisierungsanforderung muss alle Exportkonfigurationen enthalten, die Sie unterstützen möchten. Andernfalls löscht der Stream Manager sie.
+ Wenn Sie eine Exportkonfiguration aktualisieren, geben Sie den Bezeichner der Ziel-Exportkonfiguration an.
+ Um eine Exportkonfiguration hinzuzufügen, geben Sie eine eindeutige Kennung für die neue Exportkonfiguration an.
+ Um eine Exportkonfiguration zu löschen, lassen Sie die Exportkonfiguration weg.
+ Um die Startsequenznummer einer Exportkonfiguration in einem Stream zu [aktualisieren](#streammanagerclient-update-message-stream), müssen Sie einen Wert angeben, der kleiner als die letzte Sequenznummer ist. Um diese Informationen zu finden, [beschreiben Sie den Stream](#streammanagerclient-describe-message-stream) und überprüfen Sie dann den Speicherstatus des zurückgegebenen `MessageStreamInfo` Objekts.
## Löschen eines Nachrichten-Streams
Löscht einen Stream. Wenn Sie einen Stream löschen, werden alle gespeicherten Daten für den Stream von der Festplatte gelöscht.
### Voraussetzungen
Für diesen Vorgang gelten die folgenden Anforderungen:
+ Mindestversion des Stream Manager-SDK: Python: 1.1.0 \$1 Java: 1.1.0 \$1 Node.js: 1.1.0
### Beispiele
Das folgende Snippet löscht den Stream mit dem Namen `StreamName`.
------
#### [ Python ]
```
client = StreamManagerClient()
try:
client.delete_message_stream(stream_name="StreamName")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [deleteMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.delete_message_stream)
------
#### [ Java ]
```
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
client.deleteMessageStream("StreamName");
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java-SDK-Referenz: [delete\$1message\$1stream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#deleteMessageStream-java.lang.String-)
------
#### [ Node.js ]
```
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
await client.deleteMessageStream("StreamName");
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
SDK-Referenz für Node.js: [deleteMessageStream](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#deleteMessageStream)
------
## Weitere Informationen finden Sie auch unter
+ [Datenströme auf Greengrass-Kerngeräten verwalten](manage-data-streams.md)
+ [AWS IoT Greengrass Streammanager konfigurieren](configure-stream-manager.md)
+ [Konfigurationen für unterstützte AWS Cloud Ziele exportieren](stream-export-configurations.md)
+ `StreamManagerClient`in der Stream Manager SDK-Referenz:
+ [Python](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html)
+ [Java](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html)
+ [Node.js](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html)
# Konfigurationen für unterstützte AWS Cloud Ziele exportieren
Benutzerdefinierte Greengrass-Komponenten werden `StreamManagerClient` im Stream Manager SDK verwendet, um mit dem Stream Manager zu interagieren. Wenn eine Komponente einen Stream [erstellt oder einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) [aktualisiert](work-with-streams.md#streammanagerclient-create-message-stream), übergibt sie ein `MessageStreamDefinition` Objekt, das die Stream-Eigenschaften darstellt, einschließlich der Exportdefinition. Das `ExportDefinition` Objekt enthält die für den Stream definierten Exportkonfigurationen. Stream Manager verwendet diese Exportkonfigurationen, um zu bestimmen, wo und wie der Stream exportiert werden soll.
![\[Objektmodelldiagramm des ExportDefinition Eigenschaftstyps.\]](http://docs.aws.amazon.com/de_de/greengrass/v2/developerguide/images/stream-manager-exportconfigs.png)
Sie können keine oder mehr Exportkonfigurationen für einen Stream definieren, einschließlich mehrerer Exportkonfigurationen für einen einzelnen Zieltyp. Sie können beispielsweise einen Stream in zwei AWS IoT Analytics Kanäle und einen Kinesis-Datenstream exportieren.
Bei fehlgeschlagenen Exportversuchen versucht Stream Manager kontinuierlich, Daten in Intervallen von bis zu fünf Minuten zu exportieren. AWS Cloud Für die Anzahl der Wiederholungsversuche gibt es keine Obergrenze.
**Anmerkung**
`StreamManagerClient`bietet auch ein Zielziel, mit dem Sie Streams auf einen HTTP-Server exportieren können. Dieses Ziel dient nur zu Testzwecken. Es ist weder stabil noch wird es für die Verwendung in Produktionsumgebungen unterstützt.
**Topics**
+ [AWS IoT Analytics Kanäle](#export-to-iot-analytics)
+ [Amazon Kinesis Kinesis-Datenströme](#export-to-kinesis)
+ [AWS IoT SiteWise Eigenschaften von Vermögenswerten](#export-to-iot-sitewise)
+ [Amazon-S3-Objekte](#export-to-s3)
Sie sind für die Wartung dieser AWS Cloud Ressourcen verantwortlich.
## AWS IoT Analytics Kanäle
Stream Manager unterstützt automatische Exporte nach AWS IoT Analytics. AWS IoT Analytics ermöglicht es Ihnen, erweiterte Analysen Ihrer Daten durchzuführen, um Geschäftsentscheidungen zu treffen und Modelle für maschinelles Lernen zu verbessern. Weitere Informationen finden Sie unter [Was ist AWS IoT Analytics?](https://docs.aws.amazon.com/iotanalytics/latest/userguide/welcome.html) im *AWS IoT Analytics Benutzerhandbuch*.
Im Stream Manager SDK verwenden Ihre Greengrass-Komponenten die, `IoTAnalyticsConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [Io TAnalytics Config](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.IoTAnalyticsConfig) im Python-SDK
+ [Io TAnalytics Config](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTAnalyticsConfig.html) im Java SDK
+ [Io TAnalytics Config](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTAnalyticsConfig.html) im SDK Node.js
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Die eingegebenen Zielkanäle AWS IoT Analytics müssen sich im selben AWS-Konto und AWS-Region wie das Greengrass-Core-Gerät befinden.
+ Sie [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md) müssen die `iotanalytics:BatchPutMessage` Erlaubnis erteilen, Kanäle anzusprechen. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"iotanalytics:BatchPutMessage"
],
"Resource": [
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_1_name",
"arn:aws:iotanalytics:us-east-1:123456789012:channel/channel_2_name"
]
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
### Exportieren nach AWS IoT Analytics
Um einen Stream zu erstellen, in den exportiert wird AWS IoT Analytics, [erstellen Ihre Greengrass-Komponenten einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) mit einer Exportdefinition, die ein oder mehrere `IoTAnalyticsConfig` Objekte enthält. Dieses Objekt definiert Exporteinstellungen wie den Zielkanal, die Batchgröße, das Batch-Intervall und die Priorität.
Wenn Ihre Greengrass-Komponenten Daten von Geräten empfangen, [hängen sie Nachrichten](work-with-streams.md#streammanagerclient-append-message), die einen Datenblock enthalten, an den Zielstream an.
Anschließend exportiert der Stream Manager die Daten auf der Grundlage der Batch-Einstellungen und der Priorität, die in den Exportkonfigurationen des Streams definiert sind.
## Amazon Kinesis Kinesis-Datenströme
Stream Manager unterstützt automatische Exporte nach Amazon Kinesis Data Streams. Kinesis Data Streams wird häufig verwendet, um große Datenmengen zu aggregieren und in ein Data Warehouse oder MapReduce Cluster zu laden. Weitere Informationen finden Sie unter [Was ist Amazon Kinesis Data Streams](https://docs.aws.amazon.com/streams/latest/dev/what-is-this-service.html)? im *Amazon Kinesis Developer Guide*.
Im Stream Manager SDK verwenden Ihre Greengrass-Komponenten die, `KinesisConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [KinesisConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.KinesisConfig)im Python-SDK
+ [KinesisConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/KinesisConfig.html)im Java-SDK
+ [KinesisConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.KinesisConfig.html)im SDK von Node.js
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Ziel-Streams in Kinesis Data Streams müssen sich im selben AWS-Konto und AWS-Region wie das Greengrass-Core-Gerät befinden.
+ (Empfohlen) Stream Manager v2.2.1 verbessert die Leistung beim Exportieren von Streams zu Kinesis Data Streams Streams-Zielen. Um die Verbesserungen in dieser neuesten Version zu nutzen, aktualisieren Sie Ihre [Stream Manager-Komponente](stream-manager-component.md) auf v2.2.1 und verwenden Sie die `kinesis:ListShards` Richtlinie in der [Greengrass-Token-Austauschrolle](device-service-role.md).
+ Sie [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md) müssen die `kinesis:PutRecords` Erlaubnis zum Targeting von Datenströmen gewähren. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"kinesis:PutRecords"
],
"Resource": [
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_1_name",
"arn:aws:kinesis:us-east-1:123456789012:stream/stream_2_name"
]
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
### In Kinesis Data Streams exportieren
Um einen Stream zu erstellen, der in Kinesis Data Streams exportiert wird, [erstellen Ihre Greengrass-Komponenten einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) mit einer Exportdefinition, die ein oder mehrere `KinesisConfig` Objekte enthält. Dieses Objekt definiert Exporteinstellungen wie den Zieldatenstream, die Batchgröße, das Batch-Intervall und die Priorität.
Wenn Ihre Greengrass-Komponenten Daten von Geräten empfangen, [hängen sie Nachrichten](work-with-streams.md#streammanagerclient-append-message), die einen Datenblock enthalten, an den Zielstream an. Anschließend exportiert der Stream Manager die Daten auf der Grundlage der Batch-Einstellungen und der Priorität, die in den Exportkonfigurationen des Streams definiert sind.
Stream Manager generiert eine eindeutige, zufällige UUID als Partitionsschlüssel für jeden Datensatz, der auf Amazon Kinesis hochgeladen wird.
## AWS IoT SiteWise Eigenschaften von Vermögenswerten
Stream Manager unterstützt automatische Exporte nach AWS IoT SiteWise. AWS IoT SiteWise ermöglicht das Sammeln, Organisieren und Analysieren von Daten aus Industrieanlagen in großem Maßstab. Weitere Informationen finden Sie unter [Was ist AWS IoT SiteWise?](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/what-is-sitewise.html) im *AWS IoT SiteWise Benutzerhandbuch*.
Im Stream Manager SDK verwenden Ihre Greengrass-Komponenten die, `IoTSiteWiseConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [Io TSite WiseConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.IoTSiteWiseConfig) im Python-SDK
+ [Io TSite WiseConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/IoTSiteWiseConfig.html) im Java-SDK
+ [Io TSite WiseConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.IoTSiteWiseConfig.html) im SDK von Node.js
**Anmerkung**
AWS stellt auch AWS IoT SiteWise Komponenten bereit, die eine vorgefertigte Lösung bieten, mit der Sie Daten aus OPC-UA-Quellen streamen können. Weitere Informationen finden Sie unter [SiteWise IoT-OPC-UA-Kollektor](iotsitewise-opcua-collector-component.md).
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Die Eigenschaften des Zielobjekts in AWS IoT SiteWise müssen sich im selben AWS-Konto und AWS-Region wie das Greengrass-Core-Gerät befinden.
**Anmerkung**
Eine Liste der AWS IoT SiteWise unterstützten AWS-Region s finden Sie unter [AWS IoT SiteWise Endpunkte und Kontingente](https://docs.aws.amazon.com/general/latest/gr/iot-sitewise.html#iot-sitewise_region) in der *AWS Allgemeinen* Referenz.
+ Sie [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md) müssen die `iotsitewise:BatchPutAssetPropertyValue` Erlaubnis erteilen, auf Asset-Eigenschaften zu zielen. In der folgenden Beispielrichtlinie wird der `iotsitewise:assetHierarchyPath` Bedingungsschlüssel verwendet, um Zugriff auf ein Zielstamm-Asset und dessen untergeordnete Objekte zu gewähren. Sie können das `Condition` aus der Richtlinie entfernen, um Zugriff auf alle Ihre AWS IoT SiteWise Ressourcen zu gewähren oder einzelne Ressourcen anzugeben ARNs .
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iotsitewise:BatchPutAssetPropertyValue",
"Resource": "*",
"Condition": {
"StringLike": {
"iotsitewise:assetHierarchyPath": [
"/root node asset ID",
"/root node asset ID/*"
]
}
}
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
Wichtige Sicherheitsinformationen finden Sie im *AWS IoT SiteWise Benutzerhandbuch* unter [ BatchPutAssetPropertyValue Autorisierung](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/security_iam_service-with-iam.html#security_iam_service-with-iam-id-based-policies-batchputassetpropertyvalue-action).
### Exportieren nach AWS IoT SiteWise
Um einen Stream zu erstellen, in den exportiert wird AWS IoT SiteWise, [erstellen Ihre Greengrass-Komponenten einen Stream](work-with-streams.md#streammanagerclient-create-message-stream) mit einer Exportdefinition, die ein oder mehrere `IoTSiteWiseConfig` Objekte enthält. Dieses Objekt definiert Exporteinstellungen wie Batchgröße, Batch-Intervall und Priorität.
Wenn Ihre Greengrass-Komponenten Asset-Eigenschaftsdaten von Geräten empfangen, hängen sie Nachrichten, die die Daten enthalten, an den Zielstream an. Nachrichten sind JSON-serialisierte `PutAssetPropertyValueEntry` Objekte, die Eigenschaftswerte für eine oder mehrere Asset-Eigenschaften enthalten. Weitere Informationen finden Sie unter [Nachricht für Exportziele anhängen](work-with-streams.md#streammanagerclient-append-message-sitewise). AWS IoT SiteWise
**Anmerkung**
Wenn Sie Daten an senden AWS IoT SiteWise, müssen Ihre Daten die Anforderungen der `BatchPutAssetPropertyValue` Aktion erfüllen. Weitere Informationen finden Sie unter [BatchPutAssetPropertyValue](https://docs.aws.amazon.com/iot-sitewise/latest/APIReference/API_BatchPutAssetPropertyValue.html) in der *AWS IoT SiteWise -API-Referenz*.
Anschließend exportiert Stream Manager die Daten auf der Grundlage der Batch-Einstellungen und der Priorität, die in den Exportkonfigurationen des Streams definiert sind.
Sie können Ihre Stream-Manager-Einstellungen und die Greengrass-Komponentenlogik anpassen, um Ihre Exportstrategie zu entwerfen. Beispiel:
+ Für Exporte fast in Echtzeit sollten Sie niedrige Einstellungen für Batchgröße und Intervalle festlegen und die Daten an den Stream anhängen, wenn sie empfangen werden.
+ Um die Batchverarbeitung zu optimieren, Bandbreitenbeschränkungen zu minimieren oder Kosten zu minimieren, können Ihre Greengrass-Komponenten die für eine einzelne Anlageneigenschaft empfangenen timestamp-quality-value (TQV) -Datenpunkte bündeln, bevor sie an den Stream angehängt werden. Eine Strategie besteht darin, Einträge für bis zu 10 verschiedene Kombinationen von Immobilien und Vermögenswerten oder Eigenschaftsaliasnamen in einer Nachricht zu bündeln, anstatt mehr als einen Eintrag für dieselbe Immobilie zu senden. [Dies hilft dem Streammanager, die Kontingente einzuhalten.AWS IoT SiteWise](https://docs.aws.amazon.com/iot-sitewise/latest/userguide/quotas.html)
## Amazon-S3-Objekte
Stream Manager unterstützt automatische Exporte nach Amazon S3. Sie können Amazon S3 verwenden, um große Datenmengen zu speichern und abzurufen. Weitere Informationen finden Sie unter [Was ist Amazon S3?](https://docs.aws.amazon.com/AmazonS3/latest/dev/Welcome.html) im *Amazon Simple Storage Service Developer Guide*.
Im Stream Manager SDK verwenden Ihre Greengrass-Komponenten die, `S3ExportTaskExecutorConfig` um die Exportkonfiguration für diesen Zieltyp zu definieren. Weitere Informationen finden Sie in der SDK-Referenz für Ihre Zielsprache:
+ [S3 ExportTaskExecutorConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.S3ExportTaskExecutorConfig) im Python-SDK
+ [S3 ExportTaskExecutorConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/export/S3ExportTaskExecutorConfig.html) im Java-SDK
+ [S3 ExportTaskExecutorConfig](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.S3ExportTaskExecutorConfig.html) im SDK von Node.js
### Voraussetzungen
Für dieses Exportziel gelten die folgenden Anforderungen:
+ Die Amazon S3 S3-Ziel-Buckets müssen sich auf demselben Gerät AWS-Konto wie das Greengrass-Core-Gerät befinden.
+ Wenn eine Lambda-Funktion, die im **Greengrass-Container-Modus** ausgeführt wird, Eingabedateien in ein Eingabedateiverzeichnis schreibt, müssen Sie das Verzeichnis als Volume im Container mit Schreibberechtigungen mounten. Dadurch wird sichergestellt, dass die Dateien in das Root-Dateisystem geschrieben werden und für die Stream-Manager-Komponente, die außerhalb des Containers ausgeführt wird, sichtbar sind.
+ Wenn eine Docker-Container-Komponente Eingabedateien in ein Eingabedateiverzeichnis schreibt, müssen Sie das Verzeichnis als Volume im Container mit Schreibberechtigungen mounten. Dadurch wird sichergestellt, dass die Dateien in das Root-Dateisystem geschrieben werden und für die Stream-Manager-Komponente, die außerhalb des Containers ausgeführt wird, sichtbar sind.
+ Sie [Autorisieren Sie Kerngeräte für die Interaktion mit Diensten AWS](device-service-role.md) müssen die folgenden Berechtigungen für die Ziel-Buckets gewähren. Beispiel:
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:AbortMultipartUpload",
"s3:ListMultipartUploadParts"
],
"Resource": [
"arn:aws:s3:::bucket-1-name/*",
"arn:aws:s3:::bucket-2-name/*"
]
}
]
}
```
------
Sie können detaillierten oder bedingten Zugriff auf Ressourcen gewähren, indem Sie beispielsweise ein `*` Platzhalter-Benennungsschema verwenden. Weitere Informationen finden Sie im IAM-Benutzerhandbuch unter [Hinzufügen und Entfernen von *IAM-Richtlinien*](https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies_manage-attach-detach.html).
### Exportieren nach Amazon S3
Um einen Stream zu erstellen, der nach Amazon S3 exportiert, verwenden Ihre Greengrass-Komponenten das `S3ExportTaskExecutorConfig` Objekt, um die Exportrichtlinie zu konfigurieren. Die Richtlinie definiert Exporteinstellungen, wie z. B. den Schwellenwert und die Priorität für mehrteilige Uploads. Für Amazon S3 S3-Exporte lädt der Stream Manager Daten hoch, die er aus lokalen Dateien auf dem Kerngerät liest. Um einen Upload zu starten, hängen Ihre Greengrass-Komponenten eine Exportaufgabe an den Zielstream an. Die Exportaufgabe enthält Informationen über die Eingabedatei und das Amazon S3 S3-Zielobjekt. Stream Manager führt Aufgaben in der Reihenfolge aus, in der sie an den Stream angehängt werden.
**Anmerkung**
Der Ziel-Bucket muss bereits in Ihrem AWS-Konto vorhanden sein. Wenn ein Objekt für den angegebenen Schlüssel nicht existiert, erstellt Stream Manager das Objekt für Sie.
Stream Manager verwendet die Eigenschaft „Schwellenwert für mehrteilige Uploads“, die Einstellung für die [Mindestgröße von Teilen](configure-stream-manager.md#stream-manager-minimum-part-size) und die Größe der Eingabedatei, um zu bestimmen, wie Daten hochgeladen werden. Der Schwellenwert für mehrteilige Uploads muss größer oder gleich der Mindestgröße für Teile sein. Wenn Sie Daten parallel hochladen möchten, können Sie mehrere Streams erstellen.
Die Schlüssel, die Ihre Amazon S3 S3-Zielobjekte angeben, können gültige [ DateTimeFormatterJava-Zeichenfolgen](https://docs.oracle.com/javase/8/docs/api/java/time/format/DateTimeFormatter.html) in `!{timestamp:value}` Platzhaltern enthalten. Sie können diese Zeitstempel-Platzhalter verwenden, um Daten in Amazon S3 auf der Grundlage der Uhrzeit zu partitionieren, zu der die Eingabedateidaten hochgeladen wurden. Der folgende Schlüsselname wird beispielsweise in einen Wert wie aufgelöst. `my-key/2020/12/31/data.txt`
```
my-key/!{timestamp:YYYY}/!{timestamp:MM}/!{timestamp:dd}/data.txt
```
**Anmerkung**
Wenn Sie den Exportstatus für einen Stream überwachen möchten, erstellen Sie zuerst einen Status-Stream und konfigurieren Sie dann den Exportstream so, dass er ihn verwendet. Weitere Informationen finden Sie unter [Überwachen Sie die Exportaufgaben](#monitor-export-status-s3).
#### Eingabedaten verwalten
Sie können Code verfassen, den IoT-Anwendungen verwenden, um den Lebenszyklus der Eingabedaten zu verwalten. Der folgende Beispiel-Workflow zeigt, wie Sie Greengrass-Komponenten verwenden können, um diese Daten zu verwalten.
1. Ein lokaler Prozess empfängt Daten von Geräten oder Peripheriegeräten und schreibt die Daten dann in Dateien in einem Verzeichnis auf dem Kerngerät. Dies sind die Eingabedateien für den Stream-Manager.
1. Eine Greengrass-Komponente scannt das Verzeichnis und [hängt eine Exportaufgabe](work-with-streams.md#streammanagerclient-append-message-export-task) an den Zielstream an, wenn eine neue Datei erstellt wird. Die Aufgabe ist ein JSON-serialisiertes `S3ExportTaskDefinition` Objekt, das die URL der Eingabedatei, den Amazon S3 S3-Ziel-Bucket und -Schlüssel sowie optionale Benutzermetadaten angibt.
1. Stream Manager liest die Eingabedatei und exportiert die Daten in der Reihenfolge der angehängten Aufgaben nach Amazon S3. Der Ziel-Bucket muss bereits in Ihrem AWS-Konto vorhanden sein. Wenn ein Objekt für den angegebenen Schlüssel nicht existiert, erstellt Stream Manager das Objekt für Sie.
1. Die Greengrass-Komponente [liest Nachrichten](work-with-streams.md#streammanagerclient-read-messages) aus einem Status-Stream, um den Exportstatus zu überwachen. Nachdem die Exportaufgaben abgeschlossen sind, kann die Greengrass-Komponente die entsprechenden Eingabedateien löschen. Weitere Informationen finden Sie unter [Überwachen Sie die Exportaufgaben](#monitor-export-status-s3).
### Überwachen Sie die Exportaufgaben
Sie können Code verfassen, den IoT-Anwendungen verwenden, um den Status Ihrer Amazon S3 S3-Exporte zu überwachen. Ihre Greengrass-Komponenten müssen einen Status-Stream erstellen und dann den Export-Stream so konfigurieren, dass Status-Updates in den Status-Stream geschrieben werden. Ein einziger Status-Stream kann Statusaktualisierungen von mehreren Streams empfangen, die nach Amazon S3 exportiert werden.
[Erstellen Sie zunächst einen Stream](work-with-streams.md#streammanagerclient-create-message-stream), der als Status-Stream verwendet werden soll. Sie können die Größe und die Aufbewahrungsrichtlinien für den Stream konfigurieren, um die Lebensdauer der Statusmeldungen zu steuern. Beispiel:
+ Stellen `Persistence` Sie `Memory` diese Option ein, wenn Sie die Statusmeldungen nicht speichern möchten.
+ Auf `StrategyOnFull` einstellen, `OverwriteOldestData` damit neue Statusmeldungen nicht verloren gehen.
Erstellen oder aktualisieren Sie dann den Exportstream, um den Status-Stream zu verwenden. Legen Sie insbesondere die Statuskonfigurationseigenschaft der `S3ExportTaskExecutorConfig` Exportkonfiguration des Streams fest. Diese Einstellung weist den Stream-Manager an, Statusmeldungen über die Exportaufgaben in den Status-Stream zu schreiben. Geben Sie im `StatusConfig` Objekt den Namen des Status-Streams und den Grad der Ausführlichkeit an. Die folgenden unterstützten Werte reichen von am wenigsten ausführlich () bis zu den ausführlichsten Werten (`ERROR`). `TRACE` Der Standardwert ist `INFO`.
+ `ERROR`
+ `WARN`
+ `INFO`
+ `DEBUG`
+ `TRACE`
Der folgende Beispiel-Workflow zeigt, wie Greengrass-Komponenten einen Status-Stream verwenden könnten, um den Exportstatus zu überwachen.
1. Wie im vorherigen Workflow beschrieben, [hängt eine Greengrass-Komponente eine Exportaufgabe an einen](work-with-streams.md#streammanagerclient-append-message-export-task) Stream an, der so konfiguriert ist, dass er Statusmeldungen über Exportaufgaben in einen Status-Stream schreibt. Die Anfügeoperation gibt eine Sequenznummer zurück, die die Aufgaben-ID darstellt.
1. Eine Greengrass-Komponente [liest Nachrichten](work-with-streams.md#streammanagerclient-read-messages) sequentiell aus dem Status-Stream und filtert die Nachrichten dann basierend auf dem Streamnamen und der Task-ID oder basierend auf einer Exportaufgabeneigenschaft aus dem Nachrichtenkontext. Die Greengrass-Komponente kann beispielsweise nach der Eingabedatei-URL der Exportaufgabe filtern, die durch das `S3ExportTaskDefinition` Objekt im Nachrichtenkontext dargestellt wird.
Die folgenden Statuscodes geben an, dass eine Exportaufgabe den Status „Abgeschlossen“ erreicht hat:
+ `Success`. Der Upload wurde erfolgreich abgeschlossen.
+ `Failure`. Stream Manager ist auf einen Fehler gestoßen, z. B. ist der angegebene Bucket nicht vorhanden. Nachdem Sie das Problem behoben haben, können Sie die Exportaufgabe erneut an den Stream anhängen.
+ `Canceled`. Die Aufgabe wurde beendet, weil die Stream- oder Exportdefinition gelöscht wurde oder der Zeitraum time-to-live (TTL) der Aufgabe abgelaufen ist.
**Anmerkung**
Die Aufgabe kann auch den Status `InProgress` oder `Warning` haben. Stream Manager gibt Warnungen aus, wenn ein Ereignis einen Fehler zurückgibt, der die Ausführung der Aufgabe nicht beeinträchtigt. Wenn beispielsweise ein teilweiser Upload nicht bereinigt werden kann, wird eine Warnung zurückgegeben.
1. Nachdem die Exportaufgaben abgeschlossen sind, kann die Greengrass-Komponente die entsprechenden Eingabedateien löschen.
Das folgende Beispiel zeigt, wie eine Greengrass-Komponente Statusmeldungen lesen und verarbeiten könnte.
------
#### [ Python ]
```
import time
from stream_manager import (
ReadMessagesOptions,
Status,
StatusConfig,
StatusLevel,
StatusMessage,
StreamManagerClient,
)
from stream_manager.util import Util
client = StreamManagerClient()
try:
# Read the statuses from the export status stream
is_file_uploaded_to_s3 = False
while not is_file_uploaded_to_s3:
try:
messages_list = client.read_messages(
"StatusStreamName", ReadMessagesOptions(min_message_count=1, read_timeout_millis=1000)
)
for message in messages_list:
# Deserialize the status message first.
status_message = Util.deserialize_json_bytes_to_obj(message.payload, StatusMessage)
# Check the status of the status message. If the status is "Success",
# the file was successfully uploaded to S3.
# If the status was either "Failure" or "Cancelled", the server was unable to upload the file to S3.
# We will print the message for why the upload to S3 failed from the status message.
# If the status was "InProgress", the status indicates that the server has started uploading
# the S3 task.
if status_message.status == Status.Success:
logger.info("Successfully uploaded file at path " + file_url + " to S3.")
is_file_uploaded_to_s3 = True
elif status_message.status == Status.Failure or status_message.status == Status.Canceled:
logger.info(
"Unable to upload file at path " + file_url + " to S3. Message: " + status_message.message
)
is_file_uploaded_to_s3 = True
time.sleep(5)
except StreamManagerException:
logger.exception("Exception while running")
except StreamManagerException:
pass
# Properly handle errors.
except ConnectionError or asyncio.TimeoutError:
pass
# Properly handle errors.
```
Python-SDK-Referenz: [read\$1messages \$1 [StatusMessage](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.data.html#stream_manager.data.StatusMessage)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-python/_apidoc/stream_manager.streammanagerclient.html#stream_manager.streammanagerclient.StreamManagerClient.read_messages)
------
#### [ Java ]
```
import com.amazonaws.greengrass.streammanager.client.StreamManagerClient;
import com.amazonaws.greengrass.streammanager.client.StreamManagerClientFactory;
import com.amazonaws.greengrass.streammanager.client.utils.ValidateAndSerialize;
import com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions;
import com.amazonaws.greengrass.streammanager.model.Status;
import com.amazonaws.greengrass.streammanager.model.StatusConfig;
import com.amazonaws.greengrass.streammanager.model.StatusLevel;
import com.amazonaws.greengrass.streammanager.model.StatusMessage;
try (final StreamManagerClient client = StreamManagerClientFactory.standard().build()) {
try {
boolean isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
List messages = client.readMessages("StatusStreamName",
new ReadMessagesOptions().withMinMessageCount(1L).withReadTimeoutMillis(1000L));
for (Message message : messages) {
// Deserialize the status message first.
StatusMessage statusMessage = ValidateAndSerialize.deserializeJsonBytesToObj(message.getPayload(), StatusMessage.class);
// Check the status of the status message. If the status is "Success", the file was successfully uploaded to S3.
// If the status was either "Failure" or "Canceled", the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (Status.Success.equals(statusMessage.getStatus())) {
System.out.println("Successfully uploaded file at path " + FILE_URL + " to S3.");
isS3UploadComplete = true;
} else if (Status.Failure.equals(statusMessage.getStatus()) || Status.Canceled.equals(statusMessage.getStatus())) {
System.out.println(String.format("Unable to upload file at path %s to S3. Message %s",
statusMessage.getStatusContext().getS3ExportTaskDefinition().getInputUrl(),
statusMessage.getMessage()));
sS3UploadComplete = true;
}
}
} catch (StreamManagerException ignored) {
} finally {
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
Thread.sleep(5000);
}
} catch (e) {
// Properly handle errors.
}
} catch (StreamManagerException e) {
// Properly handle exception.
}
```
Java SDK-Referenz: [readMessages \$1 [StatusMessage](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/model/StatusMessage.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-java/com/amazonaws/greengrass/streammanager/client/StreamManagerClient.html#readMessages-java.lang.String-com.amazonaws.greengrass.streammanager.model.ReadMessagesOptions-)
------
#### [ Node.js ]
```
const {
StreamManagerClient, ReadMessagesOptions,
Status, StatusConfig, StatusLevel, StatusMessage,
util,
} = require(*'aws-greengrass-stream-manager-sdk'*);
const client = new StreamManagerClient();
client.onConnected(async () => {
try {
let isS3UploadComplete = false;
while (!isS3UploadComplete) {
try {
// Read the statuses from the export status stream
const messages = await c.readMessages("StatusStreamName",
new ReadMessagesOptions()
.withMinMessageCount(1)
.withReadTimeoutMillis(1000));
messages.forEach((message) => {
// Deserialize the status message first.
const statusMessage = util.deserializeJsonBytesToObj(message.payload, StatusMessage);
// Check the status of the status message. If the status is 'Success', the file was successfully uploaded to S3.
// If the status was either 'Failure' or 'Cancelled', the server was unable to upload the file to S3.
// We will print the message for why the upload to S3 failed from the status message.
// If the status was "InProgress", the status indicates that the server has started uploading the S3 task.
if (statusMessage.status === Status.Success) {
console.log(`Successfully uploaded file at path ${FILE_URL} to S3.`);
isS3UploadComplete = true;
} else if (statusMessage.status === Status.Failure || statusMessage.status === Status.Canceled) {
console.log(`Unable to upload file at path ${FILE_URL} to S3. Message: ${statusMessage.message}`);
isS3UploadComplete = true;
}
});
// Sleep for sometime for the S3 upload task to complete before trying to read the status message.
await new Promise((r) => setTimeout(r, 5000));
} catch (e) {
// Ignored
}
} catch (e) {
// Properly handle errors.
}
});
client.onError((err) => {
// Properly handle connection errors.
// This is called only when the connection to the StreamManager server fails.
});
```
Node.js SDK-Referenz: [readMessages \$1 [StatusMessage](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StatusMessage.html)](https://aws-greengrass.github.io/aws-greengrass-stream-manager-sdk-js/aws-greengrass-core-sdk.StreamManager.StreamManagerClient.html#readMessages)
------